@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/runtime-semantics/ClassDefinitionEvaluation.mts

@@ -0,0 +1,811 @@
+import {
+  Value, NullValue, ObjectValue, PrivateName,
+  BooleanValue,
+  JSStringValue,
+  type Arguments,
+  type FunctionCallContext,
+  UndefinedValue,
+  type PropertyKeyValue,
+  ReferenceRecord,
+  SymbolValue,
+} from '../value.mts';
+import { Evaluate, type PlainEvaluator, type ValueEvaluator } from '../evaluator.mts';
+import {
+  IsStatic,
+  ConstructorMethod,
+  NonConstructorElements,
+  PrivateBoundIdentifiers,
+} from '../static-semantics/all.mts';
+import {
+  Q, X,
+  AbruptCompletion,
+} from '../completion.mts';
+import { __ts_cast__, OutOfRange, type Mutable } from '../utils/language.mts';
+import type { Location, ParseNode } from '../parser/ParseNode.mts';
+import {
+  DefineMethod,
+  MethodDefinitionEvaluation,
+  ClassFieldDefinitionEvaluation,
+  PrivateElementRecord,
+  ClassFieldDefinitionRecord,
+  ClassStaticBlockDefinitionEvaluation,
+  ClassStaticBlockDefinitionRecord,
+  ClassFieldDefinitionEvaluation_decorator,
+} from './all.mts';
+import {
+  surroundingAgent,
+  DeclarativeEnvironmentRecord,
+  PrivateEnvironmentRecord,
+
+  CreateDataPropertyOrThrow, HasProperty, InitializeFieldOrAccessor, InitializePrivateMethods, IsPropertyKey, markBuiltinFunctionAsConstructor, PrivateElementFind, PrivateGet, PrivateSet, Set, Throw,
+} from '#self';
+import {
+  Assert,
+  Call,
+  Construct,
+  CreateBuiltinFunction,
+  Get,
+  GetValue,
+  IsConstructor,
+  MakeConstructor,
+  MakeClassConstructor,
+  SetFunctionName,
+  CreateMethodProperty,
+  OrdinaryObjectCreate,
+  OrdinaryCreateFromConstructor,
+  PrivateMethodOrAccessorAdd,
+  InitializeInstanceElements,
+  DefineField,
+  type ECMAScriptFunctionObject,
+  type BuiltinFunctionObject,
+  type FunctionObject,
+  DefineMethodProperty,
+  IsCallable,
+  getActiveScriptId,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-static-semantics-classelementevaluation */
+// -decorator
+function ClassElementEvaluation(node: ParseNode.MethodDefinition | ParseNode.GeneratorMethod | ParseNode.AsyncMethod | ParseNode.AsyncGeneratorMethod | ParseNode.FieldDefinition | ParseNode.ClassStaticBlock, object: ObjectValue, enumerable: BooleanValue): PlainEvaluator<PrivateElementRecord | ClassFieldDefinitionRecord | void>
+// +decorator
+function ClassElementEvaluation(node: ParseNode.MethodDefinition | ParseNode.GeneratorMethod | ParseNode.AsyncMethod | ParseNode.AsyncGeneratorMethod | ParseNode.FieldDefinition | ParseNode.ClassStaticBlock, object: ObjectValue): PlainEvaluator<ClassElementDefinitionRecord | ClassStaticBlockDefinitionRecord | void>
+function* ClassElementEvaluation(node: ParseNode.MethodDefinition | ParseNode.GeneratorMethod | ParseNode.AsyncMethod | ParseNode.AsyncGeneratorMethod | ParseNode.FieldDefinition | ParseNode.ClassStaticBlock, object: ObjectValue, enumerable?: BooleanValue): PlainEvaluator<ClassElementDefinitionRecord | ClassFieldDefinitionRecord | ClassStaticBlockDefinitionRecord | PrivateElementRecord | void> {
+  switch (node.type) {
+    case 'MethodDefinition':
+    case 'GeneratorMethod':
+    case 'AsyncMethod':
+    case 'AsyncGeneratorMethod': {
+      if (surroundingAgent.feature('decorators')) {
+        const decorators = node.Decorators ? Q(yield* DecoratorListEvaluation(node.Decorators)) : [];
+        const methodDefinition = Q(yield* MethodDefinitionEvaluation(node, object));
+        methodDefinition.Decorators = decorators;
+        return methodDefinition;
+      } else {
+        return yield* MethodDefinitionEvaluation(node, object, enumerable!);
+      }
+    }
+    case 'FieldDefinition': {
+      if (surroundingAgent.feature('decorators')) {
+        const decorators = node.Decorators ? Q(yield* DecoratorListEvaluation(node.Decorators)) : [];
+        const fieldDefinition = Q(yield* ClassFieldDefinitionEvaluation_decorator(node, object));
+        fieldDefinition.Decorators = decorators;
+        return fieldDefinition;
+      } else {
+        return yield* ClassFieldDefinitionEvaluation(node, object);
+      }
+    }
+    case 'ClassStaticBlock':
+      return ClassStaticBlockDefinitionEvaluation(node, object);
+    default:
+      throw OutOfRange.exhaustive(node);
+  }
+}
+
+export interface DefaultConstructorBuiltinFunction extends BuiltinFunctionObject {
+  // -decorator
+  readonly PrivateMethods: ECMAScriptFunctionObject['PrivateMethods'];
+  readonly Fields: ECMAScriptFunctionObject['Fields'];
+  // +decorator (PrivateMethods => Initializers, Fields => Elements)
+  readonly Initializers: ECMAScriptFunctionObject['Initializers'];
+  readonly Elements: ECMAScriptFunctionObject['Elements'];
+  readonly SourceText: ECMAScriptFunctionObject['SourceText'];
+  readonly ConstructorKind: ECMAScriptFunctionObject['ConstructorKind'];
+  /**
+   * Note: this is different than InitialName, which is used and observable in Function.prototype.toString.
+   * This is only used in the inspector.
+  */
+  readonly HostInitialName: PropertyKeyValue | PrivateName;
+  readonly HostLocation: [scriptId: string | undefined, location: Location];
+}
+
+// ClassTail : ClassHeritage? `{` ClassBody? `}`
+/** https://tc39.es/ecma262/#sec-runtime-semantics-classdefinitionevaluation */
+/** https://arai-a.github.io/ecma262-compare/snapshot.html?pr=2417#sec-runtime-semantics-classdefinitionevaluation */
+export function* ClassDefinitionEvaluation(ClassTail: ParseNode.ClassTail, classBinding: JSStringValue | UndefinedValue, className: PropertyKeyValue | PrivateName, sourceText: string, decorators: readonly DecoratorDefinitionRecord[]): ValueEvaluator<FunctionObject> {
+  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 = Q(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(yield* 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)) {
+      // f. Else if IsConstructor(superclass) is false, throw a TypeError exception.
+      return Throw.TypeError('Super class $1 is not a constructor', superclass);
+    } else { // g. Else,
+      // i. Let protoParent be ? Get(superclass, "prototype").
+      protoParent = Q(yield* 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 Throw.TypeError('Super class\'s prototype must be an object or null');
+      }
+      // 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 = function* 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 Throw.TypeError('$1 cannot be invoked without new', 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(yield* F.GetPrototypeOf());
+        // 3. If IsConstructor(func) is false, throw a TypeError exception.
+        if (!IsConstructor(func)) {
+          return Throw.TypeError('$1 is not a constructor', func);
+        }
+        // 4. Let result be ? Construct(func, args, NewTarget).
+        result = Q(yield* Construct(func, args, NewTarget));
+      } else { // v. Else,
+        // 1. NOTE: This branch behaves similarly to `constructor() {}`.
+        // 2. Let result be ? OrdinaryCreateFromConstructor(NewTarget, "%Object.prototype%").
+        result = Q(yield* OrdinaryCreateFromConstructor(NewTarget, '%Object.prototype%'));
+      }
+      Q(yield* InitializeInstanceElements(result, F));
+      return result;
+    };
+    // b. ! CreateBuiltinFunction(defaultConstructor, 0, className, « [[ConstructorKind]], [[SourceText]], [[PrivateMethods]], [[Fields]] », the current Realm Record, constructorParent).
+    F = X(CreateBuiltinFunction(markBuiltinFunctionAsConstructor(defaultConstructor), 0, className, ['ConstructorKind', 'SourceText', surroundingAgent.feature('decorators') ? 'Initializers' : 'PrivateMethods', surroundingAgent.feature('decorators') ? 'Elements' : 'Fields', 'HostLocation'], surroundingAgent.currentRealmRecord, constructorParent)) as Mutable<DefaultConstructorBuiltinFunction>;
+    F.HostLocation = [getActiveScriptId(), ClassTail.location];
+  } 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 SetFunctionName(F, className).
+    SetFunctionName(F, className);
+  }
+  __ts_cast__<Mutable<DefaultConstructorBuiltinFunction>>(F);
+  F.HostInitialName = className;
+  F.SourceText = sourceText;
+  // 16. Perform MakeConstructor(F, false, proto).
+  MakeConstructor(F, Value.false, proto);
+  // https://github.com/tc39/ecma262/pull/3212/
+  // 17. Perform MakeClassConstructor(F).
+  MakeClassConstructor(F);
+  // 18. If ClassHeritage is present, set F.[[ConstructorKind]] to derived.
+  if (ClassHeritage) {
+    F.ConstructorKind = 'derived';
+  }
+  // 19. Perform CreateMethodProperty(proto, "constructor", F).
+  X(CreateMethodProperty(proto, Value('constructor'), F));
+  // 20. 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);
+  }
+  if (surroundingAgent.feature('decorators')) {
+    const instanceElements: ClassElementDefinitionRecord[] = [];
+    // 24. Let staticElements be a new empty List.
+    const staticElements: (ClassElementDefinitionRecord | ClassStaticBlockDefinitionRecord)[] = [];
+    // 25. For each ClassElement e of elements, do
+    for (const e of elements) {
+      let result;
+      // a. If IsStatic of e is false, then
+      if (!IsStatic(e)) {
+        result = yield* ClassElementEvaluation(e, proto);
+      } else {
+        result = yield* ClassElementEvaluation(e, F);
+      }
+      // c. If field is an abrupt completion, then
+      if (result 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;
+        return result;
+      }
+      const element = X(result);
+      if (element instanceof ClassElementDefinitionRecord) {
+        if (!IsStatic(e)) {
+          instanceElements.push(element);
+        } else {
+          staticElements.push(element);
+        }
+      } else {
+        Assert(element instanceof ClassStaticBlockDefinitionRecord);
+        staticElements.push(element);
+      }
+    }
+    // 26. Set the running execution context's LexicalEnvironment to env.
+    surroundingAgent.runningExecutionContext.LexicalEnvironment = env;
+    const instanceMethodExtraInitializers: FunctionObject[] = [];
+    const staticMethodExtraInitializers: FunctionObject[] = [];
+    for (const e of staticElements) {
+      if (e instanceof ClassElementDefinitionRecord && e.Kind !== 'field') {
+        let extraInitializers: FunctionObject[];
+        if (e.Kind === 'accessor') {
+          extraInitializers = e.ExtraInitializers;
+        } else {
+          extraInitializers = staticMethodExtraInitializers;
+        }
+        const result = yield* ApplyDecoratorsAndDefineMethod(F, e, extraInitializers, true);
+        if (result instanceof AbruptCompletion) {
+          surroundingAgent.runningExecutionContext.PrivateEnvironment = outerPrivateEnvironment;
+          return result;
+        }
+      }
+    }
+    for (const e of instanceElements) {
+      let extraInitializers: FunctionObject[];
+      if (e.Kind !== 'field') {
+        if (e.Kind === 'accessor') {
+          extraInitializers = e.ExtraInitializers;
+        } else {
+          extraInitializers = instanceMethodExtraInitializers;
+        }
+        const result = yield* ApplyDecoratorsAndDefineMethod(proto, e, extraInitializers, false);
+        if (result instanceof AbruptCompletion) {
+          surroundingAgent.runningExecutionContext.PrivateEnvironment = outerPrivateEnvironment;
+          return result;
+        }
+      }
+    }
+    for (const e of staticElements) {
+      if (e instanceof ClassElementDefinitionRecord && e.Kind === 'field') {
+        const result = yield* ApplyDecoratorsToElementDefinition(F, e, e.ExtraInitializers, true);
+        if (result instanceof AbruptCompletion) {
+          surroundingAgent.runningExecutionContext.PrivateEnvironment = outerPrivateEnvironment;
+          return result;
+        }
+      }
+    }
+    for (const e of instanceElements) {
+      if (e.Kind === 'field') {
+        const result = yield* ApplyDecoratorsToElementDefinition(proto, e, e.ExtraInitializers, false);
+        if (result instanceof AbruptCompletion) {
+          surroundingAgent.runningExecutionContext.PrivateEnvironment = outerPrivateEnvironment;
+          return result;
+        }
+      }
+    }
+    F.Elements = instanceElements;
+    F.Initializers = instanceMethodExtraInitializers;
+    // TODO(decorator): spec bug?
+    // Q(yield* InitializePrivateMethods(F, staticElements));
+    Q(yield* InitializePrivateMethods(F, staticElements.filter((element): element is ClassElementDefinitionRecord => element instanceof ClassElementDefinitionRecord)));
+    const classExtraInitializers: FunctionObject[] = [];
+    const newF = yield* ApplyDecoratorsToClassDefinition(F, decorators, className, classExtraInitializers);
+    if (newF instanceof AbruptCompletion) {
+      surroundingAgent.runningExecutionContext.PrivateEnvironment = outerPrivateEnvironment;
+      return newF;
+    }
+    F = Q(newF);
+    // 27. If classBinding is not undefined, then
+    if (!(classBinding instanceof UndefinedValue)) {
+      // a. Perform classScope.InitializeBinding(classBinding, F).
+      yield* classScope.InitializeBinding(classBinding, F);
+    }
+    for (const initializer of staticMethodExtraInitializers) {
+      const result = yield* Call(initializer, F);
+      if (result instanceof AbruptCompletion) {
+        surroundingAgent.runningExecutionContext.PrivateEnvironment = outerPrivateEnvironment;
+        return result;
+      }
+    }
+    // 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 ClassElementDefinitionRecord && (elementRecord.Kind === 'field' || elementRecord.Kind === 'accessor')) {
+        // a. Let result be DefineField(F, elementRecord).
+        result = yield* InitializeFieldOrAccessor(F, elementRecord);
+      } else if (elementRecord instanceof ClassStaticBlockDefinitionRecord) {
+        result = yield* 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;
+      }
+    }
+    for (const initializer of classExtraInitializers) {
+      const result = yield* Call(initializer, F);
+      if (result instanceof AbruptCompletion) {
+        surroundingAgent.runningExecutionContext.PrivateEnvironment = outerPrivateEnvironment;
+        return result;
+      }
+    }
+    // 32. Set the running execution context's PrivateEnvironment to outerPrivateEnvironment.
+    surroundingAgent.runningExecutionContext.PrivateEnvironment = outerPrivateEnvironment;
+    // 33. Return F.
+    return F;
+  } else {
+    // 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.Getter === Value.undefined) {
+            combined = PrivateElementRecord({
+              Key: field.Key,
+              Kind: 'accessor',
+              Getter: existing.Getter,
+              Setter: field.Setter,
+            });
+          } else { // 4. Else
+            combined = PrivateElementRecord({
+              Key: field.Key,
+              Kind: 'accessor',
+              Getter: field.Getter,
+              Setter: existing.Setter,
+            });
+          }
+          // 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);
+      } else {
+        // h. Else, assert: field is empty.
+        Assert(field === undefined);
+      }
+    }
+    // 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).
+      yield* 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(F, method).
+      Q(yield* PrivateMethodOrAccessorAdd(F, method));
+    }
+    // 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 = yield* 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 = yield* 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;
+  }
+}
+
+/** https://arai-a.github.io/ecma262-compare/snapshot.html?pr=2417#sec-decoratorevaluation */
+export function* DecoratorEvaluation(decorator: ParseNode.Decorator): PlainEvaluator<DecoratorDefinitionRecord> {
+  const expr = decorator.MemberExpression || decorator.CallExpression || decorator.ParenthesizedExpression;
+  const ref = Q(yield* Evaluate(expr));
+  const value = Q(yield* GetValue(ref));
+  return { Decorator: value, Receiver: ref };
+}
+
+/** https://arai-a.github.io/ecma262-compare/snapshot.html?pr=2417#sec-decoratorelistvaluation */
+export function* DecoratorListEvaluation(decoratorList: readonly ParseNode.Decorator[]): PlainEvaluator<DecoratorDefinitionRecord[]> {
+  const decorators: DecoratorDefinitionRecord[] = [];
+  for (const decoratorNode of decoratorList) {
+    const decoratorRecord = Q(yield* DecoratorEvaluation(decoratorNode));
+    decorators.unshift(decoratorRecord);
+  }
+  return decorators;
+}
+
+/** https://arai-a.github.io/ecma262-compare/snapshot.html?pr=2417#sec-createdecoratoraccessobject */
+export function CreateDecoratorAccessObject(kind: ClassElementDefinitionRecord['Kind'], name: PropertyKeyValue | PrivateName): ObjectValue {
+  const accessObj = OrdinaryObjectCreate(surroundingAgent.intrinsic('%Object.prototype%'));
+  if (kind === 'field' || kind === 'method' || kind === 'accessor' || kind === 'getter') {
+    const getterClosure = function* getter([obj = Value.undefined]: Arguments) {
+      if (!(obj instanceof ObjectValue)) {
+        return Throw.TypeError('Invalid receiver');
+      }
+      if (IsPropertyKey(name)) {
+        return Q(yield* Get(obj, name));
+      } else {
+        return Q(yield* PrivateGet(obj, name));
+      }
+    };
+    const getter = CreateBuiltinFunction(getterClosure, 1, Value(''), []);
+    X(CreateDataPropertyOrThrow(accessObj, Value('get'), getter));
+  }
+  if (kind === 'field' || kind === 'accessor' || kind === 'setter') {
+    const setterClosure = function* setter([obj = Value.undefined, value = Value.undefined]: Arguments) {
+      if (!(obj instanceof ObjectValue)) {
+        return Throw.TypeError('Invalid receiver');
+      }
+      if (IsPropertyKey(name)) {
+        return Q(yield* Set(obj, name, value, Value.true));
+      } else {
+        return Q(yield* PrivateSet(obj, name, value));
+      }
+    };
+    const setter = CreateBuiltinFunction(setterClosure, 2, Value(''), []);
+    X(CreateDataPropertyOrThrow(accessObj, Value('set'), setter));
+  }
+  const hasClosure = function* has(this: Value, [obj = Value.undefined]: Arguments) {
+    if (!(obj instanceof ObjectValue)) {
+      return Throw.TypeError('Invalid receiver');
+    }
+    if (IsPropertyKey(name)) {
+      return Q(yield* HasProperty(obj, name));
+    }
+    if (PrivateElementFind(name, obj)) {
+      return Value.true;
+    }
+    return Value.false;
+  };
+  const has = CreateBuiltinFunction(hasClosure, 1, Value('has'), []);
+  X(CreateDataPropertyOrThrow(accessObj, Value('has'), has));
+  return accessObj;
+}
+
+/** https://arai-a.github.io/ecma262-compare/snapshot.html?pr=2417#sec-createaddinitializerfunction */
+// TODO(decorator): spec bug, initializers should not require ECMAScriptFunctionObject
+export function CreateAddInitializerFunction(initializers: FunctionObject[], decorationState: { Finished: boolean }): FunctionObject {
+  const addInitializerClosure = function* addInitializer(this: Value, [initializer = Value.undefined]: Arguments) {
+    if (decorationState.Finished) {
+      return Throw.TypeError('Cannot call addInitializer after decoration is finished');
+    }
+    if (!IsCallable(initializer)) {
+      return Throw.TypeError('addInitializer must be called with a function, but $1 was passed', initializer);
+    }
+    initializers.push(initializer);
+    return Value.undefined;
+  };
+  return CreateBuiltinFunction(addInitializerClosure, 1, Value('addInitializer'), []);
+}
+
+/** https://arai-a.github.io/ecma262-compare/snapshot.html?pr=2417#sec-createdecoratorcontextobject */
+export function CreateDecoratorContextObject(kind: 'class' | ClassElementDefinitionRecord['Kind'], name: PropertyKeyValue | PrivateName, initializers: FunctionObject[], decorationState: { Finished: boolean }, isStatic?: boolean): ObjectValue {
+  const contextObj = OrdinaryObjectCreate(surroundingAgent.intrinsic('%Object.prototype%'));
+  const kindStr = Value(kind);
+  X(CreateDataPropertyOrThrow(contextObj, Value('kind'), kindStr));
+  if (kind !== 'class') {
+    X(CreateDataPropertyOrThrow(contextObj, Value('access'), CreateDecoratorAccessObject(kind, name)));
+    if (isStatic !== undefined) {
+      X(CreateDataPropertyOrThrow(contextObj, Value('static'), Value(isStatic)));
+    }
+    if (name instanceof PrivateName) {
+      X(CreateDataPropertyOrThrow(contextObj, Value('private'), Value.true));
+      X(CreateDataPropertyOrThrow(contextObj, Value('name'), name.Description));
+    } else {
+      X(CreateDataPropertyOrThrow(contextObj, Value('private'), Value.false));
+      X(CreateDataPropertyOrThrow(contextObj, Value('name'), name));
+    }
+  } else {
+    // TODO(decorator): spec bug, no assert to the name
+    X(CreateDataPropertyOrThrow(contextObj, Value('name'), name as PropertyKeyValue));
+  }
+  const addInitializer = CreateAddInitializerFunction(initializers, decorationState);
+  X(CreateDataPropertyOrThrow(contextObj, Value('addInitializer'), addInitializer));
+  return contextObj;
+}
+
+/** https://arai-a.github.io/ecma262-compare/snapshot.html?pr=2417#sec-applydecoratorstoelementdefinition */
+// TODO(decorator): unused parameter in the spec
+export function* ApplyDecoratorsToElementDefinition(_homeObject: ObjectValue, elementRecord: ClassElementDefinitionRecord, extraInitializers: FunctionObject[], isStatic: boolean): PlainEvaluator<void> {
+  const decorators = elementRecord.Decorators;
+  if (!decorators || decorators.length === 0) {
+    return undefined;
+  }
+  const key = elementRecord.Key;
+  const kind = elementRecord.Kind;
+  for (const decoratorRecord of decorators) {
+    const decorator = decoratorRecord.Decorator;
+    const decoratorReceiver = decoratorRecord.Receiver;
+    const decorationState = { Finished: false };
+    const context = CreateDecoratorContextObject(kind, key, extraInitializers, decorationState, isStatic);
+    let value: Value = Value.undefined;
+    if (kind === 'method') {
+      value = elementRecord.Value;
+    } else if (kind === 'getter') {
+      value = elementRecord.Get;
+    } else if (kind === 'setter') {
+      value = elementRecord.Set;
+    } else if (kind === 'accessor') {
+      value = OrdinaryObjectCreate(surroundingAgent.intrinsic('%Object.prototype%'));
+      X(CreateDataPropertyOrThrow(value, Value('get'), elementRecord.Get));
+      X(CreateDataPropertyOrThrow(value, Value('set'), elementRecord.Set));
+    }
+    // TODO(decorator): spec bug, missing GetValue call
+    // const newValue = Q(yield* Call(decorator, decoratorReceiver), [value, context]));
+    const newValue = Q(yield* Call(decorator, Q(yield* GetValue(decoratorReceiver)), [value, context]));
+    decorationState.Finished = true;
+    if (kind === 'field') {
+      if (IsCallable(newValue)) {
+        // TODO(decorator): spec bug. ApplyDecoratorsToElementDefinition unshift decorator initializers into this array, but read it in order, so the spec order is wrong (be like [decorator2, decorator1, syntaxInit], but the correct order should be [syntaxInit, decorator2, decorator1])
+        elementRecord.Initializers.unshift(newValue);
+      } else if (newValue !== Value.undefined) {
+        return Throw.TypeError('Field decorator must return a function or undefined, but $1 was returned', newValue);
+      }
+    } else if (kind === 'accessor') {
+      if (newValue instanceof ObjectValue) {
+        const newGetter = Q(yield* Get(newValue, Value('get')));
+        if (IsCallable(newGetter)) {
+          elementRecord.Get = newGetter;
+        } else if (newGetter !== Value.undefined) {
+          return Throw.TypeError('The get property of the return value of an accessor decorator must be a function or undefined, but $1 was returned', newGetter);
+        }
+        const newSetter = Q(yield* Get(newValue, Value('set')));
+        if (IsCallable(newSetter)) {
+          elementRecord.Set = newSetter;
+        } else if (newSetter !== Value.undefined) {
+          return Throw.TypeError('The set property of the return value of an accessor decorator must be a function or undefined, but $1 was returned', newSetter);
+        }
+        const initializer = Q(yield* Get(newValue, Value('init')));
+        if (IsCallable(initializer)) {
+          // TODO(decorator): spec bug. ApplyDecoratorsToElementDefinition unshift decorator initializers into this array, but read it in order, so the spec order is wrong (be like [decorator2, decorator1, syntaxInit], but the correct order should be [syntaxInit, decorator2, decorator1])
+          elementRecord.Initializers.unshift(initializer);
+        } else if (initializer !== Value.undefined) {
+          return Throw.TypeError('The init property of the return value of an accessor decorator must be a function or undefined, but $1 was returned', initializer);
+        }
+      } else if (newValue !== Value.undefined) {
+        return Throw.TypeError('Accessor decorator must return an object or undefined, but $1 was returned', newValue);
+      }
+    } else {
+      if (IsCallable(newValue)) {
+        if (kind === 'getter') {
+          elementRecord.Get = newValue;
+        } else if (kind === 'setter') {
+          elementRecord.Set = newValue;
+        } else {
+          elementRecord.Value = newValue;
+        }
+      } else if (newValue !== Value.undefined) {
+        return Throw.TypeError('Method decorator must return a function or undefined, but $1 was returned', newValue);
+      }
+    }
+  }
+  elementRecord.Decorators = undefined;
+  return undefined;
+}
+
+/** https://arai-a.github.io/ecma262-compare/snapshot.html?pr=2417#sec-applydecoratorstoclassdefinition */
+export function* ApplyDecoratorsToClassDefinition(classDef: FunctionObject, decorators: readonly DecoratorDefinitionRecord[], className: PropertyKeyValue | PrivateName, extraInitializers: FunctionObject[]): PlainEvaluator<FunctionObject> {
+  for (const decoratorRecord of decorators) {
+    const decorator = decoratorRecord.Decorator;
+    const decoratorReceiver = decoratorRecord.Receiver;
+    const decorationState = { Finished: false };
+    const context = CreateDecoratorContextObject('class', className, extraInitializers, decorationState);
+    // TODO(decorator): spec bug, missing GetValue call
+    // const newDef = Q(yield* Call(decorator, decoratorReceiver, [classDef, context]));
+    const newDef = Q(yield* Call(decorator, Q(yield* GetValue(decoratorReceiver)), [classDef, context]));
+    decorationState.Finished = true;
+    if (IsCallable(newDef)) {
+      classDef = newDef;
+    } else if (newDef !== Value.undefined) {
+      return Throw.TypeError('Class decorator must return a function or undefined, but $1 was returned', newDef);
+    }
+  }
+  return classDef;
+}
+
+/** https://arai-a.github.io/ecma262-compare/snapshot.html?pr=2417#sec-applydecoratorsanddefinemethod */
+export function* ApplyDecoratorsAndDefineMethod(homeObject: ObjectValue, methodDefinition: ClassElementDefinitionRecord, extraInitializers: FunctionObject[], isStatic: boolean): PlainEvaluator<void> {
+  Q(yield* ApplyDecoratorsToElementDefinition(homeObject, methodDefinition, extraInitializers, isStatic));
+  // TODO(decorator): spec bug, enumerable of class methods, whether decorated or not, should always be false
+  // Q(yield* DefineMethodProperty(homeObject, methodDefinition, isStatic));
+  Q(yield* DefineMethodProperty(homeObject, methodDefinition, false));
+}
+
+/** https://arai-a.github.io/ecma262-compare/snapshot.html?pr=2417#sec-decoratordefinition-record-specification-type */
+export interface DecoratorDefinitionRecord {
+  readonly Decorator: Value;
+  readonly Receiver: ReferenceRecord | Value;
+}
+
+/** https://arai-a.github.io/ecma262-compare/snapshot.html?pr=2417#sec-classfielddefinition-record-specification-type */
+export type ClassElementDefinitionRecord = ClassElementDefinitionRecord_Method | ClassElementDefinitionRecord_Field | ClassElementDefinitionRecord_Accessor | ClassElementDefinitionRecord_Getter | ClassElementDefinitionRecord_Setter;
+export interface ClassElementDefinitionRecord_Method {
+  readonly Kind: 'method';
+  readonly Key: PrivateName | JSStringValue | SymbolValue;
+  // TODO(decorator): spec bug, spec is ECMAScriptFunctionObject
+  Value: FunctionObject;
+  Decorators: DecoratorDefinitionRecord[] | undefined;
+}
+export interface ClassElementDefinitionRecord_Field {
+  readonly Kind: 'field';
+  readonly Key: PrivateName | JSStringValue | SymbolValue;
+  Decorators: DecoratorDefinitionRecord[] | undefined;
+  readonly Initializers: FunctionObject[];
+  readonly ExtraInitializers: FunctionObject[];
+}
+export interface ClassElementDefinitionRecord_Accessor {
+  readonly Kind: 'accessor';
+  readonly Key: PrivateName | JSStringValue | SymbolValue;
+  // https://github.com/tc39/proposal-decorators/issues/572
+  Get: FunctionObject;
+  // https://github.com/tc39/proposal-decorators/issues/572
+  Set: FunctionObject;
+  readonly BackingStorageKey: PrivateName;
+  Decorators: readonly DecoratorDefinitionRecord[] | undefined;
+  readonly Initializers: FunctionObject[];
+  readonly ExtraInitializers: FunctionObject[];
+}
+export interface ClassElementDefinitionRecord_Getter {
+  readonly Kind: 'getter';
+  readonly Key: PrivateName | JSStringValue | SymbolValue;
+  // https://github.com/tc39/proposal-decorators/issues/572
+  Get: FunctionObject;
+  Decorators: readonly DecoratorDefinitionRecord[] | undefined;
+}
+export interface ClassElementDefinitionRecord_Setter {
+  readonly Kind: 'setter';
+  readonly Key: PrivateName | JSStringValue | SymbolValue;
+  // https://github.com/tc39/proposal-decorators/issues/572
+  Set: FunctionObject;
+  Decorators: readonly DecoratorDefinitionRecord[] | undefined;
+}
+
+// This is a struct defined as a marco.
+export const ClassElementDefinitionRecord = (function ClassElementDefinitionRecord(record: ClassElementDefinitionRecord) {
+  Object.setPrototypeOf(record, ClassElementDefinitionRecord.prototype);
+  return record;
+}) as {
+  (record: ClassElementDefinitionRecord): ClassElementDefinitionRecord;
+  [Symbol.hasInstance](instance: unknown): instance is ClassElementDefinitionRecord;
+};