@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/runtime-semantics/DestructuringAssignmentEvaluation.mts

@@ -0,0 +1,306 @@
+import {
+  JSStringValue, ReferenceRecord, Value, type PropertyKeyValue,
+} from '../value.mts';
+import {
+  IsAnonymousFunctionDefinition,
+  IsIdentifierRef,
+  StringValue,
+  type FunctionDeclaration,
+} from '../static-semantics/all.mts';
+import {
+  Evaluate, type PlainEvaluator, type StatementEvaluator,
+} from '../evaluator.mts';
+import {
+  Q, X,
+  Completion,
+  AbruptCompletion,
+  NormalCompletion,
+  EnsureCompletion,
+} from '../completion.mts';
+import { OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  Evaluate_PropertyName,
+  NamedEvaluation,
+  refineLeftHandSideExpression,
+} from './all.mts';
+import { surroundingAgent } from '#self';
+import {
+  ArrayCreate,
+  CopyDataProperties,
+  CreateDataPropertyOrThrow,
+  GetIterator,
+  GetV,
+  GetValue,
+  IteratorClose,
+  IteratorStep,
+  OrdinaryObjectCreate,
+  PutValue,
+  ResolveBinding,
+  RequireObjectCoercible,
+  ToString,
+  F,
+  Assert,
+  type IteratorRecord,
+  IteratorStepValue,
+} from '#self';
+
+// ObjectAssignmentPattern :
+//  `{` `}`
+//  `{` AssignmentPropertyList `}`
+//  `{` AssignmentPropertyList `,` `}`
+//  `{` AssignmentPropertyList `,` AssignmentRestProperty? `}`
+function* DestructuringAssignmentEvaluation_ObjectAssignmentPattern({ AssignmentPropertyList, AssignmentRestProperty }: ParseNode.ObjectAssignmentPattern, value: Value): PlainEvaluator {
+  // 1. Perform ? RequireObjectCoercible(value).
+  Q(RequireObjectCoercible(value));
+  // 2. Perform ? PropertyDestructuringAssignmentEvaluation for AssignmentPropertyList using value as the argument.
+  const excludedNames: readonly PropertyKeyValue[] = Q(yield* PropertyDestructuringAssignmentEvaluation(AssignmentPropertyList, value));
+  if (AssignmentRestProperty) {
+    Q(yield* RestDestructuringAssignmentEvaluation(AssignmentRestProperty, value, excludedNames));
+  }
+  // 3. Return NormalCompletion(empty).
+  return NormalCompletion(undefined);
+}
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-restdestructuringassignmentevaluation */
+// AssignmentRestProperty : `...` DestructuringAssignmentTarget
+function* RestDestructuringAssignmentEvaluation({ DestructuringAssignmentTarget }: ParseNode.AssignmentRestProperty, value: Value, excludedNames: readonly PropertyKeyValue[]): StatementEvaluator {
+  // 1. Let lref be the result of evaluating DestructuringAssignmentTarget.
+  const lref = Q(yield* Evaluate(DestructuringAssignmentTarget));
+  Q(lref);
+  // 3. Let restObj be OrdinaryObjectCreate(%Object.prototype%).
+  const restObj = OrdinaryObjectCreate(surroundingAgent.intrinsic('%Object.prototype%'));
+  // 4. Perform ? CopyDataProperties(restObj, value, excludedNames).
+  Q(yield* CopyDataProperties(restObj, value, excludedNames));
+  // 5. Return PutValue(lref, restObj).
+  return yield* PutValue(lref, restObj);
+}
+
+function* PropertyDestructuringAssignmentEvaluation(AssignmentPropertyList: ParseNode.ObjectAssignmentPattern['AssignmentPropertyList'], value: Value): PlainEvaluator<PropertyKeyValue[]> {
+  const propertyNames: PropertyKeyValue[] = [];
+  for (const AssignmentProperty of AssignmentPropertyList) {
+    if ('IdentifierReference' in AssignmentProperty) {
+      // 1. Let P be StringValue of IdentifierReference.
+      const P = StringValue(AssignmentProperty.IdentifierReference);
+      // 2. Let lref be ? ResolveBinding(P).
+      const lref = Q(yield* ResolveBinding(P, undefined, AssignmentProperty.IdentifierReference.strict));
+      // 3. Let v be ? GetV(value, P).
+      let v = Q(yield* GetV(value, P));
+      // 4. If Initializer? is present and v is undefined, then
+      if (AssignmentProperty.Initializer && v === Value.undefined) {
+        // a. If IsAnonymousFunctionDefinition(Initializer) is true, then
+        if (IsAnonymousFunctionDefinition(AssignmentProperty.Initializer)) {
+          // i. Set v to the result of performing NamedEvaluation for Initializer with argument P.
+          v = Q(yield* NamedEvaluation(AssignmentProperty.Initializer as FunctionDeclaration, P));
+        } else { // b. Else,
+          // i. Let defaultValue be the result of evaluating Initializer.
+          const defaultValue = Q(yield* Evaluate(AssignmentProperty.Initializer));
+          // ii. Set v to ? GetValue(defaultValue)
+          v = Q(yield* GetValue(defaultValue));
+        }
+      }
+      // 5. Perform ? PutValue(lref, v).
+      Q(yield* PutValue(lref, v));
+      // 6. Return a new List containing P.
+      propertyNames.push(P);
+    } else {
+      Assert('PropertyName' in AssignmentProperty);
+      // 1. Let name be the result of evaluating PropertyName.
+      const name = yield* Evaluate_PropertyName(AssignmentProperty.PropertyName!);
+      Q(name);
+      // 3. Perform ? KeyedDestructuringAssignmentEvaluation of AssignmentElement with value and name as the arguments.
+      Q(yield* KeyedDestructuringAssignmentEvaluation(AssignmentProperty.AssignmentElement, value, name as PropertyKeyValue));
+      // 4. Return a new List containing name.
+      propertyNames.push(name as PropertyKeyValue);
+    }
+  }
+  return propertyNames;
+}
+
+// AssignmentElement : DestructuringAssignmentTarget Initializer?
+function* KeyedDestructuringAssignmentEvaluation({
+  DestructuringAssignmentTarget,
+  Initializer,
+}: ParseNode.AssignmentElement, value: Value, propertyName: PropertyKeyValue) {
+  // 1. If DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral, then
+  let lref;
+  if (DestructuringAssignmentTarget.type !== 'ObjectLiteral'
+      && DestructuringAssignmentTarget.type !== 'ArrayLiteral') {
+    // a. Let lref be the result of evaluating DestructuringAssignmentTarget.
+    lref = Q(yield* Evaluate(DestructuringAssignmentTarget));
+  }
+  // 2. Let v be ? GetV(value, propertyName).
+  const v = Q(yield* GetV(value, propertyName));
+  // 3. If Initializer is present and v is undefined, then
+  let rhsValue: Value;
+  if (Initializer && v === Value.undefined) {
+    // a. If IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of DestructuringAssignmentTarget are both true, then
+    if (IsAnonymousFunctionDefinition(Initializer) && IsIdentifierRef(DestructuringAssignmentTarget)) {
+      // i. Let rhsValue be NamedEvaluation of Initializer with argument GetReferencedName(lref).
+      rhsValue = Q(yield* NamedEvaluation(Initializer as FunctionDeclaration, (lref as ReferenceRecord).ReferencedName as JSStringValue));
+    } else {
+      // i. Let defaultValue be the result of evaluating Initializer.
+      const defaultValue = Q(yield* Evaluate(Initializer));
+      // ii. Let rhsValue be ? GetValue(defaultValue).
+      rhsValue = Q(yield* GetValue(defaultValue));
+    }
+  } else { // 4. Else, let rhsValue be v.
+    rhsValue = v;
+  }
+  // 5. If DestructuringAssignmentTarget is an ObjectLiteral or an ArrayLiteral, then
+  if (DestructuringAssignmentTarget.type === 'ObjectLiteral'
+      || DestructuringAssignmentTarget.type === 'ArrayLiteral') {
+    // a. Let assignmentPattern be the AssignmentPattern that is covered by DestructuringAssignmentTarget.
+    const assignmentPattern = refineLeftHandSideExpression(DestructuringAssignmentTarget) as ParseNode.ObjectAssignmentPattern | ParseNode.ArrayAssignmentPattern;
+    // b. Return the result of performing DestructuringAssignmentEvaluation of assignmentPattern with rhsValue as the argument.
+    return yield* DestructuringAssignmentEvaluation(assignmentPattern, X(rhsValue));
+  }
+  // 6. Return ? PutValue(lref, rhsValue).
+  return Q(yield* PutValue(X(lref)!, rhsValue));
+}
+
+// ArrayAssignmentPattern :
+//   `[` `]`
+//   `[` AssignmentElementList `]`
+//   `[` AssignmentElementList `,` AssignmentRestElement? `]`
+function* DestructuringAssignmentEvaluation_ArrayAssignmentPattern({ AssignmentElementList, AssignmentRestElement }: ParseNode.ArrayAssignmentPattern, value: Value) {
+  // 1. Let iteratorRecord be ? GetIterator(value).
+  const iteratorRecord = Q(yield* GetIterator(value, 'sync'));
+  // 2. Let status be IteratorDestructuringAssignmentEvaluation of AssignmentElementList with argument iteratorRecord.
+  let status = EnsureCompletion(yield* IteratorDestructuringAssignmentEvaluation(AssignmentElementList, iteratorRecord));
+  // 3. If status is an abrupt completion, then
+  if (status instanceof AbruptCompletion) {
+    // a. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iteratorRecord, status).
+    if (iteratorRecord.Done === Value.false) {
+      return Q(yield* IteratorClose(iteratorRecord, status));
+    }
+    // b. Return Completion(status).
+    return status;
+  }
+  // 4. If Elision is present, then
+  // ...
+  // 5. If AssignmentRestElement is present, then
+  if (AssignmentRestElement) {
+    // a. Set status to the result of performing IteratorDestructuringAssignmentEvaluation of AssignmentRestElement with iteratorRecord as the argument.
+    status = EnsureCompletion(yield* IteratorDestructuringAssignmentEvaluation(AssignmentRestElement, iteratorRecord));
+  }
+  // 6. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iteratorRecord, status).
+  if (iteratorRecord.Done === Value.false) {
+    return Q(yield* IteratorClose(iteratorRecord, status));
+  }
+  return Completion(status);
+}
+
+function* IteratorDestructuringAssignmentEvaluation(node: ParseNode.AssignmentElisionElement[] | ParseNode.AssignmentElisionElement | ParseNode.AssignmentRestElement, iteratorRecord: IteratorRecord): StatementEvaluator {
+  if (Array.isArray(node)) {
+    for (const n of node) {
+      Q(yield* IteratorDestructuringAssignmentEvaluation(n, iteratorRecord));
+    }
+    return NormalCompletion(undefined);
+  }
+  switch (node.type) {
+    case 'Elision':
+      // 1. If iteratorRecord.[[Done]] is false, then
+      if (iteratorRecord.Done === Value.false) {
+        // a. Perform ? IteratorStep(iteratorRecord).
+        Q(yield* IteratorStep(iteratorRecord));
+      }
+      // 2. Return NormalCompletion(empty).
+      return NormalCompletion(undefined);
+    case 'AssignmentElement': {
+      const { DestructuringAssignmentTarget, Initializer } = node;
+      let lref;
+      // 1. If DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral, then
+      if (DestructuringAssignmentTarget.type !== 'ObjectLiteral'
+          && DestructuringAssignmentTarget.type !== 'ArrayLiteral') {
+        lref = Q(yield* Evaluate(DestructuringAssignmentTarget));
+      }
+      let value: Value = Value.undefined;
+      // 2. If iteratorRecord.[[Done]] is false, then
+      if (iteratorRecord.Done === Value.false) {
+        // a. Let next be ? IteratorStepValue(iteratorRecord).
+        const next = Q(yield* IteratorStepValue(iteratorRecord));
+        // d. If next is not done, set value to next.
+        if (next !== 'done') {
+          value = next;
+        }
+      }
+      let v: Value;
+      // 4. If Initializer is present and value is undefined, then
+      if (Initializer && value === Value.undefined) {
+        // a. If IsAnonymousFunctionDefinition(AssignmentExpression) is true and IsIdentifierRef of LeftHandSideExpression is true, then
+        if (IsAnonymousFunctionDefinition(Initializer) && IsIdentifierRef(DestructuringAssignmentTarget)) {
+          // i. Let target be the StringValue of DestructuringAssignmentTarget.
+          const target = (lref as ReferenceRecord).ReferencedName as JSStringValue;
+          // i. ii. Let v be ? NamedEvaluation of Initializer with argument target.
+          v = Q(yield* NamedEvaluation(Initializer as FunctionDeclaration, target));
+        } else { // b. Else,
+          // i. Let defaultValue be the result of evaluating Initializer.
+          const defaultValue = Q(yield* Evaluate(Initializer));
+          // ii. Let v be ? GetValue(defaultValue).
+          v = Q(yield* GetValue(defaultValue));
+        }
+      } else { // 5. Else, let v be value.
+        v = Q(value);
+      }
+      // 6. If DestructuringAssignmentTarget is an ObjectLiteral or an ArrayLiteral, then
+      if (DestructuringAssignmentTarget.type === 'ObjectLiteral'
+          || DestructuringAssignmentTarget.type === 'ArrayLiteral') {
+        // a. Let nestedAssignmentPattern be the AssignmentPattern that is covered by DestructuringAssignmentTarget.
+        const nestedAssignmentPattern = refineLeftHandSideExpression(DestructuringAssignmentTarget) as ParseNode.ObjectAssignmentPattern | ParseNode.ArrayAssignmentPattern;
+        // b. Return the result of performing DestructuringAssignmentEvaluation of nestedAssignmentPattern with v as the argument.
+        return yield* DestructuringAssignmentEvaluation(nestedAssignmentPattern, X(v));
+      }
+      // 7. Return ? PutValue(lref, v).
+      return Q(yield* PutValue(Q(lref) as ReferenceRecord, v));
+    }
+    case 'AssignmentRestElement': {
+      const { AssignmentExpression: DestructuringAssignmentTarget } = node;
+      let lref;
+      // 1. If DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral, then
+      if (DestructuringAssignmentTarget.type !== 'ObjectLiteral'
+          && DestructuringAssignmentTarget.type !== 'ArrayLiteral') {
+        lref = yield* Evaluate(DestructuringAssignmentTarget);
+        Q(lref);
+      }
+      // 2. Let A be ! ArrayCreate(0).
+      const array = X(ArrayCreate(0));
+      // 3. Let n be 0.
+      let n = 0;
+      // 4. Repeat, while iteratorRecord.[[Done]] is false,
+      while (iteratorRecord.Done === Value.false) {
+        // a. Let next be IteratorStep(iteratorRecord).
+        const next = Q(yield* IteratorStepValue(iteratorRecord));
+        // d. If next is not done, then
+        if (next !== 'done') {
+          // i. Perform ! CreateDataPropertyOrThrow(A, ! ToString(𝔽(n)), next).
+          X(CreateDataPropertyOrThrow(array, X(ToString(F(n))), X(next)));
+          // v. Set n to n + 1.
+          n += 1;
+        }
+      }
+      // 5. If DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral, then
+      if (DestructuringAssignmentTarget.type !== 'ObjectLiteral'
+          && DestructuringAssignmentTarget.type !== 'ArrayLiteral') {
+        return Q(yield* PutValue(Q(lref) as ReferenceRecord, array));
+      }
+      // 6. Let nestedAssignmentPattern be the AssignmentPattern that is covered by DestructuringAssignmentTarget.
+      const nestedAssignmentPattern = refineLeftHandSideExpression(DestructuringAssignmentTarget) as ParseNode.ObjectAssignmentPattern | ParseNode.ArrayAssignmentPattern;
+      // 7. Return the result of performing DestructuringAssignmentEvaluation of nestedAssignmentPattern with A as the argument.
+      return yield* DestructuringAssignmentEvaluation(nestedAssignmentPattern, array);
+    }
+    default:
+      throw OutOfRange.nonExhaustive(node);
+  }
+}
+
+export function DestructuringAssignmentEvaluation(node: ParseNode.ObjectAssignmentPattern | ParseNode.ArrayAssignmentPattern, value: Value): StatementEvaluator {
+  switch (node.type) {
+    case 'ObjectAssignmentPattern':
+      return DestructuringAssignmentEvaluation_ObjectAssignmentPattern(node, value);
+    case 'ArrayAssignmentPattern':
+      return DestructuringAssignmentEvaluation_ArrayAssignmentPattern(node, value);
+    default:
+      throw OutOfRange.exhaustive(node);
+  }
+}

package/src/runtime-semantics/EmptyStatement.mts

@@ -0,0 +1,9 @@
+import { NormalCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-empty-statement-runtime-semantics-evaluation */
+//   EmptyStatement : `;`
+export function Evaluate_EmptyStatement(_EmptyStatement: ParseNode.EmptyStatement) {
+  // 1. Return NormalCompletion(empty).
+  return NormalCompletion(undefined);
+}

package/src/runtime-semantics/EqualityExpression.mts

@@ -0,0 +1,60 @@
+import { Q, X } from '../completion.mts';
+import { Evaluate, type ValueEvaluator } from '../evaluator.mts';
+import { Value } from '../value.mts';
+import { OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  IsLooselyEqual,
+  GetValue,
+  IsStrictlyEqual,
+  BooleanValue,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-equality-operators-runtime-semantics-evaluation */
+//   EqualityExpression :
+//     EqualityExpression `==` RelationalExpression
+//     EqualityExpression `!=` RelationalExpression
+//     EqualityExpression `===` RelationalExpression
+//     EqualityExpression `!==` RelationalExpression
+export function* Evaluate_EqualityExpression({ EqualityExpression, operator, RelationalExpression }: ParseNode.EqualityExpression): ValueEvaluator<BooleanValue> {
+  // 1. Let lref be the result of evaluating EqualityExpression.
+  const lref = Q(yield* Evaluate(EqualityExpression));
+  // 2. Let lval be ? GetValue(lref).
+  const lval = Q(yield* GetValue(lref));
+  // 3. Let rref be the result of evaluating RelationalExpression.
+  const rref = Q(yield* Evaluate(RelationalExpression));
+  // 4. Let rval be ? GetValue(rref).
+  const rval = Q(yield* GetValue(rref));
+  switch (operator) {
+    case '==':
+      // 5. Return the result of performing Abstract Equality Comparison rval == lval.
+      return Value(Q(yield* IsLooselyEqual(rval, lval)));
+    case '!=': {
+      // 5. Let r be the result of performing Abstract Equality Comparison rval == lval.
+      const r = Q(yield* IsLooselyEqual(rval, lval));
+      // 7. If r is true, return false. Otherwise, return true.
+      if (r) {
+        return Value.false;
+      } else {
+        return Value.true;
+      }
+    }
+    case '===':
+      // 5. Return the result of performing Strict Equality Comparison rval === lval.
+      return Value(IsStrictlyEqual(rval, lval));
+    case '!==': {
+      // 5. Let r be the result of performing Strict Equality Comparison rval === lval.
+      // 6. Assert: r is a normal completion.
+      const r = X(IsStrictlyEqual(rval, lval));
+      // 7. If r.[[Value]] is true, return false. Otherwise, return true.
+      if (r) {
+        return Value.false;
+      } else {
+        return Value.true;
+      }
+    }
+
+    default:
+      throw OutOfRange.exhaustive(operator);
+  }
+}

package/src/runtime-semantics/EvaluateBody.mts

@@ -0,0 +1,211 @@
+import { Value, type Arguments } from '../value.mts';
+import {
+  Completion,
+  AbruptCompletion,
+  Q, X,
+  EnsureCompletion,
+  ReturnCompletion,
+} from '../completion.mts';
+import { Evaluate, type StatementEvaluator } from '../evaluator.mts';
+import { IsAnonymousFunctionDefinition, type FunctionDeclaration } from '../static-semantics/all.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { Mutable } from '../utils/language.mts';
+import {
+  Evaluate_FunctionStatementList,
+  FunctionDeclarationInstantiation,
+  NamedEvaluation,
+} from './all.mts';
+import { DeclarativeEnvironmentRecord, DisposeResources, surroundingAgent } from '#self';
+import {
+  Assert,
+  AsyncFunctionStart,
+  Call,
+  GeneratorStart,
+  NewPromiseCapability,
+  OrdinaryCreateFromConstructor,
+  AsyncGeneratorStart,
+  GetValue,
+  type ECMAScriptFunctionObject,
+  type GeneratorObject,
+  type AsyncGeneratorObject,
+  type Body,
+} from '#self';
+
+export function Evaluate_AnyFunctionBody({ FunctionStatementList }: ParseNode.FunctionBody | ParseNode.AsyncBody | ParseNode.GeneratorBody | ParseNode.AsyncGeneratorBody) {
+  return Evaluate_FunctionStatementList(FunctionStatementList);
+}
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-evaluatefunctionbody */
+// FunctionBody : FunctionStatementList
+export function* EvaluateFunctionBody({ FunctionStatementList }: ParseNode.FunctionBody, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): StatementEvaluator {
+  Q(yield* FunctionDeclarationInstantiation(functionObject, argumentsList));
+  // NOTE: If the previous step resulted in a normal completion, then evaluation finished by proceeding past the end of the FunctionStatementList.
+  // Note: Q can propagate return completion
+  Q(yield* Evaluate_FunctionStatementList(FunctionStatementList));
+  return ReturnCompletion(Value.undefined);
+}
+
+/** https://tc39.es/ecma262/#sec-arrow-function-definitions-runtime-semantics-evaluation */
+// ExpressionBody : AssignmentExpression
+export function* Evaluate_ExpressionBody({ AssignmentExpression }: ParseNode.ExpressionBody): StatementEvaluator {
+  // 1. Let exprRef be the result of evaluating AssignmentExpression.
+  const exprRef = Q(yield* Evaluate(AssignmentExpression));
+  // 2. Let exprValue be ? GetValue(exprRef).
+  const exprValue = Q(yield* GetValue(exprRef));
+  // 3. Return Completion { [[Type]]: return, [[Value]]: exprValue, [[Target]]: empty }.
+  return new Completion({ Type: 'return', Value: exprValue, Target: undefined });
+}
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-evaluateconcisebody */
+// ConciseBody : ExpressionBody
+export function* EvaluateConciseBody({ ExpressionBody }: ParseNode.ConciseBody, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments) {
+  // 1. Perform ? FunctionDeclarationInstantiation(functionObject, argumentsList).
+  Q(yield* FunctionDeclarationInstantiation(functionObject, argumentsList));
+  // 2. Return the result of evaluating ExpressionBody.
+  return yield* Evaluate(ExpressionBody);
+}
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-evaluateasyncconcisebody */
+// AsyncConciseBody : ExpressionBody
+function* EvaluateAsyncConciseBody({ ExpressionBody }: ParseNode.AsyncConciseBody, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments) {
+  // 1. Let promiseCapability be ! NewPromiseCapability(%Promise%).
+  const promiseCapability = X(NewPromiseCapability(surroundingAgent.intrinsic('%Promise%')));
+  // 2. Let declResult be FunctionDeclarationInstantiation(functionObject, argumentsList).
+  const declResult = EnsureCompletion(yield* FunctionDeclarationInstantiation(functionObject, argumentsList));
+  // 3. If declResult is not an abrupt completion, then
+  if (declResult.Type === 'normal') {
+    // a. Perform ! AsyncFunctionStart(promiseCapability, ExpressionBody).
+    X(yield* AsyncFunctionStart(promiseCapability, ExpressionBody));
+  } else { // 4. Else
+    // a. Perform ! Call(promiseCapability.[[Reject]], undefined, « declResult.[[Value]] »).
+    X(yield* Call(promiseCapability.Reject, Value.undefined, [declResult.Value!]));
+  }
+  // 5. Return Completion { [[Type]]: return, [[Value]]: promiseCapability.[[Promise]], [[Target]]: empty }.
+  return new Completion({ Type: 'return', Value: promiseCapability.Promise, Target: undefined });
+}
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-evaluategeneratorbody */
+// GeneratorBody : FunctionBody
+export function* EvaluateGeneratorBody(GeneratorBody: ParseNode.GeneratorBody, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): StatementEvaluator {
+  // 1. Perform ? FunctionDeclarationInstantiation(functionObject, argumentsList).
+  Q(yield* FunctionDeclarationInstantiation(functionObject, argumentsList));
+  // 2. Let G be ? OrdinaryCreateFromConstructor(functionObject, "%GeneratorPrototype%", « [[GeneratorState]], [[GeneratorContext]], [[GeneratorBrand]] »).
+  const G = Q(yield* OrdinaryCreateFromConstructor(functionObject, '%GeneratorFunction.prototype.prototype%', ['GeneratorState', 'GeneratorContext', 'GeneratorBrand'])) as Mutable<GeneratorObject>;
+  // 3. Set G.[[GeneratorBrand]] to empty.
+  G.GeneratorBrand = undefined;
+  // 4. Set G.[[GeneratorState]] to suspended-start.
+  G.GeneratorState = 'suspendedStart';
+  // 5. Perform GeneratorStart(G, FunctionBody).
+  GeneratorStart(G, GeneratorBody);
+  // 6. Return ReturnCompletion(G).
+  return ReturnCompletion(G);
+}
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-evaluateasyncgeneratorbody */
+// AsyncGeneratorBody : FunctionBody
+export function* EvaluateAsyncGeneratorBody(FunctionBody: ParseNode.AsyncGeneratorBody, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): StatementEvaluator {
+  // 1. Perform ? FunctionDeclarationInstantiation(functionObject, argumentsList).
+  Q(yield* FunctionDeclarationInstantiation(functionObject, argumentsList));
+  // 2. Let generator be ? OrdinaryCreateFromConstructor(functionObject, "%AsyncGeneratorFunction.prototype.prototype%", « [[AsyncGeneratorState]], [[AsyncGeneratorContext]], [[AsyncGeneratorQueue]], [[GeneratorBrand]] »).
+  const generator = Q(yield* OrdinaryCreateFromConstructor(functionObject, '%AsyncGeneratorFunction.prototype.prototype%', [
+    'AsyncGeneratorState',
+    'AsyncGeneratorContext',
+    'AsyncGeneratorQueue',
+    'GeneratorBrand',
+  ])) as Mutable<AsyncGeneratorObject>;
+  // 3. Set generator.[[GeneratorBrand]] to empty.
+  generator.GeneratorBrand = undefined;
+  generator.AsyncGeneratorState = 'suspendedStart';
+  // 4. Perform ! AsyncGeneratorStart(generator, FunctionBody).
+  X(AsyncGeneratorStart(generator, FunctionBody));
+  // 5. Return Completion { [[Type]]: return, [[Value]]: generator, [[Target]]: empty }.
+  return new Completion({ Type: 'return', Value: generator, Target: undefined });
+}
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-evaluateasyncfunctionbody */
+// AsyncBody : FunctionBody
+export function* EvaluateAsyncFunctionBody(FunctionBody: ParseNode.AsyncBody, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments) {
+  // 1. Let promiseCapability be ! NewPromiseCapability(%Promise%).
+  const promiseCapability = X(NewPromiseCapability(surroundingAgent.intrinsic('%Promise%')));
+  // 2. Let declResult be FunctionDeclarationInstantiation(functionObject, argumentsList).
+  const declResult = yield* FunctionDeclarationInstantiation(functionObject, argumentsList);
+  // 3. If declResult is not an abrupt completion, then
+  if (!(declResult instanceof AbruptCompletion)) {
+    // a. Perform ! AsyncFunctionStart(promiseCapability, FunctionBody).
+    X(yield* AsyncFunctionStart(promiseCapability, FunctionBody));
+  } else { // 4. Else,
+    // a. Perform ! Call(promiseCapability.[[Reject]], undefined, « declResult.[[Value]] »).
+    X(yield* Call(promiseCapability.Reject, Value.undefined, [declResult.Value!]));
+  }
+  // 5. Return Completion { [[Type]]: return, [[Value]]: promiseCapability.[[Promise]], [[Target]]: empty }.
+  return new Completion({ Type: 'return', Value: promiseCapability.Promise, Target: undefined });
+}
+
+// Initializer :
+//   `=` AssignmentExpression
+export function* EvaluateBody_AssignmentExpression(AssignmentExpression: ParseNode.Initializer, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): StatementEvaluator {
+  // 1. Assert: argumentsList is empty.
+  if (surroundingAgent.feature('decorators') && surroundingAgent.feature('decorators.no-bugfix.1')) {
+    // TODO(decorator): spec bug
+    // @ts-expect-error
+    // eslint-disable-next-line no-console
+    console.assert(argumentsList.length === 0, 'Assert: argumentsList is empty.');
+  } else {
+    Assert(argumentsList.length === 0);
+  }
+  // 2. Assert: functionObject.[[ClassFieldInitializerName]] is not empty.
+  Assert(functionObject.ClassFieldInitializerName !== undefined);
+  let value;
+  // 3. If IsAnonymousFunctionDefinition(AssignmentExpression) is true, then
+  if (IsAnonymousFunctionDefinition(AssignmentExpression)) {
+    // a. Let value be NamedEvaluation of Initializer with argument functionObject.[[ClassFieldInitializerName]].
+    value = yield* NamedEvaluation(AssignmentExpression as FunctionDeclaration, functionObject.ClassFieldInitializerName);
+  } else { // 4. Else,
+    // a. Let rhs be the result of evaluating AssignmentExpression.
+    const rhs = Q(yield* Evaluate(AssignmentExpression));
+    // b. Let value be ? GetValue(rhs).
+    value = Q(yield* GetValue(rhs));
+  }
+  // 5. Return Completion { [[Type]]: return, [[Value]]: value, [[Target]]: empty }.
+  return new Completion({ Type: 'return', Value: X(value), Target: undefined });
+}
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-evaluateclassstaticblockbody */
+//    ClassStaticBlockBody : ClassStaticBlockStatementList
+export function* EvaluateClassStaticBlockBody({ ClassStaticBlockStatementList }: ParseNode.ClassStaticBlockBody, funcObject: ECMAScriptFunctionObject): StatementEvaluator {
+  X(FunctionDeclarationInstantiation(funcObject, []));
+  const result = EnsureCompletion(yield* Evaluate_FunctionStatementList(ClassStaticBlockStatementList));
+  const envRecord = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  Assert(envRecord instanceof DeclarativeEnvironmentRecord);
+  Q(yield* DisposeResources(envRecord.DisposableResourceStack, result));
+  return ReturnCompletion(Value.undefined);
+}
+
+// FunctionBody : FunctionStatementList
+// ConciseBody : ExpressionBody
+// GeneratorBody : FunctionBody
+// AsyncGeneratorBody : FunctionBody
+// AsyncBody : FunctionBody
+// AsyncConciseBody : ExpressionBody
+// ClassStaticBlockBody : ClassStaticBlockStatementList
+export function EvaluateBody(Body: Body, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments) {
+  switch (Body.type) {
+    case 'FunctionBody':
+      return EvaluateFunctionBody(Body, functionObject, argumentsList);
+    case 'ConciseBody':
+      return EvaluateConciseBody(Body, functionObject, argumentsList);
+    case 'GeneratorBody':
+      return EvaluateGeneratorBody(Body, functionObject, argumentsList);
+    case 'AsyncGeneratorBody':
+      return EvaluateAsyncGeneratorBody(Body, functionObject, argumentsList);
+    case 'AsyncBody':
+      return EvaluateAsyncFunctionBody(Body, functionObject, argumentsList);
+    case 'AsyncConciseBody':
+      return EvaluateAsyncConciseBody(Body, functionObject, argumentsList);
+    case 'ClassStaticBlockBody':
+      Assert(argumentsList.length === 0);
+      return EvaluateClassStaticBlockBody(Body, functionObject);
+    default:
+      return EvaluateBody_AssignmentExpression(Body, functionObject, argumentsList);
+  }
+}

package/src/runtime-semantics/EvaluateCall.mts

@@ -0,0 +1,67 @@
+import {
+  ObjectValue, Value, ReferenceRecord,
+} from '../value.mts';
+import { Q, Completion, AbruptCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { ArgumentListEvaluation } from './all.mts';
+import {
+  Assert,
+  IsPropertyReference,
+  IsCallable,
+  GetThisValue,
+  PrepareForTailCall,
+  Call,
+  EnvironmentRecord,
+  Throw,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-evaluatecall */
+export function* EvaluateCall(func: Value, ref: ReferenceRecord | Value, args: ParseNode.TemplateLiteral | ParseNode.Arguments, tailPosition: boolean, callExpression?: ParseNode.CallExpression | ParseNode.OptionalExpression) {
+  // 1. If Type(ref) is Reference, then
+  let thisValue;
+  if (ref instanceof ReferenceRecord) {
+    // a. If IsPropertyReference(ref) is true, then
+    if (IsPropertyReference(ref) === Value.true) {
+      // i. Let thisValue be GetThisValue(ref).
+      thisValue = GetThisValue(ref);
+    } else {
+      // i. Let refEnv be ref.[[Base]].
+      const refEnv = ref.Base;
+      // ii. Assert: refEnv is an Environment Record.
+      Assert(refEnv instanceof EnvironmentRecord);
+      // iii. Let thisValue be refEnv.WithBaseObject().
+      thisValue = refEnv.WithBaseObject();
+    }
+  } else {
+    // a. Let thisValue be undefined.
+    thisValue = Value.undefined;
+  }
+  // 3. Let argList be ? ArgumentListEvaluation of arguments.
+  const argList = Q(yield* ArgumentListEvaluation(args));
+  // 4. If Type(func) is not Object, throw a TypeError exception.
+  // 5. If IsCallable(func) is false, throw a TypeError exception.
+  if (!(func instanceof ObjectValue) || !IsCallable(func)) {
+    if (callExpression) {
+      const source = callExpression.sourceText;
+      const arg0StartIndex = args.location.startIndex;
+      if (source.length < 100) {
+        return Throw.TypeError('$1 is not a function. (In "$2", it is $3)', source.slice(0, arg0StartIndex - callExpression.location.startIndex), source, func);
+      }
+    }
+    return Throw.TypeError('$1 is not a function', func);
+  }
+  // 6. If tailPosition is true, perform PrepareForTailCall().
+  if (tailPosition) {
+    PrepareForTailCall();
+  }
+  // 7. Let result be Call(func, thisValue, argList).
+  const result = yield* Call(func, thisValue, argList);
+  // 8. Assert: If tailPosition is true, the above call will not return here but instead
+  //    evaluation will continue as if the following return has already occurred.
+  // 9. Assert: If result is not an abrupt completion, then Type(result) is an ECMAScript language type.
+  if (!(result instanceof AbruptCompletion)) {
+    Assert(result instanceof Value || result instanceof Completion);
+  }
+  // 10. Return result.
+  return result;
+}