@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/src/runtime-semantics/NamedEvaluation.mts

@@ -0,0 +1,98 @@
+import { Value } from '../value.mts';
+import { sourceTextMatchedBy } from '../abstract-ops/all.mts';
+import { ReturnIfAbrupt } from '../completion.mts';
+import { OutOfRange, type Mutable } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { ExpressionEvaluator } from '../evaluator.mts';
+import {
+  ClassDefinitionEvaluation,
+  InstantiateOrdinaryFunctionExpression,
+  InstantiateAsyncFunctionExpression,
+  InstantiateGeneratorFunctionExpression,
+  InstantiateAsyncGeneratorFunctionExpression,
+  InstantiateArrowFunctionExpression,
+  InstantiateAsyncArrowFunctionExpression,
+} from './all.mts';
+import type {
+  ECMAScriptFunctionObject, FunctionDeclaration, 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 } = ClassExpression;
+  // 1. Let value be the result of ClassDefinitionEvaluation of ClassTail with arguments undefined and name.
+  const value = yield* ClassDefinitionEvaluation(ClassTail, Value.undefined, name);
+  // 2. ReturnIfAbrupt(value).
+  ReturnIfAbrupt(value);
+  // 3. Set value.[[SourceText]] to the source text matched by ClassExpression.
+  (value as Mutable<ECMAScriptFunctionObject>).SourceText = sourceTextMatchedBy(ClassExpression);
+  // 4. Return value.
+  return value;
+}
+
+export function* NamedEvaluation(F: FunctionDeclaration, name: PropertyKeyValue | PrivateName): ExpressionEvaluator<ECMAScriptFunctionObject> {
+  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 new OutOfRange('NamedEvaluation', F);
+  }
+}

package/src/runtime-semantics/NewExpression.mts

@@ -0,0 +1,52 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Assert,
+  Construct,
+  GetValue,
+  IsConstructor,
+  type FunctionObject,
+} from '../abstract-ops/all.mts';
+import { Value } from '../value.mts';
+import { Evaluate, type ExpressionEvaluator } from '../evaluator.mts';
+import { Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { ArgumentListEvaluation } from './all.mts';
+
+/** 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 || Array.isArray(args));
+  // 3. Let ref be the result of evaluating constructExpr.
+  const ref = yield* Evaluate(constructExpr);
+  // 4. Let constructor be ? GetValue(ref).
+  const constructor = Q(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) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'NotAConstructor', constructor);
+  }
+  // 8. Return ? Construct(constructor, argList).
+  return Q(Construct(constructor as FunctionObject, 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): ExpressionEvaluator {
+  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 '../abstract-ops/all.mts';
+
+/** 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,17 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Assert, IsIntegralNumber, Z, R,
+} from '../abstract-ops/all.mts';
+import { Value, NumberValue } from '../value.mts';
+
+/** 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 surroundingAgent.Throw('RangeError', 'CannotConvertDecimalToBigInt', 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,26 @@
+import { surroundingAgent } from '../engine.mts';
+import { Value } from '../value.mts';
+import { OrdinaryObjectCreate } from '../abstract-ops/all.mts';
+import { Q } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { ExpressionEvaluator } from '../evaluator.mts';
+import {
+  PropertyDefinitionEvaluation_PropertyDefinitionList,
+} from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-object-initializer-runtime-semantics-evaluation */
+//   ObjectLiteral :
+//     `{` `}`
+//     `{` PropertyDefinitionList `}`
+//     `{` PropertyDefinitionList `,` `}`
+export function* Evaluate_ObjectLiteral({ PropertyDefinitionList }: ParseNode.ObjectLiteral): ExpressionEvaluator {
+  // 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,132 @@
+import { ReferenceRecord, Value } from '../value.mts';
+import { GetValue, MakePrivateReference, RequireObjectCoercible } from '../abstract-ops/all.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 '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  EvaluateCall,
+  EvaluatePropertyAccessWithExpressionKey,
+  EvaluatePropertyAccessWithIdentifierKey,
+} from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-optional-chaining-evaluation */
+//   OptionalExpression :
+//     MemberExpression OptionalChain
+//     CallExpression OptionalChain
+//     OptionalExpression OptionalChain
+export function* Evaluate_OptionalExpression({ MemberExpression, OptionalChain }: ParseNode.OptionalExpression) {
+  // 1. Let baseReference be the result of evaluating MemberExpression.
+  const baseReference = yield* Evaluate(MemberExpression);
+  // 2. Let baseValue be ? GetValue(baseReference).
+  const baseValue = Q(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));
+}
+
+/** 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): 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));
+      // 3. Let newValue be ? GetValue(newReference).
+      const newValue = Q(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));
+    }
+    // 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));
+  }
+  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));
+      // 3. Let newValue be ? GetValue(newReference).
+      const newValue = Q(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));
+      // 3. Let newValue be ? GetValue(newReference).
+      const newValue = Q(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 Q(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 Q(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));
+      // 3. Let newValue be ? GetValue(newReference).
+      const newValue = Q(GetValue(newReference));
+      // 4. Let nv be ? RequireObjectCoercible(newValue).
+      const nv = Q(RequireObjectCoercible(newValue));
+      // 5. Let fieldNameString be the StringValue of PrivateIdentifier.
+      const fieldNameString = StringValue(PrivateIdentifier);
+      // 6. Return ! MakePrivateReference(nv, fieldNameString).
+      return X(MakePrivateReference(nv, fieldNameString));
+    }
+    // 1. Let bv be ? RequireObjectCoercible(baseValue).
+    const bv = Q(RequireObjectCoercible(baseValue));
+    // 2. Let fieldNameString be the StringValue of PrivateIdentifier.
+    const fieldNameString = StringValue(PrivateIdentifier);
+    // 3. Return ! MakePrivateReference(bv, fieldNameString).
+    return X(MakePrivateReference(bv, fieldNameString));
+  }
+  throw new OutOfRange('ChainEvaluation', 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,46 @@
+import { BoundNames } from '../static-semantics/all.mts';
+import { Q, ReturnIfAbrupt } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { isArray } from '../helpers.mts';
+import type { Evaluator } 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): Evaluator<PlainCompletion<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);
+    // 2. ReturnIfAbrupt(P).
+    ReturnIfAbrupt(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,124 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Value, NullValue, ObjectValue, type PropertyKeyValue, JSStringValue, BooleanValue,
+} from '../value.mts';
+import {
+  Assert,
+  GetValue,
+  CreateDataPropertyOrThrow,
+  CopyDataProperties,
+} from '../abstract-ops/all.mts';
+import {
+  StringValue,
+  IsAnonymousFunctionDefinition,
+  IsComputedPropertyKey,
+  type FunctionDeclaration,
+} from '../static-semantics/all.mts';
+import { Evaluate, type Evaluator, type ExpressionEvaluator } from '../evaluator.mts';
+import {
+  Q, X,
+  ReturnIfAbrupt,
+  NormalCompletion,
+  type PlainCompletion,
+} from '../completion.mts';
+import { OutOfRange, kInternal } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { NamedEvaluation, MethodDefinitionEvaluation, Evaluate_PropertyName } from './all.mts';
+
+/** 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>): Evaluator<PlainCompletion<void>> {
+  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':
+      return yield* MethodDefinitionEvaluation(PropertyDefinition, object, enumerable);
+    default:
+      throw new OutOfRange('PropertyDefinitionEvaluation_PropertyDefinition', PropertyDefinition);
+  }
+  // PropertyDefinition :
+  //   PropertyName `:` AssignmentExpression
+  //   `...` AssignmentExpression
+  const { PropertyName, AssignmentExpression } = PropertyDefinition;
+  if (!PropertyName) {
+    // 1. Let exprValue be the result of evaluating AssignmentExpression.
+    const exprValue = yield* Evaluate(AssignmentExpression);
+    // 2. Let fromValue be ? GetValue(exprValue).
+    const fromValue = Q(GetValue(exprValue));
+    // 3. Let excludedNames be a new empty List.
+    const excludedNames: PropertyKeyValue[] = [];
+    // 4. Return ? CopyDataProperties(object, fromValue, excludedNames).
+    return Q(CopyDataProperties(object, fromValue, excludedNames));
+  }
+  // 1. Let propKey be the result of evaluating PropertyName.
+  const propKey = ReturnIfAbrupt(yield* Evaluate_PropertyName(PropertyName));
+  // 2. ReturnIfAbrupt(propKey).
+  // 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 = yield* Evaluate(AssignmentExpression);
+    // b. Let propValue be ? GetValue(exprValueRef).
+    propValue = Q(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 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>): ExpressionEvaluator {
+  // 1. Let propName be StringValue of IdentifierReference.
+  const propName = StringValue(IdentifierReference);
+  // 2. Let exprValue be the result of evaluating IdentifierReference.
+  const exprValue = yield* Evaluate(IdentifierReference);
+  // 3. Let propValue be ? GetValue(exprValue).
+  const propValue = Q(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 { surroundingAgent } from '../engine.mts';
+import { Value } from '../value.mts';
+import { Evaluate, type Evaluator } from '../evaluator.mts';
+import { StringValue, NumericValue } from '../static-semantics/all.mts';
+import {
+  Assert,
+  ToString,
+  GetValue,
+  ToPropertyKey,
+} from '../abstract-ops/all.mts';
+import { Q, X } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type {
+  PlainCompletion, 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): Evaluator<PlainCompletion<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 = yield* Evaluate(PropertyName.ComputedPropertyName);
+      // 2. Let propName be ? GetValue(exprValue).
+      const propName = Q(GetValue(exprValue));
+      // 3. Return ? ToPropertyKey(propName).
+      return Q(ToPropertyKey(propName));
+    }
+  }
+}