@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/runtime-semantics/LabelledStatement.mts

@@ -0,0 +1,11 @@
+import { JSStringSet } from '../utils/container.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { LabelledEvaluation } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-labelled-statements-runtime-semantics-evaluation */
+export function Evaluate_LabelledStatement(LabelledStatement: ParseNode.LabelledStatement) {
+  // 1. Let newLabelSet be a new empty List.
+  const newLabelSet = new JSStringSet();
+  // 2. Return LabelledEvaluation of this LabelledStatement with argument newLabelSet.
+  return LabelledEvaluation(LabelledStatement, newLabelSet);
+}

package/src/runtime-semantics/LexicalDeclaration.mts

@@ -0,0 +1,114 @@
+import { Evaluate, type PlainEvaluator } from '../evaluator.mts';
+import {
+  Q, X,
+} from '../completion.mts';
+import { Value } from '../value.mts';
+import { IsAnonymousFunctionDefinition, StringValue, type FunctionDeclaration } from '../static-semantics/all.mts';
+import { OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  AddDisposableResource,
+  type DisposableResourceKind,
+} from '../abstract-ops/disposable-operations.mts';
+import { DeclarativeEnvironmentRecord } from '../execution-context/Environment.mts';
+import { NamedEvaluation, BindingInitialization } from './all.mts';
+import {
+  surroundingAgent,
+  Assert,
+  GetValue,
+  InitializeReferencedBinding,
+  ResolveBinding,
+  IsUnresolvableReference,
+  type StatementEvaluator,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-bindingevaluation */
+function* BindingEvaluation_LexicalBinding(
+  LexicalBinding: ParseNode.LexicalBinding,
+  kind: 'normal' | DisposableResourceKind,
+): StatementEvaluator {
+  switch (true) {
+    case !!LexicalBinding.BindingIdentifier: {
+      // LexicalBinding : BindingIdentifier Initializer
+      if (LexicalBinding.Initializer) {
+        const { Initializer, BindingIdentifier } = LexicalBinding;
+        const bindingId = StringValue(BindingIdentifier);
+        const lhs = X(ResolveBinding(bindingId));
+        let value: Value;
+        if (IsAnonymousFunctionDefinition(Initializer)) {
+          value = Q(yield* NamedEvaluation(Initializer as FunctionDeclaration, bindingId));
+        } else {
+          const rhs = Q(yield* Evaluate(Initializer));
+          value = Q(yield* GetValue(rhs));
+        }
+        if (kind !== 'normal') {
+          Assert(IsUnresolvableReference(lhs) === Value.false);
+          const base = lhs.Base;
+          Assert(base instanceof DeclarativeEnvironmentRecord);
+          Q(yield* AddDisposableResource(base.DisposableResourceStack, value, kind));
+        }
+        Q(yield* InitializeReferencedBinding(lhs, value));
+        return undefined;
+      } else {
+        // LexicalBinding : BindingIdentifier
+        const { BindingIdentifier } = LexicalBinding;
+        Assert(kind === 'normal');
+        const lhs = X(ResolveBinding(StringValue(BindingIdentifier)));
+        X(InitializeReferencedBinding(lhs, Value.undefined));
+        return undefined;
+      }
+    }
+    case !!LexicalBinding.BindingPattern: {
+      const { Initializer, BindingPattern } = LexicalBinding;
+      Assert(kind === 'normal');
+      const rhs = Q(yield* Evaluate(Initializer!));
+      const value = Q(yield* GetValue(rhs));
+      const envRecord = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+      return Q(yield* BindingInitialization(BindingPattern, value, envRecord));
+    }
+    default:
+      throw OutOfRange.nonExhaustive(LexicalBinding);
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-bindingevaluation */
+//   BindingList : BindingList `,` LexicalBinding
+//
+// (implicit)
+//   BindingList : LexicalBinding
+export function* BindingEvaluation(
+  BindingList: ParseNode.BindingList,
+  kind: 'normal' | DisposableResourceKind,
+) {
+  // 1. Let next be the result of evaluating BindingList.
+  // 3. Return the result of evaluating LexicalBinding.
+  let next;
+  for (const LexicalBinding of BindingList) {
+    next = yield* BindingEvaluation_LexicalBinding(LexicalBinding, kind);
+    Q(next);
+  }
+  return next;
+}
+
+/** https://tc39.es/ecma262/#sec-let-and-const-declarations-runtime-semantics-evaluation */
+//   LexicalDeclaration : LetOrConst BindingList `;`
+export function* Evaluate_LexicalDeclaration(
+  declaration: ParseNode.LexicalDeclaration | ParseNode.UsingDeclaration | ParseNode.AwaitUsingDeclaration,
+): PlainEvaluator {
+  switch (declaration.type) {
+    case 'LexicalDeclaration': {
+      Q(yield* BindingEvaluation(declaration.BindingList, 'normal'));
+      return undefined;
+    }
+    case 'UsingDeclaration': {
+      Q(yield* BindingEvaluation(declaration.BindingList, 'sync-dispose'));
+      return undefined;
+    }
+    case 'AwaitUsingDeclaration': {
+      Q(yield* BindingEvaluation(declaration.BindingList, 'async-dispose'));
+      return undefined;
+    }
+    default:
+      throw OutOfRange.exhaustive(declaration);
+  }
+}

package/src/runtime-semantics/Literal.mts

@@ -0,0 +1,36 @@
+import { Value } from '../value.mts';
+import { StringValue, NumericValue } from '../static-semantics/all.mts';
+import { OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { NormalCompletion } from '../completion.mts';
+
+/** https://tc39.es/ecma262/#sec-literals-runtime-semantics-evaluation */
+// Literal :
+//   NullLiteral
+//   BooleanLiteral
+//   NumericLiteral
+//   StringLiteral
+export function Evaluate_Literal(Literal: ParseNode.Literal): NormalCompletion<Value> {
+  switch (Literal.type) {
+    case 'NullLiteral':
+      // 1. Return null.
+      return NormalCompletion(Value.null);
+    case 'BooleanLiteral':
+      // 1. If BooleanLiteral is the token false, return false.
+      if (Literal.value === false) {
+        return NormalCompletion(Value.false);
+      }
+      // 2. If BooleanLiteral is the token true, return true.
+      if (Literal.value === true) {
+        return NormalCompletion(Value.true);
+      }
+      throw OutOfRange.nonExhaustive(Literal);
+    case 'NumericLiteral':
+      // 1. Return the NumericValue of NumericLiteral as defined in 11.8.3.
+      return NormalCompletion(NumericValue(Literal));
+    case 'StringLiteral':
+      return NormalCompletion(StringValue(Literal));
+    default:
+      throw OutOfRange.exhaustive(Literal);
+  }
+}

package/src/runtime-semantics/LogicalANDExpression.mts

@@ -0,0 +1,25 @@
+import { Value } from '../value.mts';
+import { Evaluate, type ValueEvaluator } from '../evaluator.mts';
+import { Q, X } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { GetValue, ToBoolean } from '#self';
+
+/** https://tc39.es/ecma262/#sec-binary-logical-operators-runtime-semantics-evaluation */
+//   LogicalANDExpression :
+//     LogicalANDExpression `&&` BitwiseORExpression
+export function* Evaluate_LogicalANDExpression({ LogicalANDExpression, BitwiseORExpression }: ParseNode.LogicalANDExpression): ValueEvaluator {
+  // 1. Let lref be the result of evaluating LogicalANDExpression.
+  const lref = Q(yield* Evaluate(LogicalANDExpression));
+  // 2. Let lval be ? GetValue(lref).
+  const lval = Q(yield* GetValue(lref));
+  // 3. Let lbool be ! ToBoolean(lval).
+  const lbool = X(ToBoolean(lval));
+  // 4. If lbool is false, return lval.
+  if (lbool === Value.false) {
+    return lval;
+  }
+  // 5. Let rref be the result of evaluating BitwiseORExpression.
+  const rref = Q(yield* Evaluate(BitwiseORExpression));
+  // 6. Return ? GetValue(rref).
+  return Q(yield* GetValue(rref));
+}

package/src/runtime-semantics/LogicalORExpression.mts

@@ -0,0 +1,25 @@
+import { Value } from '../value.mts';
+import { Evaluate, type ValueEvaluator } from '../evaluator.mts';
+import { Q, X } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { GetValue, ToBoolean } from '#self';
+
+/** https://tc39.es/ecma262/#sec-binary-logical-operators-runtime-semantics-evaluation */
+//   LogicalORExpression :
+//     LogicalORExpression `||` LogicalANDExpression
+export function* Evaluate_LogicalORExpression({ LogicalORExpression, LogicalANDExpression }: ParseNode.LogicalORExpression): ValueEvaluator {
+  // 1. Let lref be the result of evaluating LogicalORExpression.
+  const lref = Q(yield* Evaluate(LogicalORExpression));
+  // 2. Let lval be ? GetValue(lref).
+  const lval = Q(yield* GetValue(lref));
+  // 3. Let lbool be ! ToBoolean(lval).
+  const lbool = X(ToBoolean(lval));
+  // 4. If lbool is false, return lval.
+  if (lbool === Value.true) {
+    return lval;
+  }
+  // 5. Let rref be the result of evaluating LogicalANDExpression.
+  const rref = Q(yield* Evaluate(LogicalANDExpression));
+  // 6. Return ? GetValue(rref).
+  return Q(yield* GetValue(rref));
+}

package/src/runtime-semantics/MV.mts

@@ -0,0 +1,10 @@
+import { F } from '#self';
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-mv-s */
+//   StringNumericLiteral :::
+//     [empty]
+//     StrWhiteSpace
+//     StrWhiteSpace_opt StrNumericLiteral StrWhiteSpace_opt
+export function MV_StringNumericLiteral(StringNumericLiteral: string) {
+  return F(Number(StringNumericLiteral));
+}

package/src/runtime-semantics/MemberExpression.mts

@@ -0,0 +1,71 @@
+import { Evaluate } from '../evaluator.mts';
+import { Q, X } from '../completion.mts';
+import { OutOfRange } from '../utils/language.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  EvaluatePropertyAccessWithExpressionKey,
+  EvaluatePropertyAccessWithIdentifierKey,
+} from './all.mts';
+import { GetValue, MakePrivateReference } from '#self';
+import type { PlainEvaluator, ReferenceRecord } from '#self';
+
+/** https://tc39.es/ecma262/#sec-property-accessors-runtime-semantics-evaluation */
+//   MemberExpression : MemberExpression `[` Expression `]`
+//   CallExpression : CallExpression `[` Expression `]`
+function* Evaluate_MemberExpression_Expression({ strict, MemberExpression, Expression }: ParseNode.MemberExpression): PlainEvaluator<ReferenceRecord> {
+  // 1. Let baseReference be the result of evaluating |MemberExpression|.
+  const baseReference = Q(yield* Evaluate(MemberExpression));
+  // 2. Let baseValue be ? GetValue(baseReference).
+  const baseValue = Q(yield* GetValue(baseReference));
+  // 3. If the code matched by this |MemberExpression| is strict mode code, let strict be true; else let strict be false.
+  // 4. Return ? EvaluatePropertyAccessWithExpressionKey(baseValue, |Expression|, strict).
+  return Q(yield* EvaluatePropertyAccessWithExpressionKey(baseValue, Expression!, strict));
+}
+
+/** https://tc39.es/ecma262/#sec-property-accessors-runtime-semantics-evaluation */
+//   MemberExpression : MemberExpression `.` IdentifierName
+//   CallExpression : CallExpression `.` IdentifierName
+function* Evaluate_MemberExpression_IdentifierName({ strict, MemberExpression, IdentifierName }: ParseNode.MemberExpression): PlainEvaluator<ReferenceRecord> {
+  // 1. Let baseReference be the result of evaluating |MemberExpression|.
+  const baseReference = Q(yield* Evaluate(MemberExpression));
+  // 2. Let baseValue be ? GetValue(baseReference).
+  const baseValue = Q(yield* GetValue(baseReference));
+  // 3. If the code matched by this |MemberExpression| is strict mode code, let strict be true; else let strict be false.
+  // 4. Return ! EvaluatePropertyAccessWithIdentifierKey(baseValue, |IdentifierName|, strict).
+  return X(EvaluatePropertyAccessWithIdentifierKey(baseValue, IdentifierName!, strict));
+}
+
+/** https://tc39.es/ecma262/#sec-property-accessors-runtime-semantics-evaluation */
+//   MemberExpression : MemberExpression `.` PrivateIdentifier
+//   CallExpression : CallExpression `.` PrivateIdentifier
+function* Evaluate_MemberExpression_PrivateIdentifier({ MemberExpression, PrivateIdentifier }: ParseNode.MemberExpression): PlainEvaluator<ReferenceRecord> {
+  // 1. Let baseReference be the result of evaluating MemberExpression.
+  const baseReference = Q(yield* Evaluate(MemberExpression));
+  // 2. Let baseValue be ? GetValue(baseReference).
+  const baseValue = Q(yield* GetValue(baseReference));
+  // 3. Let fieldNameString be the StringValue of PrivateIdentifier.
+  const fieldNameString = StringValue(PrivateIdentifier!);
+  // 4. Return ! MakePrivateReference(bv, fieldNameString).
+  return X(MakePrivateReference(baseValue, fieldNameString));
+}
+
+/** https://tc39.es/ecma262/#sec-property-accessors-runtime-semantics-evaluation */
+//   MemberExpression :
+//     MemberExpression `[` Expression `]`
+//     MemberExpression `.` IdentifierName
+//   CallExpression :
+//     CallExpression `[` Expression `]`
+//     CallExpression `.` IdentifierName
+export function Evaluate_MemberExpression(MemberExpression: ParseNode.MemberExpression) {
+  switch (true) {
+    case !!MemberExpression.Expression:
+      return Evaluate_MemberExpression_Expression(MemberExpression);
+    case !!MemberExpression.IdentifierName:
+      return Evaluate_MemberExpression_IdentifierName(MemberExpression);
+    case !!MemberExpression.PrivateIdentifier:
+      return Evaluate_MemberExpression_PrivateIdentifier(MemberExpression);
+    default:
+      throw OutOfRange.nonExhaustive(MemberExpression);
+  }
+}

package/src/runtime-semantics/MethodDefinitionEvaluation.mts

@@ -0,0 +1,364 @@
+import {
+  Value, Descriptor, PrivateName, UndefinedValue, type PropertyKeyValue, ObjectValue, BooleanValue,
+} from '../value.mts';
+import {
+  Q, X,
+} from '../completion.mts';
+import { OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { PlainEvaluator } from '../evaluator.mts';
+import { ClassElementDefinitionRecord, DefineMethod, Evaluate_PropertyName } from './all.mts';
+import { surroundingAgent } from '#self';
+import {
+  OrdinaryObjectCreate,
+  OrdinaryFunctionCreate,
+  DefinePropertyOrThrow,
+  SetFunctionName,
+  MakeMethod,
+  sourceTextMatchedBy,
+  type FunctionObject,
+  type GCMarker,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-privateelement-specification-type */
+export interface PrivateElementRecord_Value {
+  readonly Key: PrivateName;
+  readonly Kind: 'method' | 'field';
+  Value?: Value;
+  readonly Getter?: undefined;
+  readonly Setter?: undefined;
+}
+export interface PrivateElementRecord_Accessor {
+  readonly Key: PrivateName;
+  readonly Kind: 'accessor';
+  Value?: Value;
+  readonly Getter?: FunctionObject | UndefinedValue;
+  readonly Setter?: FunctionObject | UndefinedValue;
+}
+export type PrivateElementRecord = PrivateElementRecord_Value | PrivateElementRecord_Accessor;
+export const PrivateElementRecord = function PrivateElementRecord(value: PrivateElementRecord) {
+  Object.setPrototypeOf(value, PrivateElementRecord.prototype);
+  return value;
+} as {
+  (value: PrivateElementRecord): PrivateElementRecord;
+  [Symbol.hasInstance](instance: unknown): instance is PrivateElementRecord;
+};
+
+// NON-SPEC
+PrivateElementRecord.prototype.mark = function mark(m: GCMarker): void {
+  m(this.Value);
+  m(this.Get);
+  m(this.Set);
+};
+
+// -decorator
+// +decorator: remove this function
+/** https://tc39.es/ecma262/#sec-definemethodproperty */
+function* DefineMethodProperty(key: PropertyKeyValue | PrivateName, homeObject: ObjectValue, closure: FunctionObject, enumerable: BooleanValue): PlainEvaluator<PrivateElementRecord | undefined> {
+  // 1. If key is a Private Name, then
+  if (key instanceof PrivateName) {
+    // a. Return PrivateElement { [[Key]]: key, [[Kind]]: method, [[Value]]: closure }.
+    return PrivateElementRecord({
+      Key: key,
+      Kind: 'method',
+      Value: closure,
+    });
+  } else { // 2. Else,
+    // a. Let desc be the PropertyDescriptor { [[Value]]: closure, [[Writable]]: true, [[Enumerable]]: enumerable, [[Configurable]]: true }.
+    const desc = Descriptor({
+      Value: closure,
+      Writable: Value.true,
+      Enumerable: enumerable,
+      Configurable: Value.true,
+    });
+    // b. Perform ? DefinePropertyOrThrow(homeObject, key, desc).
+    Q(yield* DefinePropertyOrThrow(homeObject, key, desc));
+    // c. Return empty.
+    return undefined;
+  }
+}
+
+// MethodDefinition :
+//   ClassElementName `(` UniqueFormalParameters `)` `{` FunctionBody `}`
+//   `get` ClassElementName `(` `)` `{` FunctionBody `}`
+//   `set` ClassElementName `(` PropertySetParameterList `)` `{` FunctionBody `}`
+// -decorator signature
+function MethodDefinitionEvaluation_MethodDefinition(MethodDefinition: ParseNode.MethodDefinition, object: ObjectValue, enumerable: BooleanValue): PlainEvaluator<ClassElementDefinitionRecord>
+// +decorator signature
+function MethodDefinitionEvaluation_MethodDefinition(MethodDefinition: ParseNode.MethodDefinition, object: ObjectValue): PlainEvaluator<ClassElementDefinitionRecord>
+function* MethodDefinitionEvaluation_MethodDefinition(MethodDefinition: ParseNode.MethodDefinition, object: ObjectValue, enumerable?: BooleanValue): PlainEvaluator<ClassElementDefinitionRecord | PrivateElementRecord | void> {
+  switch (true) {
+    case !!MethodDefinition.UniqueFormalParameters: {
+      // 1. Let methodDef be ? DefineMethod of MethodDefinition with argument object.
+      const methodDef = Q(yield* DefineMethod(MethodDefinition, object));
+      // 2. Perform ! SetFunctionName(methodDef.[[Closure]], methodDef.[[Key]]).
+      X(SetFunctionName(methodDef.Closure, methodDef.Key));
+      // 3. Return ? DefineMethodProperty(methodDef.[[Key]], object, methodDef.[[Closure]], enumerable).
+      if (enumerable) {
+        return Q(yield* DefineMethodProperty(methodDef.Key, object, methodDef.Closure, enumerable));
+      } else {
+        return ClassElementDefinitionRecord({
+          Key: methodDef.Key,
+          Kind: 'method',
+          Value: methodDef.Closure,
+          Decorators: undefined,
+        });
+      }
+    }
+    case !!MethodDefinition.PropertySetParameterList: {
+      const { ClassElementName, PropertySetParameterList, FunctionBody } = MethodDefinition;
+      // 1. Let propKey be the result of evaluating ClassElementName.
+      const propKey = Q(yield* Evaluate_PropertyName(ClassElementName));
+      // 3. Let scope be the running execution context's LexicalEnvironment.
+      const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+      // 4. Let privateScope be the running execution context's PrivateEnvironment.
+      const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+      // 5. Let sourceText be the source text matched by MethodDefinition.
+      const sourceText = sourceTextMatchedBy(MethodDefinition);
+      // 6. Let closure be OrdinaryFunctionCreate(%Function.prototype%, sourceText, PropertySetParameterList, FunctionBody, non-lexical-this, scope, privateScope).
+      const closure = OrdinaryFunctionCreate(surroundingAgent.intrinsic('%Function.prototype%'), sourceText, PropertySetParameterList, FunctionBody, 'non-lexical-this', scope, privateScope);
+      // 7. Perform MakeMethod(closure, object).
+      MakeMethod(closure, object);
+      // 8. Perform SetFunctionName(closure, propKey, "get").
+      SetFunctionName(closure, propKey, Value('set'));
+      if (enumerable) {
+        // 9. If propKey is a Private Name, then
+        if (propKey instanceof PrivateName) {
+        // a. Return PrivateElement { [[Key]]: propKey, [[Kind]]: accessor, [[Get]]: undefined, [[Set]]: closure }.
+          return PrivateElementRecord({
+            Key: propKey,
+            Kind: 'accessor',
+            Getter: Value.undefined,
+            Setter: closure,
+          });
+        } else { // 10. Else,
+        // a. Let desc be the PropertyDescriptor { [[Get]]: closure, [[Enumerable]]: enumerable, [[Configurable]]: true }.
+          const desc = Descriptor({
+            Setter: closure,
+            Enumerable: enumerable,
+            Configurable: Value.true,
+          });
+          // b. Perform ? DefinePropertyOrThrow(object, propKey, desc).
+          Q(yield* DefinePropertyOrThrow(object, propKey, desc));
+          // c. Return empty.
+          return undefined;
+        }
+      } else {
+        return ClassElementDefinitionRecord({
+          Key: propKey,
+          Kind: 'setter',
+          Set: closure,
+          Decorators: undefined,
+        });
+      }
+    }
+    case !MethodDefinition.UniqueFormalParameters && !MethodDefinition.PropertySetParameterList: {
+      const { ClassElementName, FunctionBody } = MethodDefinition;
+      // 1. Let propKey be the result of evaluating ClassElementName.
+      const propKey = Q(yield* Evaluate_PropertyName(ClassElementName));
+      // 3. Let scope be the running execution context's LexicalEnvironment.
+      const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+      // 4. Let privateScope be the running execution context's PrivateEnvironment.
+      const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+      // 5. Let formalParameterList be an instance of the production FormalParameters : [empty].
+      const formalParameterList: ParseNode.FormalParameters = [];
+      // 6. Let sourceText be the source text matched by MethodDefinition.
+      const sourceText = sourceTextMatchedBy(MethodDefinition);
+      // 7. Let closure be OrdinaryFunctionCreate(%Function.prototype%, sourceText, formalParameterList, FunctionBody, non-lexical-this, scope, privateScope).
+      const closure = OrdinaryFunctionCreate(surroundingAgent.intrinsic('%Function.prototype%'), sourceText, formalParameterList, FunctionBody, 'non-lexical-this', scope, privateScope);
+      // 8. Perform MakeMethod(closure, object).
+      MakeMethod(closure, object);
+      // 9. Perform SetFunctionName(closure, propKey, "get").
+      SetFunctionName(closure, propKey, Value('get'));
+      if (enumerable) {
+        // 10. If propKey is a Private Name, then
+        if (propKey instanceof PrivateName) {
+          return PrivateElementRecord({
+            Key: propKey,
+            Kind: 'accessor',
+            Getter: closure,
+            Setter: Value.undefined,
+          });
+        } else { // 11. Else,
+          // a. Let desc be the PropertyDescriptor { [[Get]]: closure, [[Enumerable]]: enumerable, [[Configurable]]: true }.
+          const desc = Descriptor({
+            Getter: closure,
+            Enumerable: enumerable,
+            Configurable: Value.true,
+          });
+          // b. Perform ? DefinePropertyOrThrow(object, propKey, desc).
+          Q(yield* DefinePropertyOrThrow(object, propKey, desc));
+          // c. Return empty.
+          return undefined;
+        }
+      } else {
+        return ClassElementDefinitionRecord({
+          Key: propKey,
+          Kind: 'getter',
+          Get: closure,
+          Decorators: undefined,
+        });
+      }
+    }
+    default:
+      throw OutOfRange.nonExhaustive(MethodDefinition);
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-async-function-definitions-MethodDefinitionEvaluation */
+//   AsyncMethod :
+//     `async` ClassElementName `(` UniqueFormalParameters `)` `{` AsyncBody `}`
+// -decorator signature
+function MethodDefinitionEvaluation_AsyncMethod(AsyncMethod: ParseNode.AsyncMethod, object: ObjectValue, enumerable: BooleanValue): PlainEvaluator<PrivateElementRecord | void>
+// +decorator signature
+function MethodDefinitionEvaluation_AsyncMethod(AsyncMethod: ParseNode.AsyncMethod, object: ObjectValue): PlainEvaluator<ClassElementDefinitionRecord>
+function* MethodDefinitionEvaluation_AsyncMethod(AsyncMethod: ParseNode.AsyncMethod, object: ObjectValue, enumerable?: BooleanValue): PlainEvaluator<ClassElementDefinitionRecord | PrivateElementRecord | void> {
+  const { ClassElementName, UniqueFormalParameters, AsyncBody } = AsyncMethod;
+  // 1. Let propKey be the result of evaluating ClassElementName.
+  const propKey = Q(yield* Evaluate_PropertyName(ClassElementName));
+  // 3. Let scope be the LexicalEnvironment of the running execution context.
+  const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 4. Let privateScope be the running execution context's PrivateEnvironment.
+  const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 5. Let sourceText be the source text matched by AsyncMethod.
+  const sourceText = sourceTextMatchedBy(AsyncMethod);
+  // 6. Let closure be ! OrdinaryFunctionCreate(%AsyncFunction.prototype%, sourceText, UniqueFormalParameters, AsyncBody, non-lexical-this, scope, privateScope).
+  const closure = X(OrdinaryFunctionCreate(surroundingAgent.intrinsic('%AsyncFunction.prototype%'), sourceText, UniqueFormalParameters, AsyncBody, 'non-lexical-this', scope, privateScope));
+  // 7. Perform ! MakeMethod(closure, object).
+  X(MakeMethod(closure, object));
+  // 8. Perform ! SetFunctionName(closure, propKey).
+  X(SetFunctionName(closure, propKey));
+  if (enumerable) {
+    // 9. Return ? DefineMethodProperty(propKey, object, closure, enumerable).
+    return Q(yield* DefineMethodProperty(propKey, object, closure, enumerable));
+  } else {
+    return ClassElementDefinitionRecord({
+      Key: propKey,
+      Kind: 'method',
+      Value: closure,
+      Decorators: undefined,
+    });
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation */
+//   GeneratorMethod :
+//     `*` ClassElementName `(` UniqueFormalParameters `)` `{` GeneratorBody `}`
+function MethodDefinitionEvaluation_GeneratorMethod(GeneratorMethod: ParseNode.GeneratorMethod, object: ObjectValue, enumerable: BooleanValue): PlainEvaluator<PrivateElementRecord | void>
+function MethodDefinitionEvaluation_GeneratorMethod(GeneratorMethod: ParseNode.GeneratorMethod, object: ObjectValue): PlainEvaluator<ClassElementDefinitionRecord>
+function* MethodDefinitionEvaluation_GeneratorMethod(GeneratorMethod: ParseNode.GeneratorMethod, object: ObjectValue, enumerable?: BooleanValue): PlainEvaluator<ClassElementDefinitionRecord | PrivateElementRecord | void> {
+  const { ClassElementName, UniqueFormalParameters, GeneratorBody } = GeneratorMethod;
+  // 1. Let propKey be the result of evaluating ClassElementName.
+  let propKey = yield* Evaluate_PropertyName(ClassElementName);
+  propKey = Q(propKey);
+  // 3. Let scope be the LexicalEnvironment of the running execution context.
+  const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 4. Let privateScope be the running execution context's PrivateEnvironment.
+  const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 5. Let sourceText be the source text matched by GeneratorMethod.
+  const sourceText = sourceTextMatchedBy(GeneratorMethod);
+  // 6. Let closure be ! OrdinaryFunctionCreate(%GeneratorFunction.prototype%, sourceText, UniqueFormalParameters, AsyncBody, non-lexical-this, scope, privateScope).
+  const closure = X(OrdinaryFunctionCreate(surroundingAgent.intrinsic('%GeneratorFunction.prototype%'), sourceText, UniqueFormalParameters, GeneratorBody, 'non-lexical-this', scope, privateScope));
+  // 7. Perform ! MakeMethod(closure, object).
+  X(MakeMethod(closure, object));
+  // 8. Perform ! SetFunctionName(closure, propKey).
+  X(SetFunctionName(closure, propKey));
+  // 9. Let prototype be OrdinaryObjectCreate(%GeneratorFunction.prototype.prototype%).
+  const prototype = OrdinaryObjectCreate(surroundingAgent.intrinsic('%GeneratorFunction.prototype.prototype%'));
+  // 10. Perform DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
+  X(DefinePropertyOrThrow(closure, Value('prototype'), Descriptor({
+    Value: prototype,
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+  if (enumerable) {
+    // 11. Return ? DefineMethodProperty(propKey, object, closure, enumerable).
+    return Q(yield* DefineMethodProperty(propKey, object, closure, enumerable));
+  } else {
+    return ClassElementDefinitionRecord({
+      Key: propKey,
+      Kind: 'method',
+      Value: closure,
+      Decorators: undefined,
+    });
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgenerator-definitions-propertydefinitionevaluation */
+//   AsyncGeneratorMethod :
+//     `async` `*` PropertyName `(` UniqueFormalParameters `)` `{` AsyncGeneratorBody `}`
+function MethodDefinitionEvaluation_AsyncGeneratorMethod(AsyncGeneratorMethod: ParseNode.AsyncGeneratorMethod, object: ObjectValue, enumerable: BooleanValue): PlainEvaluator<PrivateElementRecord | void>
+function MethodDefinitionEvaluation_AsyncGeneratorMethod(AsyncGeneratorMethod: ParseNode.AsyncGeneratorMethod, object: ObjectValue): PlainEvaluator<ClassElementDefinitionRecord>
+function* MethodDefinitionEvaluation_AsyncGeneratorMethod(AsyncGeneratorMethod: ParseNode.AsyncGeneratorMethod, object: ObjectValue, enumerable?: BooleanValue): PlainEvaluator<ClassElementDefinitionRecord | PrivateElementRecord | void> {
+  const { ClassElementName, UniqueFormalParameters, AsyncGeneratorBody } = AsyncGeneratorMethod;
+  // 1. Let propKey be the result of evaluating ClassElementName.
+  let propKey = yield* Evaluate_PropertyName(ClassElementName);
+  propKey = Q(propKey);
+  // 3. Let scope be the LexicalEnvironment of the running execution context.
+  const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 4. Let privateScope be the running execution context's PrivateEnvironment.
+  const privateEnv = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 5. Let sourceText be the source text matched by AsyncGeneratorMethod.
+  const sourceText = sourceTextMatchedBy(AsyncGeneratorMethod);
+  // 6. Let closure be ! OrdinaryFunctionCreate(%AsyncGeneratorFunction.prototype%, sourceText, UniqueFormalParameters, AsyncGeneratorBody, non-lexical-this, scope, privateScope).
+  const closure = X(OrdinaryFunctionCreate(surroundingAgent.intrinsic('%AsyncGeneratorFunction.prototype%'), sourceText, UniqueFormalParameters, AsyncGeneratorBody, 'non-lexical-this', scope, privateEnv));
+  // 7. Perform ! MakeMethod(closure, object).
+  X(MakeMethod(closure, object));
+  // 9. Perform ! SetFunctionName(closure, propKey).
+  X(SetFunctionName(closure, propKey));
+  // 9. Let prototype be OrdinaryObjectCreate(%AsyncGeneratorFunction.prototype.prototype%).
+  const prototype = OrdinaryObjectCreate(surroundingAgent.intrinsic('%AsyncGeneratorFunction.prototype.prototype%'));
+  // 10. Perform DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
+  X(DefinePropertyOrThrow(closure, Value('prototype'), Descriptor({
+    Value: prototype,
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+  if (enumerable) {
+    // 11. Return ? DefineMethodProperty(propKey, object, closure, enumerable).
+    return Q(yield* DefineMethodProperty(propKey, object, closure, enumerable));
+  } else {
+    return ClassElementDefinitionRecord({
+      Key: propKey,
+      Kind: 'method',
+      Value: closure,
+      Decorators: undefined,
+    });
+  }
+}
+
+// -decorator
+export function MethodDefinitionEvaluation(node: ParseNode.MethodDefinitionLike, object: ObjectValue, enumerable: BooleanValue): PlainEvaluator<PrivateElementRecord | void>
+// +decorator
+export function MethodDefinitionEvaluation(node: ParseNode.MethodDefinitionLike, object: ObjectValue): PlainEvaluator<ClassElementDefinitionRecord>
+export function MethodDefinitionEvaluation(node: ParseNode.MethodDefinitionLike, object: ObjectValue, enumerable?: BooleanValue): PlainEvaluator<ClassElementDefinitionRecord | PrivateElementRecord | void> {
+  if (enumerable) {
+    switch (node.type) {
+      case 'MethodDefinition':
+        return MethodDefinitionEvaluation_MethodDefinition(node, object, enumerable);
+      case 'AsyncMethod':
+        return MethodDefinitionEvaluation_AsyncMethod(node, object, enumerable);
+      case 'GeneratorMethod':
+        return MethodDefinitionEvaluation_GeneratorMethod(node, object, enumerable);
+      case 'AsyncGeneratorMethod':
+        return MethodDefinitionEvaluation_AsyncGeneratorMethod(node, object, enumerable);
+      default:
+        throw OutOfRange.exhaustive(node);
+    }
+  } else {
+    switch (node.type) {
+      case 'MethodDefinition':
+        return MethodDefinitionEvaluation_MethodDefinition(node, object);
+      case 'AsyncMethod':
+        return MethodDefinitionEvaluation_AsyncMethod(node, object);
+      case 'GeneratorMethod':
+        return MethodDefinitionEvaluation_GeneratorMethod(node, object);
+      case 'AsyncGeneratorMethod':
+        return MethodDefinitionEvaluation_AsyncGeneratorMethod(node, object);
+      default:
+        throw OutOfRange.exhaustive(node);
+    }
+  }
+}