@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/runtime-semantics/Module.mts

@@ -0,0 +1,15 @@
+import { Value } from '../value.mts';
+import { NormalCompletion } from '../completion.mts';
+import { Evaluate } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-module-semantics-runtime-semantics-evaluation */
+// Module :
+//   [empty]
+//   ModuleBody
+export function* Evaluate_Module({ ModuleBody }: ParseNode.Module) {
+  if (!ModuleBody) {
+    return NormalCompletion(Value.undefined);
+  }
+  return yield* Evaluate(ModuleBody);
+}

package/src/runtime-semantics/ModuleBody.mts

@@ -0,0 +1,10 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { Evaluate_StatementList } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-module-semantics-runtime-semantics-evaluation */
+// ModuleBody : ModuleItemList
+export function Evaluate_ModuleBody({ ModuleItemList }: ParseNode.ModuleBody) {
+  // TODO(ts): ModuleItemList might contain ImportDeclaration or ExportDeclaration which is not accepted by Evaluate_StatementList.
+  // @ts-expect-error
+  return Evaluate_StatementList(ModuleItemList);
+}

package/src/runtime-semantics/MultiplicativeExpression.mts

@@ -0,0 +1,18 @@
+import { Q } from '../completion.mts';
+import type { ValueEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { EvaluateStringOrNumericBinaryExpression } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-multiplicative-operators-runtime-semantics-evaluation */
+//   MultiplicativeExpression :
+//     MultiplicativeExpression MultiplicativeOperator ExponentiationExpression
+export function* Evaluate_MultiplicativeExpression({
+  MultiplicativeExpression,
+  MultiplicativeOperator,
+  ExponentiationExpression,
+}: ParseNode.MultiplicativeExpression): ValueEvaluator {
+  // 1. Let opText be the source text matched by MultiplicativeOperator.
+  const opText = MultiplicativeOperator;
+  // 2. Return ? EvaluateStringOrNumericBinaryExpression(MultiplicativeExpression, opText, ExponentiationExpression).
+  return Q(yield* EvaluateStringOrNumericBinaryExpression(MultiplicativeExpression, opText, ExponentiationExpression));
+}

package/src/runtime-semantics/NamedEvaluation.mts

@@ -0,0 +1,97 @@
+import { Value } from '../value.mts';
+import { Q } from '../completion.mts';
+import { OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { ValueEvaluator } from '../evaluator.mts';
+import {
+  ClassDefinitionEvaluation,
+  InstantiateOrdinaryFunctionExpression,
+  InstantiateAsyncFunctionExpression,
+  InstantiateGeneratorFunctionExpression,
+  InstantiateAsyncGeneratorFunctionExpression,
+  InstantiateArrowFunctionExpression,
+  InstantiateAsyncArrowFunctionExpression,
+  DecoratorListEvaluation,
+} from './all.mts';
+import type {
+  FunctionDeclaration, FunctionObject, PrivateName, PropertyKeyValue,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-namedevaluation */
+//   FunctionExpression :
+//     `function` `(` FormalParameters `)` `{` FunctionBody `}`
+function NamedEvaluation_FunctionExpression(FunctionExpression: ParseNode.FunctionExpression, name: PropertyKeyValue | PrivateName) {
+  return InstantiateOrdinaryFunctionExpression(FunctionExpression, name);
+}
+
+
+/** https://tc39.es/ecma262/#sec-generator-function-definitions-runtime-semantics-namedevaluation */
+//   GeneratorExpression :
+//     `function` `*` `(` FormalParameters `)` `{` GeneratorBody `}`
+function NamedEvaluation_GeneratorExpression(GeneratorExpression: ParseNode.GeneratorExpression, name: PropertyKeyValue | PrivateName) {
+  return InstantiateGeneratorFunctionExpression(GeneratorExpression, name);
+}
+
+/** https://tc39.es/ecma262/#sec-async-function-definitions-runtime-semantics-namedevaluation */
+//   AsyncFunctionExpression :
+//     `async` `function` `(` FormalParameters `)` `{` AsyncBody `}`
+function NamedEvaluation_AsyncFunctionExpression(AsyncFunctionExpression: ParseNode.AsyncFunctionExpression, name: PropertyKeyValue | PrivateName) {
+  return InstantiateAsyncFunctionExpression(AsyncFunctionExpression, name);
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgenerator-definitions-namedevaluation */
+//   AsyncGeneratorExpression :
+//     `async` `function` `*` `(` FormalParameters `)` `{` AsyncGeneratorBody `}`
+function NamedEvaluation_AsyncGeneratorExpression(AsyncGeneratorExpression: ParseNode.AsyncGeneratorExpression, name: PropertyKeyValue | PrivateName) {
+  return InstantiateAsyncGeneratorFunctionExpression(AsyncGeneratorExpression, name);
+}
+
+/** https://tc39.es/ecma262/#sec-arrow-function-definitions-runtime-semantics-namedevaluation */
+//   ArrowFunction :
+//     ArrowParameters `=>` ConciseBody
+function NamedEvaluation_ArrowFunction(ArrowFunction: ParseNode.ArrowFunction, name: PropertyKeyValue | PrivateName) {
+  return InstantiateArrowFunctionExpression(ArrowFunction, name);
+}
+
+/** https://tc39.es/ecma262/#sec-arrow-function-definitions-runtime-semantics-namedevaluation */
+//   AsyncArrowFunction :
+//     ArrowParameters `=>` AsyncConciseBody
+function NamedEvaluation_AsyncArrowFunction(AsyncArrowFunction: ParseNode.AsyncArrowFunction, name: PropertyKeyValue | PrivateName) {
+  return InstantiateAsyncArrowFunctionExpression(AsyncArrowFunction, name);
+}
+
+/** https://tc39.es/ecma262/#sec-class-definitions-runtime-semantics-namedevaluation */
+//   ClassExpression : `class` ClassTail
+function* NamedEvaluation_ClassExpression(ClassExpression: ParseNode.ClassExpression, name: PropertyKeyValue | PrivateName) {
+  const { ClassTail, Decorators } = ClassExpression;
+  const decorators = Decorators ? Q(yield* DecoratorListEvaluation(Decorators)) : [];
+  const sourceText = ClassExpression.sourceText;
+  // 1. Let value be the result of ClassDefinitionEvaluation of ClassTail with arguments undefined and name.
+  const value = yield* ClassDefinitionEvaluation(ClassTail, Value.undefined, name, sourceText, decorators);
+  Q(value);
+  // 4. Return value.
+  return value;
+}
+
+export function* NamedEvaluation(F: FunctionDeclaration, name: PropertyKeyValue | PrivateName): ValueEvaluator<FunctionObject> {
+  switch (F.type) {
+    case 'FunctionExpression':
+      return NamedEvaluation_FunctionExpression(F, name);
+    case 'GeneratorExpression':
+      return NamedEvaluation_GeneratorExpression(F, name);
+    case 'AsyncFunctionExpression':
+      return NamedEvaluation_AsyncFunctionExpression(F, name);
+    case 'AsyncGeneratorExpression':
+      return NamedEvaluation_AsyncGeneratorExpression(F, name);
+    case 'ArrowFunction':
+      return NamedEvaluation_ArrowFunction(F, name);
+    case 'AsyncArrowFunction':
+      return NamedEvaluation_AsyncArrowFunction(F, name);
+    case 'ClassExpression':
+      return yield* NamedEvaluation_ClassExpression(F, name);
+    case 'ParenthesizedExpression':
+      return yield* NamedEvaluation(F.Expression, name);
+    default:
+      throw OutOfRange.exhaustive(F);
+  }
+}

package/src/runtime-semantics/NewExpression.mts

@@ -0,0 +1,51 @@
+import { Evaluate, type ValueEvaluator } from '../evaluator.mts';
+import { Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { isArray } from '../utils/language.mts';
+import { ArgumentListEvaluation } from './all.mts';
+import {
+  Assert,
+  Construct,
+  GetValue,
+  IsConstructor,
+  Throw,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-evaluatenew */
+function* EvaluateNew(constructExpr: ParseNode.LeftHandSideExpression, args: undefined | ParseNode.Arguments) {
+  // 1. Assert: constructExpr is either a NewExpression or a MemberExpression.
+  // 2. Assert: arguments is either empty or an Arguments.
+  Assert(args === undefined || isArray(args));
+  // 3. Let ref be the result of evaluating constructExpr.
+  const ref = Q(yield* Evaluate(constructExpr));
+  // 4. Let constructor be ? GetValue(ref).
+  const constructor = Q(yield* GetValue(ref));
+  let argList;
+  // 5. If arguments is empty, let argList be a new empty List.
+  if (args === undefined) {
+    argList = [];
+  } else { // 6. Else,
+    // a. Let argList be ? ArgumentListEvaluation of arguments.
+    argList = Q(yield* ArgumentListEvaluation(args));
+  }
+  // 7. If IsConstructor(constructor) is false, throw a TypeError exception.
+  if (!IsConstructor(constructor)) {
+    return Throw.TypeError('$1 is not a constructor', constructor);
+  }
+  // 8. Return ? Construct(constructor, argList).
+  return Q(yield* Construct(constructor, argList));
+}
+
+/** https://tc39.es/ecma262/#sec-new-operator-runtime-semantics-evaluation */
+//   NewExpression :
+//     `new` NewExpression
+//     `new` MemberExpression Arguments
+export function* Evaluate_NewExpression({ MemberExpression, Arguments }: ParseNode.NewExpression): ValueEvaluator {
+  if (!Arguments) {
+    // 1. Return ? EvaluateNew(NewExpression, empty).
+    return Q(yield* EvaluateNew(MemberExpression, undefined));
+  } else {
+    // 1. Return ? EvaluateNew(MemberExpression, Arguments).
+    return Q(yield* EvaluateNew(MemberExpression, Arguments));
+  }
+}

package/src/runtime-semantics/NewTarget.mts

@@ -0,0 +1,8 @@
+import { GetNewTarget } from '#self';
+
+/** https://tc39.es/ecma262/#sec-meta-properties-runtime-semantics-evaluation */
+// NewTarget : `new` `.` `target`
+export function Evaluate_NewTarget() {
+  // 1. Return GetNewTarget().
+  return GetNewTarget();
+}

package/src/runtime-semantics/NumberToBigInt.mts

@@ -0,0 +1,16 @@
+import { Value, NumberValue } from '../value.mts';
+import {
+  Assert, IsIntegralNumber, Z, R, Throw,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-numbertobigint */
+export function NumberToBigInt(number: NumberValue) {
+  // 1. Assert: Type(number) is Number.
+  Assert(number instanceof NumberValue);
+  // 2. If IsIntegralNumber(number) is false, throw a RangeError exception.
+  if (IsIntegralNumber(number) === Value.false) {
+    return Throw.RangeError('Cannot convert $1 to a BigInt', number);
+  }
+  // 3. Return the BigInt value that represents the mathematical value of number.
+  return Z(BigInt(R(number)));
+}

package/src/runtime-semantics/ObjectLiteral.mts

@@ -0,0 +1,25 @@
+import { Value } from '../value.mts';
+import { Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { ValueEvaluator } from '../evaluator.mts';
+import {
+  PropertyDefinitionEvaluation_PropertyDefinitionList,
+} from './all.mts';
+import { surroundingAgent, OrdinaryObjectCreate } from '#self';
+
+/** https://tc39.es/ecma262/#sec-object-initializer-runtime-semantics-evaluation */
+//   ObjectLiteral :
+//     `{` `}`
+//     `{` PropertyDefinitionList `}`
+//     `{` PropertyDefinitionList `,` `}`
+export function* Evaluate_ObjectLiteral({ PropertyDefinitionList }: ParseNode.ObjectLiteral): ValueEvaluator {
+  // 1. Let obj be OrdinaryObjectCreate(%Object.prototype%).
+  const obj = OrdinaryObjectCreate(surroundingAgent.intrinsic('%Object.prototype%'));
+  if (PropertyDefinitionList.length === 0) {
+    return obj;
+  }
+  // 2. Perform ? PropertyDefinitionEvaluation of PropertyDefinitionList with arguments obj and true.
+  Q(yield* PropertyDefinitionEvaluation_PropertyDefinitionList(PropertyDefinitionList, obj, Value.true));
+  // 3. Return obj.
+  return obj;
+}

package/src/runtime-semantics/OptionalExpression.mts

@@ -0,0 +1,129 @@
+import { ReferenceRecord, Value } from '../value.mts';
+import { Evaluate, type ExpressionEvaluator } from '../evaluator.mts';
+import { Q, X } from '../completion.mts';
+import { IsInTailPosition, StringValue } from '../static-semantics/all.mts';
+import { OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  EvaluateCall,
+  EvaluatePropertyAccessWithExpressionKey,
+  EvaluatePropertyAccessWithIdentifierKey,
+} from './all.mts';
+import { GetValue, MakePrivateReference } from '#self';
+
+/** https://tc39.es/ecma262/#sec-optional-chaining-evaluation */
+//   OptionalExpression :
+//     MemberExpression OptionalChain
+//     CallExpression OptionalChain
+//     OptionalExpression OptionalChain
+export function* Evaluate_OptionalExpression(node: ParseNode.OptionalExpression) {
+  const { MemberExpression, OptionalChain } = node;
+  // 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 baseValue is undefined or null, then
+  if (baseValue === Value.undefined || baseValue === Value.null) {
+    // a. Return undefined.
+    return Value.undefined;
+  }
+  // 4. Return the result of performing ChainEvaluation of OptionalChain with arguments baseValue and baseReference.
+  return yield* ChainEvaluation(OptionalChain, baseValue, X(baseReference), node);
+}
+
+/** https://tc39.es/ecma262/#sec-optional-chaining-chain-evaluation */
+//   OptionalChain :
+//     `?.` Arguments
+//     `?.` `[` Expression `]`
+//     `?.` IdentifierName
+//     `?.` PrivateIdentifier
+//     OptionalChain Arguments
+//     OptionalChain `[` Expression `]`
+//     OptionalChain `.` IdentifierName
+//     OptionalChain `.` PrivateIdentifier
+function* ChainEvaluation(node: ParseNode.OptionalChain, baseValue: Value, baseReference: Value | ReferenceRecord, topExpression?: ParseNode.OptionalExpression): ExpressionEvaluator {
+  const {
+    OptionalChain,
+    Arguments,
+    Expression,
+    IdentifierName,
+    PrivateIdentifier,
+  } = node;
+  if (Arguments) {
+    if (OptionalChain) {
+      // 1. Let optionalChain be OptionalChain.
+      const optionalChain = OptionalChain;
+      // 2. Let newReference be ? ChainEvaluation of optionalChain with arguments baseValue and baseReference.
+      const newReference = Q(yield* ChainEvaluation(optionalChain, baseValue, baseReference, topExpression));
+      // 3. Let newValue be ? GetValue(newReference).
+      const newValue = Q(yield* GetValue(newReference));
+      // 4. Let thisChain be this OptionalChain.
+      const thisChain = node;
+      // 5. Let tailCall be IsInTailPosition(thisChain).
+      const tailCall = IsInTailPosition(thisChain);
+      // 6. Return ? EvaluateCall(newValue, newReference, Arguments, tailCall).
+      return Q(yield* EvaluateCall(newValue, newReference, Arguments, tailCall, topExpression));
+    }
+    // 1. Let thisChain be this OptionalChain.
+    const thisChain = node;
+    // 2. Let tailCall be IsInTailPosition(thisChain).
+    const tailCall = IsInTailPosition(thisChain);
+    // 3. Return ? EvaluateCall(baseValue, baseReference, Arguments, tailCall).
+    return Q(yield* EvaluateCall(baseValue, baseReference, Arguments, tailCall, topExpression));
+  }
+  if (Expression) {
+    if (OptionalChain) {
+      // 1. Let optionalChain be OptionalChain.
+      const optionalChain = OptionalChain;
+      // 2. Let newReference be ? ChainEvaluation of optionalChain with arguments baseValue and baseReference.
+      const newReference = Q(yield* ChainEvaluation(optionalChain, baseValue, baseReference, topExpression));
+      // 3. Let newValue be ? GetValue(newReference).
+      const newValue = Q(yield* GetValue(newReference));
+      // 4. If the code matched by this OptionalChain is strict mode code, let strict be true; else let strict be false.
+      const strict = node.strict;
+      // 5. Return ? EvaluatePropertyAccessWithExpressionKey(newValue, Expression, strict).
+      return Q(yield* EvaluatePropertyAccessWithExpressionKey(newValue, Expression, strict));
+    }
+    // 1. If the code matched by this OptionalChain is strict mode code, let strict be true; else let strict be false.
+    const strict = node.strict;
+    // 2. Return ? EvaluatePropertyAccessWithExpressionKey(baseValue, Expression, strict).
+    return Q(yield* EvaluatePropertyAccessWithExpressionKey(baseValue, Expression, strict));
+  }
+  if (IdentifierName) {
+    if (OptionalChain) {
+      // 1. Let optionalChain be OptionalChain.
+      const optionalChain = OptionalChain;
+      // 2. Let newReference be ? ChainEvaluation of optionalChain with arguments baseValue and baseReference.
+      const newReference = Q(yield* ChainEvaluation(optionalChain, baseValue, baseReference, topExpression));
+      // 3. Let newValue be ? GetValue(newReference).
+      const newValue = Q(yield* GetValue(newReference));
+      // 4. If the code matched by this OptionalChain is strict mode code, let strict be true; else let strict be false.
+      const strict = node.strict;
+      // 5. Return ! EvaluatePropertyAccessWithIdentifierKey(newValue, IdentifierName, strict).
+      return X(EvaluatePropertyAccessWithIdentifierKey(newValue, IdentifierName, strict));
+    }
+    // 1. If the code matched by this OptionalChain is strict mode code, let strict be true; else let strict be false.
+    const strict = node.strict;
+    // 2. Return ! EvaluatePropertyAccessWithIdentifierKey(baseValue, IdentifierName, strict).
+    return X(EvaluatePropertyAccessWithIdentifierKey(baseValue, IdentifierName, strict));
+  }
+  if (PrivateIdentifier) {
+    if (OptionalChain) {
+      // 1. Let optionalChain be OptionalChain.
+      const optionalChain = OptionalChain;
+      // 2. Let newReference be ? ChainEvaluation of optionalChain with arguments baseValue and baseReference.
+      const newReference = Q(yield* ChainEvaluation(optionalChain, baseValue, baseReference, topExpression));
+      // 3. Let newValue be ? GetValue(newReference).
+      const newValue = Q(yield* GetValue(newReference));
+      // 4. Let fieldNameString be the StringValue of PrivateIdentifier.
+      const fieldNameString = StringValue(PrivateIdentifier);
+      // 5. Return ! MakePrivateReference(nv, fieldNameString).
+      return X(MakePrivateReference(newValue, fieldNameString));
+    }
+    // 1. Let fieldNameString be the StringValue of PrivateIdentifier.
+    const fieldNameString = StringValue(PrivateIdentifier);
+    // 2. Return ! MakePrivateReference(bv, fieldNameString).
+    return X(MakePrivateReference(baseValue, fieldNameString));
+  }
+  throw OutOfRange.nonExhaustive(node);
+}

package/src/runtime-semantics/ParenthesizedExpression.mts

@@ -0,0 +1,8 @@
+import { Evaluate } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-grouping-operator-runtime-semantics-evaluation */
+export function* Evaluate_ParenthesizedExpression({ Expression }: ParseNode.ParenthesizedExpression) {
+  // 1. Return the result of evaluating Expression. This may be of type Reference.
+  return yield* Evaluate(Expression);
+}

package/src/runtime-semantics/PropertyBindingInitialization.mts

@@ -0,0 +1,45 @@
+import { BoundNames } from '../static-semantics/all.mts';
+import { Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { isArray } from '../utils/language.mts';
+import type { PlainEvaluator } from '../evaluator.mts';
+import { Evaluate_PropertyName, KeyedBindingInitialization } from './all.mts';
+import type {
+  EnvironmentRecord, PlainCompletion, PropertyKeyValue, UndefinedValue, Value,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-destructuring-binding-patterns-runtime-semantics-propertybindinginitialization */
+// BindingPropertyList : BIndingPropertyList `,` BindingProperty
+// BindingProperty :
+//   SingleNameBinding
+//   PropertyName `:` BindingElement
+export function* PropertyBindingInitialization(node: ParseNode.BindingPropertyList | ParseNode.BindingPropertyLike, value: Value, environment: EnvironmentRecord | UndefinedValue): PlainEvaluator<PropertyKeyValue[]> {
+  if (isArray(node)) {
+    // 1. Let boundNames be ? PropertyBindingInitialization of BindingPropertyList with arguments value and environment.
+    // 2. Let nextNames be ? PropertyBindingInitialization of BindingProperty with arguments value and environment.
+    // 3. Append each item in nextNames to the end of boundNames.
+    // 4. Return boundNames.
+    const boundNames: PlainCompletion<PropertyKeyValue[]> = [];
+    for (const item of node) {
+      const nextNames = Q(yield* PropertyBindingInitialization(item, value, environment));
+      boundNames.push(...nextNames);
+    }
+    return boundNames;
+  }
+  if ('PropertyName' in node && node.PropertyName) {
+    // 1. Let P be the result of evaluating PropertyName.
+    const P = yield* Evaluate_PropertyName(node.PropertyName);
+    Q(P);
+    // 3. Perform ? KeyedBindingInitialization of BindingElement with value, environment, and P as the arguments.
+    Q(yield* KeyedBindingInitialization(node.BindingElement, value, environment, P as PropertyKeyValue));
+    // 4. Return a new List containing P.
+    return [P as PropertyKeyValue];
+  } else {
+    // 1. Let name be the string that is the only element of BoundNames of SingleNameBinding.
+    const name = BoundNames(node)[0];
+    // 2. Perform ? KeyedBindingInitialization for SingleNameBinding using value, environment, and name as the arguments.
+    Q(yield* KeyedBindingInitialization(node as ParseNode.SingleNameBinding, value, environment, name));
+    // 3. Return a new List containing name.
+    return [name];
+  }
+}

package/src/runtime-semantics/PropertyDefinitionEvaluation.mts

@@ -0,0 +1,132 @@
+import {
+  Value, NullValue, ObjectValue, type PropertyKeyValue, JSStringValue, BooleanValue,
+} from '../value.mts';
+import {
+  StringValue,
+  IsAnonymousFunctionDefinition,
+  IsComputedPropertyKey,
+  type FunctionDeclaration,
+} from '../static-semantics/all.mts';
+import { Evaluate, type PlainEvaluator, type ValueEvaluator } from '../evaluator.mts';
+import {
+  Q, X,
+  NormalCompletion,
+} from '../completion.mts';
+import { kInternal } from '../utils/internal.mts';
+import { OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { NamedEvaluation, MethodDefinitionEvaluation, Evaluate_PropertyName } from './all.mts';
+import {
+  surroundingAgent,
+  Assert,
+  GetValue,
+  CreateDataPropertyOrThrow,
+  CopyDataProperties,
+  DefineMethodProperty,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-object-initializer-runtime-semantics-propertydefinitionevaluation */
+//   PropertyDefinitionList :
+//     PropertyDefinitionList `,` PropertyDefinition
+export function* PropertyDefinitionEvaluation_PropertyDefinitionList(PropertyDefinitionList: ParseNode.PropertyDefinitionList, object: ObjectValue, enumerable: BooleanValue<true>): PlainEvaluator {
+  for (const PropertyDefinition of PropertyDefinitionList) {
+    Q(yield* PropertyDefinitionEvaluation_PropertyDefinition(PropertyDefinition, object, enumerable));
+  }
+}
+
+// PropertyDefinition :
+//   `...` AssignmentExpression
+//   IdentifierReference
+//   PropertyName `:` AssignmentExpression
+function* PropertyDefinitionEvaluation_PropertyDefinition(PropertyDefinition: ParseNode.PropertyDefinitionLike, object: ObjectValue, enumerable: BooleanValue<true>) {
+  switch (PropertyDefinition.type) {
+    case 'IdentifierReference':
+      return yield* PropertyDefinitionEvaluation_PropertyDefinition_IdentifierReference(PropertyDefinition, object, enumerable);
+    case 'PropertyDefinition':
+      break;
+    case 'MethodDefinition':
+    case 'GeneratorMethod':
+    case 'AsyncMethod':
+    case 'AsyncGeneratorMethod': {
+      if (surroundingAgent.feature('decorators')) {
+        const methodDefinition = Q(yield* MethodDefinitionEvaluation(PropertyDefinition, object));
+        Q(yield* DefineMethodProperty(object, methodDefinition, true));
+        return undefined;
+      } else {
+        const result = Q(yield* MethodDefinitionEvaluation(PropertyDefinition, object, enumerable));
+        Assert(result === undefined);
+        return undefined;
+      }
+    }
+    default:
+      throw OutOfRange.nonExhaustive(PropertyDefinition);
+  }
+  // PropertyDefinition :
+  //   PropertyName `:` AssignmentExpression
+  //   `...` AssignmentExpression
+  const { PropertyName, AssignmentExpression } = PropertyDefinition;
+  if (!PropertyName) {
+    // 1. Let exprValue be the result of evaluating AssignmentExpression.
+    const exprValue = Q(yield* Evaluate(AssignmentExpression));
+    // 2. Let fromValue be ? GetValue(exprValue).
+    const fromValue = Q(yield* GetValue(exprValue));
+    // 3. Let excludedNames be a new empty List.
+    const excludedNames: PropertyKeyValue[] = [];
+    // 4. Return ? CopyDataProperties(object, fromValue, excludedNames).
+    return Q(yield* CopyDataProperties(object, fromValue, excludedNames));
+  }
+  // 1. Let propKey be the result of evaluating PropertyName.
+  const propKey = Q(yield* Evaluate_PropertyName(PropertyName));
+  // 3. If this PropertyDefinition is contained within a Script which is being evaluated for JSON.parse, then
+  let isProtoSetter;
+  if (surroundingAgent.runningExecutionContext?.HostDefined?.[kInternal]?.json) {
+    isProtoSetter = false;
+  } else if (!IsComputedPropertyKey(PropertyName) && (propKey as JSStringValue).stringValue() === '__proto__') { // 3. Else, If _propKey_ is the String value *"__proto__"* and if IsComputedPropertyKey(|PropertyName|) is *false*,
+    // a. Let isProtoSetter be true.
+    isProtoSetter = true;
+  } else { // 4. Else,
+    // a. Let isProtoSetter be false.
+    isProtoSetter = false;
+  }
+  let propValue;
+  // 5. If IsAnonymousFunctionDefinition(AssignmentExpression) is true and isProtoSetter is false, then
+  if (IsAnonymousFunctionDefinition(AssignmentExpression) && !isProtoSetter) {
+    // a. Let propValue be NamedEvaluation of AssignmentExpression with argument propKey.
+    propValue = yield* NamedEvaluation(AssignmentExpression as FunctionDeclaration, propKey);
+  } else { // 6. Else,
+    // a. Let exprValueRef be the result of evaluating AssignmentExpression.
+    const exprValueRef = Q(yield* Evaluate(AssignmentExpression));
+    // b. Let propValue be ? GetValue(exprValueRef).
+    propValue = Q(yield* GetValue(exprValueRef));
+  }
+  // 7. If isProtoSetter is true, then
+  if (isProtoSetter) {
+    // a. If Type(propValue) is either Object or Null, then
+    if (propValue instanceof ObjectValue || propValue instanceof NullValue) {
+      // i. Return object.[[SetPrototypeOf]](propValue).
+      return yield* object.SetPrototypeOf(propValue);
+    }
+    // b. Return NormalCompletion(empty).
+    return NormalCompletion(undefined);
+  }
+  // 8. Assert: enumerable is true.
+  Assert(enumerable === Value.true);
+  // 9. Assert: object is an ordinary, extensible object with no non-configurable properties.
+  // 10. Return ! CreateDataPropertyOrThrow(object, propKey, propValue).
+  return X(CreateDataPropertyOrThrow(object, propKey as PropertyKeyValue, X(propValue)));
+}
+
+// PropertyDefinition : IdentifierReference
+function* PropertyDefinitionEvaluation_PropertyDefinition_IdentifierReference(IdentifierReference: ParseNode.IdentifierReference, object: ObjectValue, enumerable: BooleanValue<true>): ValueEvaluator {
+  // 1. Let propName be StringValue of IdentifierReference.
+  const propName = StringValue(IdentifierReference);
+  // 2. Let exprValue be the result of evaluating IdentifierReference.
+  const exprValue = Q(yield* Evaluate(IdentifierReference));
+  // 3. Let propValue be ? GetValue(exprValue).
+  const propValue = Q(yield* GetValue(exprValue));
+  // 4. Assert: enumerable is true.
+  Assert(enumerable === Value.true);
+  // 5. Assert: object is an ordinary, extensible object with no non-configurable properties.
+  // 6. Return ! CreateDataPropertyOrThrow(object, propName, propValue).
+  return X(CreateDataPropertyOrThrow(object, propName, propValue));
+}

package/src/runtime-semantics/PropertyName.mts

@@ -0,0 +1,62 @@
+import { Value } from '../value.mts';
+import { Evaluate } from '../evaluator.mts';
+import { StringValue, NumericValue } from '../static-semantics/all.mts';
+import { Q, X } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  surroundingAgent,
+  Assert,
+  ToString,
+  GetValue,
+  ToPropertyKey,
+} from '#self';
+import type {
+  PlainEvaluator, PrivateEnvironmentRecord, PrivateName, PropertyKeyValue,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-object-initializer-runtime-semantics-evaluation */
+// PropertyName :
+//   LiteralPropertyName
+//   ComputedPropertyName
+// LiteralPropertyName :
+//   IdentifierName
+//   StringLiteral
+//   NumericLiteral
+// ComputedPropertyName :
+//   `[` AssignmentExpression `]`
+export function* Evaluate_PropertyName(PropertyName: ParseNode.PropertyNameLike | ParseNode.PrivateIdentifier): PlainEvaluator<PropertyKeyValue | PrivateName> {
+  switch (PropertyName.type) {
+    case 'IdentifierName':
+      return StringValue(PropertyName);
+    case 'StringLiteral':
+      return Value(PropertyName.value);
+    case 'NumericLiteral': {
+      // 1. Let nbr be the NumericValue of NumericLiteral.
+      const nbr = NumericValue(PropertyName);
+      // 2. Return ! ToString(nbr).
+      return X(ToString(nbr));
+    }
+    case 'PrivateIdentifier': {
+      // 1. Let privateIdentifier be StringValue of PrivateIdentifier.
+      const privateIdentifier = StringValue(PropertyName);
+      // 2. Let privateEnvRec be the running execution context's PrivateEnvironment.
+      const privateEnvRec = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+      // 3. Let names be privateEnvRec.[[Names]].
+      const names = (privateEnvRec as PrivateEnvironmentRecord).Names;
+      // 4. Assert: Exactly one element of names is a Private Name whose [[Description]] is privateIdentifier.
+      // 5. Let privateName be the Private Name in names whose [[Description]] is privateIdentifier.
+      const privateName = names.find((n) => n.Description.stringValue() === privateIdentifier.stringValue());
+      Assert(!!privateName);
+      // 6. Return privateName.
+      return privateName;
+    }
+    default: {
+      // 1. Let exprValue be the result of evaluating AssignmentExpression.
+      const exprValue = Q(yield* Evaluate(PropertyName.ComputedPropertyName));
+      // 2. Let propName be ? GetValue(exprValue).
+      const propName = Q(yield* GetValue(exprValue));
+      // 3. Return ? ToPropertyKey(propName).
+      return Q(yield* ToPropertyKey(propName));
+    }
+  }
+}