@engine262/engine262 0.0.1-0574c6b92a2925de851f895445b7cfd7e97cc0ba

package/src/runtime-semantics/EvaluateBody.mts

@@ -0,0 +1,200 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import { Value, type Arguments } from '../value.mts';
+import {
+  Assert,
+  AsyncFunctionStart,
+  Call,
+  GeneratorStart,
+  NewPromiseCapability,
+  OrdinaryCreateFromConstructor,
+  AsyncGeneratorStart,
+  GetValue,
+  type ECMAScriptFunctionObject,
+  type GeneratorObject,
+  type AsyncGeneratorObject,
+  type Body,
+} from '../abstract-ops/all.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 '../helpers.mts';
+import {
+  Evaluate_FunctionStatementList,
+  FunctionDeclarationInstantiation,
+  NamedEvaluation,
+} from './all.mts';
+
+export function Evaluate_AnyFunctionBody({ FunctionStatementList }: ParseNode.FunctionBody | ParseNode.AsyncBody | ParseNode.GeneratorBody | ParseNode.AsyncGeneratorBody) {
+  return Evaluate_FunctionStatementList(FunctionStatementList);
+}
+
+/** https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-evaluatebody */
+// FunctionBody : FunctionStatementList
+export function* EvaluateBody_FunctionBody({ FunctionStatementList }: ParseNode.FunctionBody, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments) {
+  // 1. Perform ? FunctionDeclarationInstantiation(functionObject, argumentsList).
+  Q(yield* FunctionDeclarationInstantiation(functionObject, argumentsList));
+  // 2. Return the result of evaluating FunctionStatementList.
+  return yield* Evaluate_FunctionStatementList(FunctionStatementList);
+}
+
+/** 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-arrow-function-definitions-runtime-semantics-evaluatebody */
+// ConciseBody : ExpressionBody
+export function* EvaluateBody_ConciseBody({ 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-async-arrow-function-definitions-EvaluateBody */
+// AsyncConciseBody : ExpressionBody
+function* EvaluateBody_AsyncConciseBody({ 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-generator-function-definitions-runtime-semantics-evaluatebody */
+// GeneratorBody : FunctionBody
+export function* EvaluateBody_GeneratorBody(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-asyncgenerator-definitions-evaluatebody */
+// AsyncGeneratorBody : FunctionBody
+export function* EvaluateBody_AsyncGeneratorBody(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-async-function-definitions-EvaluateBody */
+// AsyncBody : FunctionBody
+export function* EvaluateBody_AsyncFunctionBody(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.
+  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
+function* EvaluateClassStaticBlockBody({ ClassStaticBlockStatementList }: ParseNode.ClassStaticBlockBody, functionObject: ECMAScriptFunctionObject) {
+  // 1. Perform ? FunctionDeclarationInstantiation(functionObject, « »).
+  Q(yield* FunctionDeclarationInstantiation(functionObject, []));
+  // 2. Return the result of evaluating ClassStaticBlockStatementList.
+  return yield* Evaluate_FunctionStatementList(ClassStaticBlockStatementList);
+}
+
+// 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 EvaluateBody_FunctionBody(Body, functionObject, argumentsList);
+    case 'ConciseBody':
+      return EvaluateBody_ConciseBody(Body, functionObject, argumentsList);
+    case 'GeneratorBody':
+      return EvaluateBody_GeneratorBody(Body, functionObject, argumentsList);
+    case 'AsyncGeneratorBody':
+      return EvaluateBody_AsyncGeneratorBody(Body, functionObject, argumentsList);
+    case 'AsyncBody':
+      return EvaluateBody_AsyncFunctionBody(Body, functionObject, argumentsList);
+    case 'AsyncConciseBody':
+      return EvaluateBody_AsyncConciseBody(Body, functionObject, argumentsList);
+    case 'ClassStaticBlockBody':
+      return EvaluateClassStaticBlockBody(Body, functionObject);
+    default:
+      return EvaluateBody_AssignmentExpression(Body, functionObject, argumentsList);
+  }
+}

package/src/runtime-semantics/EvaluateCall.mts

@@ -0,0 +1,63 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  ObjectValue, Value, ReferenceRecord,
+} from '../value.mts';
+import {
+  Assert,
+  IsPropertyReference,
+  IsCallable,
+  GetThisValue,
+  PrepareForTailCall,
+  Call,
+} from '../abstract-ops/all.mts';
+import { Q, Completion, AbruptCompletion } from '../completion.mts';
+import { EnvironmentRecord } from '../environment.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { ArgumentListEvaluation } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-evaluatecall */
+export function* EvaluateCall(func: Value, ref: ReferenceRecord | Value, args: ParseNode | ParseNode.Arguments, tailPosition: boolean) {
+  // 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.
+  if (!(func instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAFunction', func);
+  }
+  // 5. If IsCallable(func) is false, throw a TypeError exception.
+  if (!IsCallable(func)) {
+    return surroundingAgent.Throw('TypeError', 'NotAFunction', 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;
+}

package/src/runtime-semantics/EvaluatePropertyAccess.mts

@@ -0,0 +1,39 @@
+import {
+  GetValue,
+  Assert,
+} from '../abstract-ops/all.mts';
+import { Value, ReferenceRecord } from '../value.mts';
+import { Evaluate, type ReferenceEvaluator } from '../evaluator.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import { Q, type PlainCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-evaluate-expression-key-property-access */
+export function* EvaluatePropertyAccessWithExpressionKey(baseValue: Value, expression: ParseNode.Expression, strict: boolean): ReferenceEvaluator {
+  // 1. Let propertyNameReference be the result of evaluating expression.
+  const propertyNameReference = Q(yield* Evaluate(expression));
+  // 2. Let propertyNameValue be ? GetValue(propertyNameReference).
+  const propertyNameValue = Q(yield* GetValue(propertyNameReference));
+  // 3. Return the Reference Record { [[Base]]: bv, [[ReferencedName]]: propertyKey, [[Strict]]: strict, [[ThisValue]]: empty }.
+  return new ReferenceRecord({
+    Base: baseValue,
+    ReferencedName: propertyNameValue,
+    Strict: strict ? Value.true : Value.false,
+    ThisValue: undefined,
+  });
+}
+
+/** https://tc39.es/ecma262/#sec-evaluate-identifier-key-property-access */
+export function EvaluatePropertyAccessWithIdentifierKey(baseValue: Value, identifierName: ParseNode.IdentifierName, strict: boolean): PlainCompletion<ReferenceRecord> {
+  // 1. Assert: identifierName is an IdentifierName.
+  Assert(identifierName.type === 'IdentifierName');
+  // 3. Let propertyNameString be StringValue of IdentifierName
+  const propertyNameString = StringValue(identifierName);
+  // 4. Return the Reference Record { [[Base]]: bv, [[ReferencedName]]: propertyNameString, [[Strict]]: strict, [[ThisValue]]: empty }.
+  return new ReferenceRecord({
+    Base: baseValue,
+    ReferencedName: propertyNameString,
+    Strict: strict ? Value.true : Value.false,
+    ThisValue: undefined,
+  });
+}

package/src/runtime-semantics/EvaluateStringOrNumericBinaryExpression.mts

@@ -0,0 +1,19 @@
+import { Evaluate, type ValueEvaluator } from '../evaluator.mts';
+import { GetValue } from '../abstract-ops/all.mts';
+import { Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { ApplyStringOrNumericBinaryOperator, type BinaryOperator } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-evaluatestringornumericbinaryexpression */
+export function* EvaluateStringOrNumericBinaryExpression(leftOperand: ParseNode.Expression, opText: BinaryOperator, rightOperand: ParseNode.Expression): ValueEvaluator {
+  // 1. Let lref be the result of evaluating leftOperand.
+  const lref = Q(yield* Evaluate(leftOperand));
+  // 2. Let lval be ? GetValue(lref).
+  const lval = Q(yield* GetValue(lref));
+  // 3. Let rref be the result of evaluating rightOperand.
+  const rref = Q(yield* Evaluate(rightOperand));
+  // 4. Let rval be ? GetValue(rref).
+  const rval = Q(yield* GetValue(rref));
+  // 5. Return ? ApplyStringOrNumericBinaryOperator(lval, opText, rval).
+  return Q(yield* ApplyStringOrNumericBinaryOperator(lval, opText, rval));
+}

package/src/runtime-semantics/ExponentiationExpression.mts

@@ -0,0 +1,11 @@
+import { Q } from '../completion.mts';
+import type { ValueEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { EvaluateStringOrNumericBinaryExpression } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-exp-operator-runtime-semantics-evaluation */
+// ExponentiationExpression : UpdateExpression ** ExponentiationExpression
+export function* Evaluate_ExponentiationExpression({ UpdateExpression, ExponentiationExpression }: ParseNode.ExponentiationExpression): ValueEvaluator {
+  // 1. Return ? EvaluateStringOrNumericBinaryExpression(UpdateExpression, **, ExponentiationExpression).
+  return Q(yield* EvaluateStringOrNumericBinaryExpression(UpdateExpression, '**', ExponentiationExpression));
+}

package/src/runtime-semantics/ExportDeclaration.mts

@@ -0,0 +1,90 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import { Value } from '../value.mts';
+import { Evaluate } from '../evaluator.mts';
+import { GetValue, type ECMAScriptFunctionObject } from '../abstract-ops/all.mts';
+import { BoundNames, IsAnonymousFunctionDefinition } from '../static-semantics/all.mts';
+import { NormalCompletion, Q } from '../completion.mts';
+import { OutOfRange } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  NamedEvaluation,
+  InitializeBoundName,
+  BindingClassDeclarationEvaluation,
+} from './all.mts';
+import type { FunctionDeclaration } from '#self';
+
+/** https://tc39.es/ecma262/#sec-exports-runtime-semantics-evaluation */
+//   ExportDeclaration :
+//     `export` ExportFromClause FromClause `;`
+//     `export` NamedExports `;`
+//     `export` VariableDeclaration
+//     `export` Declaration
+//     `export` `default` HoistableDeclaration
+//     `export` `default` ClassDeclaration
+//     `export` `default` AssignmentExpression `;`
+export function* Evaluate_ExportDeclaration(ExportDeclaration: ParseNode.ExportDeclaration) {
+  const {
+    FromClause, NamedExports,
+    VariableStatement,
+    Declaration,
+    default: isDefault,
+    HoistableDeclaration,
+    ClassDeclaration,
+    AssignmentExpression,
+  } = ExportDeclaration;
+
+  if (FromClause || NamedExports) {
+    // 1. Return NormalCompletion(empty).
+    return NormalCompletion(undefined);
+  }
+  if (VariableStatement) {
+    // 1. Return the result of evaluating VariableStatement.
+    return yield* Evaluate(VariableStatement);
+  }
+  if (Declaration) {
+    // 1. Return the result of evaluating Declaration.
+    return yield* Evaluate(ExportDeclaration.Declaration!);
+  }
+  if (!isDefault) {
+    throw new OutOfRange('Evaluate_ExportDeclaration', ExportDeclaration);
+  }
+  if (HoistableDeclaration) {
+    // 1. Return the result of evaluating HoistableDeclaration.
+    return yield* Evaluate(HoistableDeclaration);
+  }
+  if (ClassDeclaration) {
+    // 1. Let value be ? BindingClassDeclarationEvaluation of ClassDeclaration.
+    const value = Q(yield* BindingClassDeclarationEvaluation(ClassDeclaration)) as ECMAScriptFunctionObject;
+    // 2. Let className be the sole element of BoundNames of ClassDeclaration.
+    const className = BoundNames(ClassDeclaration)[0];
+    // If className is "*default*", then
+    if (className.stringValue() === '*default*') {
+      // a. Let env be the running execution context's LexicalEnvironment.
+      const env = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+      // b. Perform ? InitializeBoundName("*default*", value, env).
+      Q(yield* InitializeBoundName(Value('*default*'), value, env));
+    }
+    // 3. Return NormalCompletion(empty).
+    return NormalCompletion(undefined);
+  }
+  if (AssignmentExpression) {
+    let value;
+    // 1. If IsAnonymousFunctionDefinition(AssignmentExpression) is true, then
+    if (IsAnonymousFunctionDefinition(AssignmentExpression)) {
+      // a. Let value be NamedEvaluation of AssignmentExpression with argument "default".
+      value = yield* NamedEvaluation(AssignmentExpression as FunctionDeclaration, Value('default'));
+    } else { // 2. Else,
+      // a. Let rhs be the result of evaluating AssignmentExpression.
+      const rhs = Q(yield* Evaluate(AssignmentExpression));
+      // a. Let value be ? GetValue(rhs).
+      value = Q(yield* GetValue(rhs));
+    }
+    // 3. Let env be the running execution context's LexicalEnvironment.
+    const env = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+    // 4. Perform ? InitializeBoundName("*default*", value, env).
+    Q(yield* InitializeBoundName(Value('*default*'), value as ECMAScriptFunctionObject, env));
+    // 5. Return NormalCompletion(empty).
+    return NormalCompletion(undefined);
+  }
+  throw new OutOfRange('Evaluate_ExportDeclaration', ExportDeclaration);
+}

package/src/runtime-semantics/ExpressionStatement.mts

@@ -0,0 +1,14 @@
+import { GetValue } from '../abstract-ops/all.mts';
+import { Evaluate, type ValueEvaluator } from '../evaluator.mts';
+import { Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-expression-statement-runtime-semantics-evaluation */
+//   ExpressionStatement :
+//     Expression `;`
+export function* Evaluate_ExpressionStatement({ Expression }: ParseNode.ExpressionStatement): ValueEvaluator {
+  // 1. Let exprRef be the result of evaluating Expression.
+  const exprRef = Q(yield* Evaluate(Expression));
+  // 2. Return ? GetValue(exprRef).
+  return Q(yield* GetValue(exprRef));
+}

package/src/runtime-semantics/FunctionDeclaration.mts

@@ -0,0 +1,11 @@
+import { NormalCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-evaluation */
+// FunctionDeclaration :
+//   function BindingIdentifier ( FormalParameters ) { FunctionBody }
+//   function ( FormalParameters ) { FunctionBody }
+export function Evaluate_FunctionDeclaration(_FunctionDeclaration: ParseNode.FunctionDeclaration) {
+  // 1. Return NormalCompletion(empty).
+  return NormalCompletion(undefined);
+}