@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/src/runtime-semantics/ClassDefinitionEvaluation.mts

@@ -0,0 +1,343 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Value, NullValue, ObjectValue, PrivateName,
+  BooleanValue,
+  JSStringValue,
+  type Arguments,
+  type FunctionCallContext,
+  UndefinedValue,
+  type PropertyKeyValue,
+} from '../value.mts';
+import { Evaluate } from '../evaluator.mts';
+import {
+  Assert,
+  Call,
+  Construct,
+  CreateBuiltinFunction,
+  Get,
+  GetValue,
+  IsConstructor,
+  MakeConstructor,
+  MakeClassConstructor,
+  SetFunctionName,
+  CreateMethodProperty,
+  OrdinaryObjectCreate,
+  OrdinaryCreateFromConstructor,
+  PrivateMethodOrAccessorAdd,
+  InitializeInstanceElements,
+  DefineField,
+  type ECMAScriptFunctionObject,
+  type FunctionObject,
+} from '../abstract-ops/all.mts';
+import {
+  IsStatic,
+  ConstructorMethod,
+  NonConstructorElements,
+  PrivateBoundIdentifiers,
+} from '../static-semantics/all.mts';
+import {
+  DeclarativeEnvironmentRecord,
+  PrivateEnvironmentRecord,
+} from '../environment.mts';
+import {
+  Q, X,
+  AbruptCompletion,
+  Completion,
+} from '../completion.mts';
+import { __ts_cast__, OutOfRange, type Mutable } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  DefineMethod,
+  MethodDefinitionEvaluation,
+  ClassFieldDefinitionEvaluation,
+  PrivateElementRecord,
+  ClassFieldDefinitionRecord,
+  ClassStaticBlockDefinitionEvaluation,
+  ClassStaticBlockDefinitionRecord,
+} from './all.mts';
+
+function* ClassElementEvaluation(node: ParseNode.MethodDefinition | ParseNode.GeneratorMethod | ParseNode.AsyncMethod | ParseNode.AsyncGeneratorMethod | ParseNode.FieldDefinition | ParseNode.ClassStaticBlock, object: ObjectValue, enumerable: BooleanValue) {
+  switch (node.type) {
+    case 'MethodDefinition':
+    case 'GeneratorMethod':
+    case 'AsyncMethod':
+    case 'AsyncGeneratorMethod':
+      return yield* MethodDefinitionEvaluation(node, object, enumerable);
+    case 'FieldDefinition':
+      return yield* ClassFieldDefinitionEvaluation(node, object);
+    case 'ClassStaticBlock':
+      return ClassStaticBlockDefinitionEvaluation(node, object);
+    default:
+      throw new OutOfRange('ClassElementEvaluation', node);
+  }
+}
+
+// ClassTail : ClassHeritage? `{` ClassBody? `}`
+export function* ClassDefinitionEvaluation(ClassTail: ParseNode.ClassTail, classBinding: JSStringValue | UndefinedValue, className: PropertyKeyValue | PrivateName) {
+  const { ClassHeritage, ClassBody } = ClassTail;
+  // 1. Let env be the LexicalEnvironment of the running execution context.
+  const env = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 2. Let classScope be NewDeclarativeEnvironment(env).
+  const classScope = new DeclarativeEnvironmentRecord(env);
+  // 3. If classBinding is not undefined, then
+  if (!(classBinding instanceof UndefinedValue)) {
+    // a. Perform classScopeEnv.CreateImmutableBinding(classBinding, true).
+    classScope.CreateImmutableBinding(classBinding, Value.true);
+  }
+  // 4. Let outerPrivateEnvironment be the running execution context's PrivateEnvironment.
+  const outerPrivateEnvironment = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 5. Let classPrivateEnvironment be NewPrivateEnvironment(outerPrivateEnvironment).
+  const classPrivateEnvironment = new PrivateEnvironmentRecord(outerPrivateEnvironment);
+  // 6. If ClassBody is present, then
+  if (ClassBody) {
+    // a. For each String dn of the PrivateBoundIdentifiers of ClassBody, do
+    for (const dn of PrivateBoundIdentifiers(ClassBody)) {
+      // i. If classPrivateEnvironment.[[Names]] contains a Private Name whose [[Description]] is dn, then
+      const existing = classPrivateEnvironment.Names.find((n) => n.Description.stringValue() === dn.stringValue());
+      if (existing) {
+        // 1. Assert: This is only possible for getter/setter pairs.
+      } else { // ii. Else,
+        // 1. Let name be a new Private Name whose [[Description]] value is dn.
+        const name = new PrivateName(dn);
+        // 2. Append name to classPrivateEnvironment.[[Names]].
+        classPrivateEnvironment.Names.push(name);
+      }
+    }
+  }
+  let protoParent;
+  let constructorParent: ObjectValue;
+  // 7. If ClassHeritage is not present, then
+  if (!ClassHeritage) {
+    // a. Let protoParent be %Object.prototype%.
+    protoParent = surroundingAgent.intrinsic('%Object.prototype%');
+    // b. Let constructorParent be %Function.prototype%.
+    constructorParent = surroundingAgent.intrinsic('%Function.prototype%');
+  } else { // 8. Else,
+    // a. Set the running execution context's LexicalEnvironment to classScope.
+    surroundingAgent.runningExecutionContext.LexicalEnvironment = classScope;
+    // b. Let superclassRef be the result of evaluating ClassHeritage.
+    const superclassRef = yield* Evaluate(ClassHeritage);
+    // c. Set the running execution context's LexicalEnvironment to env.
+    surroundingAgent.runningExecutionContext.LexicalEnvironment = env;
+    // d. Let superclass be ? GetValue(superclassRef).
+    const superclass = Q(GetValue(superclassRef));
+    // e. If superclass is null, then
+    if (superclass instanceof NullValue) {
+      // i. Let protoParent be null.
+      protoParent = Value.null;
+      // ii. Let constructorParent be %Function.prototype%.
+      constructorParent = surroundingAgent.intrinsic('%Function.prototype%');
+    } else if (IsConstructor(superclass) === Value.false) {
+      // f. Else if IsConstructor(superclass) is false, throw a TypeError exception.
+      return surroundingAgent.Throw('TypeError', 'NotAConstructor', superclass);
+    } else { // g. Else,
+      // i. Let protoParent be ? Get(superclass, "prototype").
+      protoParent = Q(Get(superclass as ObjectValue, Value('prototype')));
+      // ii. If Type(protoParent) is neither Object nor Null, throw a TypeError exception.
+      if (!(protoParent instanceof ObjectValue) && !(protoParent instanceof NullValue)) {
+        return surroundingAgent.Throw('TypeError', 'ObjectPrototypeType');
+      }
+      // iii. Let constructorParent be superclass.
+      constructorParent = superclass as ObjectValue;
+    }
+  }
+  // 9. Let proto be OrdinaryObjectCreate(protoParent).
+  const proto = OrdinaryObjectCreate(protoParent);
+  let constructor;
+  // 10. If ClassBody is not present, let constructor be empty.
+  if (!ClassBody) {
+    constructor = undefined;
+  } else { // 11. Else, let constructor be ConstructorMethod of ClassBody.
+    constructor = ConstructorMethod(ClassBody);
+  }
+  // 12. Set the running execution context's LexicalEnvironment to classScope.
+  surroundingAgent.runningExecutionContext.LexicalEnvironment = classScope;
+  // 13. Set the running execution context's PrivateEnvironment to classPrivateEnvironment.
+  surroundingAgent.runningExecutionContext.PrivateEnvironment = classPrivateEnvironment;
+  let F;
+  // 14. If constructor is empty, then
+  if (constructor === undefined) {
+    // a. Let defaultConstructor be a new Abstract Closure with no parameters that captures nothing and performs the following steps when called:
+    const defaultConstructor = (args: Arguments, { NewTarget }: FunctionCallContext) => {
+      // i. Let args be the List of arguments that was passed to this function by [[Call]] or [[Construct]].
+      // ii. If NewTarget is undefined, throw a TypeError exception.
+      if (NewTarget instanceof UndefinedValue) {
+        return surroundingAgent.Throw('TypeError', 'ConstructorNonCallable', surroundingAgent.activeFunctionObject);
+      }
+      // iii. Let F be the active function object.
+      const F = surroundingAgent.activeFunctionObject as ECMAScriptFunctionObject; // eslint-disable-line no-shadow
+      let result;
+      // iv. If F.[[ConstructorKind]] is derived, then
+      if (F.ConstructorKind === 'derived') {
+        // 1. NOTE: This branch behaves similarly to `constructor(...args) { super(...args); }`. The most
+        //    notable distinction is that while the aforementioned ECMAScript source text observably calls
+        //    the @@iterator method on `%Array.prototype%`, a Default Constructor Function does not.
+        // 2. Let func be ! F.[[GetPrototypeOf]]().
+        const func = X(F.GetPrototypeOf());
+        // 3. If IsConstructor(func) is false, throw a TypeError exception.
+        if (IsConstructor(func) === Value.false) {
+          return surroundingAgent.Throw('TypeError', 'NotAConstructor', func);
+        }
+        // 4. Let result be ? Construct(func, args, NewTarget).
+        result = Q(Construct(func as FunctionObject, args, NewTarget));
+      } else { // v. Else,
+        // 1. NOTE: This branch behaves similarly to `constructor() {}`.
+        // 2. Let result be ? OrdinaryCreateFromConstructor(NewTarget, "%Object.prototype%").
+        result = Q(OrdinaryCreateFromConstructor(NewTarget, '%Object.prototype%'));
+      }
+      Q(InitializeInstanceElements(result, F));
+      return result;
+    };
+    // b. ! CreateBuiltinFunction(defaultConstructor, 0, className, « [[ConstructorKind]], [[SourceText]] », the current Realm Record, constructorParent).
+    F = X(CreateBuiltinFunction(defaultConstructor, 0, className, ['ConstructorKind', 'SourceText'], undefined, constructorParent, undefined, Value.true));
+  } else { // 15. Else,
+    // a. Let constructorInfo be ! DefineMethod of constructor with arguments proto and constructorParent.
+    const constructorInfo = X(yield* DefineMethod(constructor, proto, constructorParent));
+    // b. Let F be constructorInfo.[[Closure]].
+    F = constructorInfo.Closure;
+    // c. Perform MakeClassConstructor(F).
+    MakeClassConstructor(F);
+    // d. Perform SetFunctionName(F, className).
+    SetFunctionName(F, className);
+  }
+  __ts_cast__<Mutable<ECMAScriptFunctionObject>>(F);
+  // 16. Perform MakeConstructor(F, false, proto).
+  MakeConstructor(F, Value.false, proto);
+  // 17. If ClassHeritage is present, set F.[[ConstructorKind]] to derived.
+  if (ClassHeritage) {
+    F.ConstructorKind = 'derived';
+  }
+  // 18. Perform CreateMethodProperty(proto, "constructor", F).
+  X(CreateMethodProperty(proto, Value('constructor'), F));
+  // 19. If ClassBody is not present, let elements be a new empty List.
+  let elements: ParseNode.ClassElement[];
+  if (!ClassBody) {
+    elements = [];
+  } else { // 20. Else, let elements be NonConstructorElements of ClassBody.
+    elements = NonConstructorElements(ClassBody);
+  }
+  // 21. Let instancePrivateMethods be a new empty List.
+  const instancePrivateMethods: never[] = [];
+  // 22. Let staticPrivateMethods be a new empty List.
+  const staticPrivateMethods: never[] = [];
+  // 23. Let instanceFields be a new empty List.
+  const instanceFields: ClassFieldDefinitionRecord[] = [];
+  // 24. Let staticElements be a new empty List.
+  const staticElements: (ClassFieldDefinitionRecord | ClassStaticBlockDefinitionRecord)[] = [];
+  // 25. For each ClassElement e of elements, do
+  for (const e of elements) {
+    let field;
+    // a. If IsStatic of e is false, then
+    if (IsStatic(e) === false) {
+      // i. Let field be ClassElementEvaluation of e with arguments proto and false.
+      field = (yield* ClassElementEvaluation(e, proto, Value.false))!;
+    } else { // b. Else,
+      // i. Let field be ClassElementEvaluation of e with arguments F and false.
+      field = (yield* ClassElementEvaluation(e, F, Value.false))!;
+    }
+    // c. If field is an abrupt completion, then
+    if (field instanceof AbruptCompletion) {
+      // i. Set the running execution context's LexicalEnvironment to env.
+      surroundingAgent.runningExecutionContext.LexicalEnvironment = env;
+      // ii. Set the running execution context's PrivateEnvironment to outerPrivateEnvironment.
+      surroundingAgent.runningExecutionContext.PrivateEnvironment = outerPrivateEnvironment;
+      // iii. Return Completion(field).
+      return field;
+    }
+    // d. Set field to field.[[Value]].
+    Q(field);
+    // e. If field is a PrivateElement, then
+    if (field instanceof PrivateElementRecord) {
+      // i. Assert: field.[[Kind]] is either method or accessor.
+      Assert(field.Kind === 'method' || field.Kind === 'accessor');
+      // ii. If IsStatic of e is false, let container be instancePrivateMethods.
+      let container: PrivateElementRecord[];
+      if (IsStatic(e) === false) {
+        container = instancePrivateMethods;
+      } else { // iii. Else, let container be staticPrivateMethods.
+        container = staticPrivateMethods;
+      }
+      // iv. If container contains a PrivateElement whose [[Key]] is field.[[Key]], then
+      const index = container.findIndex((el) => el.Key === field.Key);
+      if (index >= 0) {
+        // 1. Let existing be that PrivateElement.
+        const existing = container[index];
+        // 2. Assert: field.[[Kind]] and existing.[[Kind]] are both accessor.
+        Assert(field.Kind === 'accessor' && existing.Kind === 'accessor');
+        // 3. If field.[[Get]] is undefined, then
+        let combined;
+        if (field.Get === Value.undefined) {
+          combined = new PrivateElementRecord({
+            Key: field.Key,
+            Kind: 'accessor',
+            Get: existing.Get,
+            Set: field.Set,
+          });
+        } else { // 4. Else
+          combined = new PrivateElementRecord({
+            Key: field.Key,
+            Kind: 'accessor',
+            Get: field.Get,
+            Set: existing.Set,
+          });
+        }
+        // 5. Replace existing in container with combined.
+        container[index] = combined;
+      } else { // v. Else,
+        // 1. Append field to container.
+        container.push(field);
+      }
+    } else if (field instanceof ClassFieldDefinitionRecord) { // f. Else if field is a ClassFieldDefinition Record, then
+      // i. If IsStatic of e is false, append field to instanceFields.
+      if (IsStatic(e) === false) {
+        instanceFields.push(field);
+      } else { // ii. Else, append field to staticElements.
+        staticElements.push(field);
+      }
+    } else if (field instanceof ClassStaticBlockDefinitionRecord) { // g. Else if element is a ClassStaticBlockDefinition Record, then
+      // i. Append element to staticElements.
+      staticElements.push(field);
+    }
+  }
+  // 26. Set the running execution context's LexicalEnvironment to env.
+  surroundingAgent.runningExecutionContext.LexicalEnvironment = env;
+  // 27. If classBinding is not undefined, then
+  if (!(classBinding instanceof UndefinedValue)) {
+    // a. Perform classScope.InitializeBinding(classBinding, F).
+    classScope.InitializeBinding(classBinding, F);
+  }
+  // 28. Set F.[[PrivateMethods]] to instancePrivateMethods.
+  F.PrivateMethods = instancePrivateMethods;
+  // 29. Set F.[[Fields]] to instanceFields.
+  F.Fields = instanceFields;
+  // 30. For each PrivateElement method of staticPrivateMethods, do
+  for (const method of staticPrivateMethods) {
+    // a. Perform ! PrivateMethodOrAccessorAdd(method, F).
+    X(PrivateMethodOrAccessorAdd(method, F));
+  }
+  // 31. For each element elementRecord of staticElements, do
+  for (const elementRecord of staticElements) {
+    let result;
+    // a. If elementRecord is a ClassFieldDefinition Record, then
+    if (elementRecord instanceof ClassFieldDefinitionRecord) {
+      // a. Let result be DefineField(F, elementRecord).
+      result = DefineField(F, elementRecord);
+    } else { // b. Else,
+      // i. Assert: elementRecord is a ClassStaticBlockDefinition Record.
+      Assert(elementRecord instanceof ClassStaticBlockDefinitionRecord);
+      // ii. Let result be Completion(Call(elementRecord.[[BodyFunction]], F)).
+      result = Completion(Call(elementRecord.BodyFunction, F));
+    }
+    // c. If result is an abrupt completion, then
+    if (result instanceof AbruptCompletion) {
+      // i. Set the running execution context's PrivateEnvironment to outerPrivateEnvironment.
+      surroundingAgent.runningExecutionContext.PrivateEnvironment = outerPrivateEnvironment;
+      // ii. Return result.
+      return result;
+    }
+  }
+  // 32. Set the running execution context's PrivateEnvironment to outerPrivateEnvironment.
+  surroundingAgent.runningExecutionContext.PrivateEnvironment = outerPrivateEnvironment;
+  // 33. Return F.
+  return F;
+}

package/src/runtime-semantics/ClassExpression.mts

@@ -0,0 +1,32 @@
+import { Value } from '../value.mts';
+import { sourceTextMatchedBy, type ECMAScriptFunctionObject } from '../abstract-ops/all.mts';
+import { Q } from '../completion.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { Mutable } from '../helpers.mts';
+import type { ExpressionEvaluator } from '../evaluator.mts';
+import { ClassDefinitionEvaluation } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-class-definitions-runtime-semantics-evaluation */
+// ClassExpression :
+//   `class` ClassTail
+//   `class` BindingIdentifier ClassTail
+export function* Evaluate_ClassExpression(ClassExpression: ParseNode.ClassExpression): ExpressionEvaluator {
+  const { BindingIdentifier, ClassTail } = ClassExpression;
+  if (!BindingIdentifier) {
+    // 1. Let value be ? ClassDefinitionEvaluation of ClassTail with arguments undefined and ''
+    const value = Q(yield* ClassDefinitionEvaluation(ClassTail, Value.undefined, Value(''))) as Mutable<ECMAScriptFunctionObject>;
+    // 2. Set value.[[SourceText]] to the source text matched by ClassExpression.
+    value.SourceText = sourceTextMatchedBy(ClassExpression);
+    // 3. Return value.
+    return value;
+  }
+  // 1. Let className be StringValue of BindingIdentifier.
+  const className = StringValue(BindingIdentifier);
+  // 2. Let value be ? ClassDefinitionEvaluation of ClassTail with arguments className and className.
+  const value = Q(yield* ClassDefinitionEvaluation(ClassTail, className, className)) as Mutable<ECMAScriptFunctionObject>;
+  // Set value.[[SourceText]] to the source text matched by ClassExpression.
+  value.SourceText = sourceTextMatchedBy(ClassExpression);
+  // Return value.
+  return value;
+}

package/src/runtime-semantics/ClassFieldDefinitionEvaluation.mts

@@ -0,0 +1,61 @@
+import { surroundingAgent } from '../engine.mts';
+import { X, ReturnIfAbrupt } from '../completion.mts';
+import { MakeMethod, OrdinaryFunctionCreate } from '../abstract-ops/all.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { Evaluator } from '../evaluator.mts';
+import { Evaluate_PropertyName } from './PropertyName.mts';
+import type {
+  ECMAScriptFunctionObject, ObjectValue, PlainCompletion, PrivateName, PropertyKeyValue,
+} from '#self';
+
+export class ClassFieldDefinitionRecord {
+  Name: PropertyKeyValue | PrivateName;
+
+  Initializer: ECMAScriptFunctionObject | undefined;
+
+  constructor(init: ClassFieldDefinitionRecord) {
+    this.Name = init.Name;
+    this.Initializer = init.Initializer;
+  }
+}
+
+export function* ClassFieldDefinitionEvaluation(FieldDefinition: ParseNode.FieldDefinition, homeObject: ObjectValue): Evaluator<PlainCompletion<ClassFieldDefinitionRecord>> {
+  const { ClassElementName, Initializer } = FieldDefinition;
+  // 1. Let name be the result of evaluating ClassElementName.
+  // 2. ReturnIfAbrupt(name).
+  const name = ReturnIfAbrupt(yield* Evaluate_PropertyName(ClassElementName));
+  // 3. If Initializer is present, then
+  let initializer;
+  if (Initializer) {
+    // a. Let formalParameterList be an instance of the production FormalParameters : [empty].
+    const formalParameterList: readonly [] = [];
+    // b. Let scope be the LexicalEnvironment of the running execution context.
+    const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+    // c. Let privateScope be the running execution context's PrivateEnvironment.
+    const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+    // d. Let sourceText be the empty sequence of Unicode code points.
+    const sourceText = '';
+    // e. Let initializer be ! OrdinaryFunctionCreate(%Function.prototype%, sourceText, formalParameterList, Initializer, non-lexical-this, scope, privateScope).
+    initializer = X(OrdinaryFunctionCreate(
+      surroundingAgent.intrinsic('%Function.prototype%'),
+      sourceText,
+      formalParameterList,
+      Initializer,
+      'non-lexical-this',
+      scope,
+      privateScope,
+    ));
+    // f. Perform MakeMethod(initializer, homeObject).
+    MakeMethod(initializer, homeObject);
+    // g. Set initializer.[[ClassFieldInitializerName]] to name.
+    initializer.ClassFieldInitializerName = name;
+  } else { // 4. Else,
+    // a. Let initializer be empty.
+    initializer = undefined;
+  }
+  // 5. Return the ClassFieldDefinition Record { [[Name]]: name, [[Initializer]]: initializer }.
+  return new ClassFieldDefinitionRecord({
+    Name: name,
+    Initializer: initializer,
+  });
+}

package/src/runtime-semantics/ClassStaticBlockDefinitionEvaluation.mts

@@ -0,0 +1,44 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  MakeMethod,
+  OrdinaryFunctionCreate,
+  type ECMAScriptFunctionObject,
+} from '../abstract-ops/all.mts';
+import { X } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { ObjectValue } from '#self';
+
+export class ClassStaticBlockDefinitionRecord {
+  BodyFunction: ECMAScriptFunctionObject;
+
+  constructor({ BodyFunction }: ClassStaticBlockDefinitionRecord) {
+    this.BodyFunction = BodyFunction;
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-classstaticblockdefinitionevaluation */
+//    ClassStaticBlock : `static` `{` ClassStaticBlockBody `}`
+export function ClassStaticBlockDefinitionEvaluation({ ClassStaticBlockBody }: ParseNode.ClassStaticBlock, homeObject: ObjectValue) {
+  // 1. Let lex be the running execution context's LexicalEnvironment.
+  const lex = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 2. Let privateEnv be the running execution context's PrivateEnvironment.
+  const privateEnv = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 3. Let sourceText be the empty sequence of Unicode code points.
+  const sourceText = '';
+  // 4. Let formalParameters be an instance of the production FormalParameters : [empty] .
+  const formalParameters: readonly [] = [];
+  // 5. Let bodyFunction be OrdinaryFunctionCreate(%Function.prototype%, sourceText, formalParameters, ClassStaticBlockBody, non-lexical-this, lex, privateEnv).
+  const bodyFunction = X(OrdinaryFunctionCreate(
+    surroundingAgent.intrinsic('%Function.prototype%'),
+    sourceText,
+    formalParameters,
+    ClassStaticBlockBody,
+    'non-lexical-this',
+    lex,
+    privateEnv,
+  ));
+  // 6. Perform MakeMethod(bodyFunction, homeObject).
+  X(MakeMethod(bodyFunction, homeObject));
+  // 7. Return the ClassStaticBlockDefinition Record { [[BodyFunction]]: bodyFunction }.
+  return new ClassStaticBlockDefinitionRecord({ BodyFunction: bodyFunction });
+}

package/src/runtime-semantics/CoalesceExpression.mts

@@ -0,0 +1,24 @@
+import { Q } from '../completion.mts';
+import { Evaluate, type ExpressionEvaluator } from '../evaluator.mts';
+import { GetValue } from '../abstract-ops/all.mts';
+import { Value } from '../value.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-binary-logical-operators-runtime-semantics-evaluation */
+//   CoalesceExpression :
+//     CoalesceExpressionHead `??` BitwiseORExpression
+export function* Evaluate_CoalesceExpression({ CoalesceExpressionHead, BitwiseORExpression }: ParseNode.CoalesceExpression): ExpressionEvaluator {
+  // 1. Let lref be the result of evaluating |CoalesceExpressionHead|.
+  const lref = yield* Evaluate(CoalesceExpressionHead);
+  // 2. Let lval be ? GetValue(lref).
+  const lval = Q(GetValue(lref));
+  // 3. If lval is *undefined* or *null*,
+  if (lval === Value.undefined || lval === Value.null) {
+    // a. Let rref be the result of evaluating |BitwiseORExpression|.
+    const rref = yield* Evaluate(BitwiseORExpression);
+    // b. Return ? GetValue(rref).
+    return Q(GetValue(rref));
+  }
+  // 4. Otherwise, return lval.
+  return lval;
+}

package/src/runtime-semantics/CommaOperator.mts

@@ -0,0 +1,18 @@
+import { Evaluate, type ExpressionEvaluator } from '../evaluator.mts';
+import { GetValue } from '../abstract-ops/all.mts';
+import { Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { Value } from '#self';
+
+/** https://tc39.es/ecma262/#sec-comma-operator-runtime-semantics-evaluation */
+//   Expression :
+//     AssignmentExpression
+//     Expression `,` AssignmentExpression
+export function* Evaluate_CommaOperator({ ExpressionList }: ParseNode.CommaOperator): ExpressionEvaluator {
+  let result!: Value;
+  for (const Expression of ExpressionList) {
+    const lref = yield* Evaluate(Expression);
+    result = Q(GetValue(lref));
+  }
+  return result;
+}

package/src/runtime-semantics/ConditionalExpression.mts

@@ -0,0 +1,31 @@
+import { Value } from '../value.mts';
+import { Evaluate, type ExpressionEvaluator } from '../evaluator.mts';
+import { ToBoolean, GetValue } from '../abstract-ops/all.mts';
+import { Q, X } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-conditional-operator-runtime-semantics-evaluation */
+//   ConditionalExpression :
+//     ShortCircuitExpression `?` AssignmentExpression `:` AssignmentExpression
+export function* Evaluate_ConditionalExpression({
+  ShortCircuitExpression,
+  AssignmentExpression_a,
+  AssignmentExpression_b,
+}: ParseNode.ConditionalExpression): ExpressionEvaluator {
+  // 1. Let lref be the result of evaluating ShortCircuitExpression.
+  const lref = yield* Evaluate(ShortCircuitExpression);
+  // 2. Let lval be ! ToBoolean(? GetValue(lref)).
+  const lval = X(ToBoolean(Q(GetValue(lref))));
+  // 3. If lval is true, then
+  if (lval === Value.true) {
+    // a. Let trueRef be the result of evaluating the first AssignmentExpression.
+    const trueRef = yield* Evaluate(AssignmentExpression_a);
+    // b. Return ? GetValue(trueRef).
+    return Q(GetValue(trueRef));
+  } else { // 4. Else,
+    // a. Let falseRef be the result of evaluating the second AssignmentExpression.
+    const falseRef = yield* Evaluate(AssignmentExpression_b);
+    // b. Return ? GetValue(falseRef).
+    return Q(GetValue(falseRef));
+  }
+}

package/src/runtime-semantics/ContinueStatement.mts

@@ -0,0 +1,18 @@
+import { Completion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { StringValue } from '../static-semantics/all.mts';
+
+/** https://tc39.es/ecma262/#sec-continue-statement-runtime-semantics-evaluation */
+//   ContinueStatement :
+//     `continue` `;`
+//     `continue` LabelIdentifier `;`
+export function Evaluate_ContinueStatement({ LabelIdentifier }: ParseNode.ContinueStatement) {
+  if (!LabelIdentifier) {
+    // 1. Return Completion { [[Type]]: continue, [[Value]]: empty, [[Target]]: empty }.
+    return new Completion({ Type: 'continue', Value: undefined, Target: undefined });
+  }
+  // 1. Let label be the StringValue of LabelIdentifier.
+  const label = StringValue(LabelIdentifier);
+  // 2. Return Completion { [[Type]]: continue, [[Value]]: empty, [[Target]]: label }.
+  return new Completion({ Type: 'continue', Value: undefined, Target: label });
+}