@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/abstract-ops/objects.mts

@@ -0,0 +1,453 @@
+import {
+  Descriptor,
+  ObjectValue,
+  SymbolValue, JSStringValue, UndefinedValue, NullValue,
+  Value,
+  BooleanValue,
+  type PropertyKeyValue,
+  type DescriptorInit,
+  type CanBeNativeSteps,
+} from '../value.mts';
+import {
+  Q, X,
+} from '../completion.mts';
+import type { Mutable } from '../utils/language.mts';
+import type { ValueEvaluator } from '../evaluator.mts';
+import {
+  Assert,
+  Call,
+  CreateDataProperty,
+  Get,
+  GetFunctionRealm,
+  IsAccessorDescriptor,
+  IsCallable,
+  IsDataDescriptor,
+  IsExtensible,
+  IsGenericDescriptor,
+  IsPropertyKey,
+  SameValue,
+  MakeBasicObject,
+  isArrayIndex,
+  type FunctionObject,
+  type Intrinsics,
+} from './all.mts';
+import { CreateBuiltinFunction, surroundingAgent } from '#self';
+
+export interface OrdinaryObject extends ObjectValue {
+  Prototype: ObjectValue | NullValue;
+  Extensible: BooleanValue;
+}
+
+export function isOrdinaryObject(value: Value): value is OrdinaryObject {
+  return value instanceof ObjectValue
+    && value.GetPrototypeOf === ObjectValue.prototype.GetPrototypeOf
+    && value.SetPrototypeOf === ObjectValue.prototype.SetPrototypeOf
+    && value.IsExtensible === ObjectValue.prototype.IsExtensible
+    && value.PreventExtensions === ObjectValue.prototype.PreventExtensions
+    && value.GetOwnProperty === ObjectValue.prototype.GetOwnProperty
+    && value.DefineOwnProperty === ObjectValue.prototype.DefineOwnProperty
+    && value.HasProperty === ObjectValue.prototype.HasProperty
+    && value.Get === ObjectValue.prototype.Get
+    && value.Set === ObjectValue.prototype.Set
+    && value.Delete === ObjectValue.prototype.Delete
+    && value.OwnPropertyKeys === ObjectValue.prototype.OwnPropertyKeys
+    && 'Prototype' in value
+    && 'Extensible' in value;
+}
+
+// TODO: ban other direct extension from ObjectValue in the linter
+export type ExoticObject = ObjectValue;
+// 9.1.1.1 OrdinaryGetPrototypeOf
+export function OrdinaryGetPrototypeOf(O: OrdinaryObject) {
+  return O.Prototype;
+}
+
+// 9.1.2.1 OrdinarySetPrototypeOf
+export function OrdinarySetPrototypeOf(O: OrdinaryObject, V: ObjectValue | NullValue) {
+  Assert(V instanceof ObjectValue || V instanceof NullValue);
+
+  const current = O.Prototype;
+  if (SameValue(V, current)) {
+    return Value.true;
+  }
+  const extensible = O.Extensible;
+  if (extensible === Value.false) {
+    return Value.false;
+  }
+  let p = V;
+  let done = false;
+  while (done === false) {
+    if (p instanceof NullValue) {
+      done = true;
+    } else if (SameValue(p, O)) {
+      return Value.false;
+    } else if (p.GetPrototypeOf !== ObjectValue.prototype.GetPrototypeOf) {
+      done = true;
+    } else {
+      p = (p as OrdinaryObject).Prototype;
+    }
+  }
+  O.Prototype = V;
+  return Value.true;
+}
+
+// 9.1.3.1 OrdinaryIsExtensible
+export function OrdinaryIsExtensible(O: OrdinaryObject) {
+  return O.Extensible;
+}
+
+// 9.1.4.1 OrdinaryPreventExtensions
+export function OrdinaryPreventExtensions(O: OrdinaryObject) {
+  O.Extensible = Value.false;
+  return Value.true;
+}
+
+// 9.1.5.1 OrdinaryGetOwnProperty
+export function OrdinaryGetOwnProperty(O: ObjectValue, P: PropertyKeyValue) {
+  Assert(IsPropertyKey(P));
+
+  if (!O.properties.has(P)) {
+    return Value.undefined;
+  }
+
+  const D: Mutable<DescriptorInit> = {};
+
+  const x = O.properties.get(P)!;
+
+  if (IsDataDescriptor(x)) {
+    D.Value = x.Value;
+    D.Writable = x.Writable;
+  } else if (IsAccessorDescriptor(x)) {
+    D.Getter = x.Getter;
+    D.Setter = x.Setter;
+  }
+  D.Enumerable = x.Enumerable;
+  D.Configurable = x.Configurable;
+
+  return Descriptor(D);
+}
+
+// 9.1.6.1 OrdinaryDefineOwnProperty
+export function* OrdinaryDefineOwnProperty(O: ObjectValue, P: PropertyKeyValue, Desc: Descriptor): ValueEvaluator<BooleanValue> {
+  const current = Q(yield* O.GetOwnProperty(P));
+  const extensible = Q(yield* IsExtensible(O));
+  return ValidateAndApplyPropertyDescriptor(O, P, extensible, Desc, current);
+}
+
+/** https://tc39.es/ecma262/#sec-iscompatiblepropertydescriptor */
+export function IsCompatiblePropertyDescriptor(Extensible: BooleanValue, Desc: Descriptor, Current: UndefinedValue | Descriptor) {
+  return ValidateAndApplyPropertyDescriptor(Value.undefined, Value.undefined, Extensible, Desc, Current);
+}
+
+// 9.1.6.3 ValidateAndApplyPropertyDescriptor
+export function ValidateAndApplyPropertyDescriptor(O: ObjectValue | UndefinedValue, P: PropertyKeyValue | UndefinedValue, extensible: BooleanValue, Desc: Descriptor, current: UndefinedValue | Descriptor) {
+  Assert(O === Value.undefined || IsPropertyKey(P));
+
+  if (current instanceof UndefinedValue) {
+    if (extensible === Value.false) {
+      return Value.false;
+    }
+
+    Assert(extensible === Value.true);
+
+    if (IsGenericDescriptor(Desc) || IsDataDescriptor(Desc)) {
+      if (!(O instanceof UndefinedValue)) {
+        O.properties.set(P as PropertyKeyValue, Descriptor({
+          Value: Desc.Value === undefined ? Value.undefined : Desc.Value,
+          Writable: Desc.Writable === undefined ? Value.false : Desc.Writable,
+          Enumerable: Desc.Enumerable === undefined ? Value.false : Desc.Enumerable,
+          Configurable: Desc.Configurable === undefined ? Value.false : Desc.Configurable,
+        }));
+      }
+    } else {
+      Assert(IsAccessorDescriptor(Desc));
+      if (!(O instanceof UndefinedValue)) {
+        O.properties.set(P as PropertyKeyValue, Descriptor({
+          Getter: Desc.Getter === undefined ? Value.undefined : Desc.Getter,
+          Setter: Desc.Setter === undefined ? Value.undefined : Desc.Setter,
+          Enumerable: Desc.Enumerable === undefined ? Value.false : Desc.Enumerable,
+          Configurable: Desc.Configurable === undefined ? Value.false : Desc.Configurable,
+        }));
+      }
+    }
+
+    return Value.true;
+  }
+
+  if (Desc.everyFieldIsAbsent()) {
+    return Value.true;
+  }
+
+  if ((current as Descriptor).Configurable === Value.false) {
+    if (Desc.Configurable !== undefined && Desc.Configurable === Value.true) {
+      return Value.false;
+    }
+
+    if (Desc.Enumerable !== undefined && Desc.Enumerable !== (current as Descriptor).Enumerable) {
+      return Value.false;
+    }
+  }
+
+  if (IsGenericDescriptor(Desc)) {
+    // No further validation is required.
+  } else if (IsDataDescriptor(current) !== IsDataDescriptor(Desc)) {
+    if ((current as Descriptor).Configurable === Value.false) {
+      return Value.false;
+    }
+    if (IsDataDescriptor(current)) {
+      if (!(O instanceof UndefinedValue)) {
+        const entry = { ...O.properties.get(P as PropertyKeyValue)! };
+        entry.Value = undefined;
+        entry.Writable = undefined;
+        entry.Getter = Value.undefined;
+        entry.Setter = Value.undefined;
+        O.properties.set(P as PropertyKeyValue, Descriptor(entry));
+      }
+    } else {
+      if (!(O instanceof UndefinedValue)) {
+        const entry = { ...O.properties.get(P as PropertyKeyValue) };
+        entry.Getter = undefined;
+        entry.Setter = undefined;
+        entry.Value = Value.undefined;
+        entry.Writable = Value.false;
+        O.properties.set(P as PropertyKeyValue, Descriptor(entry));
+      }
+    }
+  } else if (IsDataDescriptor(current) && IsDataDescriptor(Desc)) {
+    if (current.Configurable === Value.false && current.Writable === Value.false) {
+      if (Desc.Writable !== undefined && Desc.Writable === Value.true) {
+        return Value.false;
+      }
+      if (Desc.Value !== undefined && !SameValue(Desc.Value, current.Value)) {
+        return Value.false;
+      }
+      return Value.true;
+    }
+  } else {
+    Assert(IsAccessorDescriptor(current) && IsAccessorDescriptor(Desc));
+    if (current.Configurable === Value.false) {
+      if (Desc.Setter !== undefined && !SameValue(Desc.Setter, current.Setter)) {
+        return Value.false;
+      }
+      if (Desc.Getter !== undefined && !SameValue(Desc.Getter, current.Getter)) {
+        return Value.false;
+      }
+      return Value.true;
+    }
+  }
+
+  if (!(O instanceof UndefinedValue)) {
+    const target = { ...O.properties.get(P as PropertyKeyValue) };
+    if (Desc.Value !== undefined) {
+      target.Value = Desc.Value;
+    }
+    if (Desc.Writable !== undefined) {
+      target.Writable = Desc.Writable;
+    }
+    if (Desc.Getter !== undefined) {
+      target.Getter = Desc.Getter;
+    }
+    if (Desc.Setter !== undefined) {
+      target.Setter = Desc.Setter;
+    }
+    if (Desc.Enumerable !== undefined) {
+      target.Enumerable = Desc.Enumerable;
+    }
+    if (Desc.Configurable !== undefined) {
+      target.Configurable = Desc.Configurable;
+    }
+    O.properties.set(P as PropertyKeyValue, Descriptor(target));
+  }
+
+  return Value.true;
+}
+
+// 9.1.7.1 OrdinaryHasProperty
+export function* OrdinaryHasProperty(O: ObjectValue, P: PropertyKeyValue): ValueEvaluator<BooleanValue> {
+  Assert(IsPropertyKey(P));
+
+  const hasOwn = Q(yield* O.GetOwnProperty(P));
+  if (!(hasOwn instanceof UndefinedValue)) {
+    return Value.true;
+  }
+  const parent = Q(yield* O.GetPrototypeOf());
+  if (!(parent instanceof NullValue)) {
+    return Q(yield* parent.HasProperty(P));
+  }
+  return Value.false;
+}
+
+// 9.1.8.1
+export function* OrdinaryGet(O: ObjectValue, P: PropertyKeyValue, Receiver: Value): ValueEvaluator {
+  Assert(IsPropertyKey(P));
+
+  const desc = Q(yield* O.GetOwnProperty(P));
+  if (desc instanceof UndefinedValue) {
+    const parent = Q(yield* O.GetPrototypeOf());
+    if (parent instanceof NullValue) {
+      return Value.undefined;
+    }
+    return Q(yield* parent.Get(P, Receiver));
+  }
+  if (IsDataDescriptor(desc)) {
+    return desc.Value;
+  }
+  Assert(IsAccessorDescriptor(desc));
+  const getter = desc.Getter;
+  if (getter instanceof UndefinedValue) {
+    return Value.undefined;
+  }
+  return Q(yield* Call(getter, Receiver));
+}
+
+// 9.1.9.1 OrdinarySet
+export function* OrdinarySet(O: ObjectValue, P: PropertyKeyValue, V: Value, Receiver: Value) {
+  Assert(IsPropertyKey(P));
+  const ownDesc = Q(yield* O.GetOwnProperty(P));
+  return yield* OrdinarySetWithOwnDescriptor(O, P, V, Receiver, ownDesc);
+}
+
+// 9.1.9.2 OrdinarySetWithOwnDescriptor
+export function* OrdinarySetWithOwnDescriptor(O: ObjectValue, P: PropertyKeyValue, V: Value, Receiver: Value, ownDesc: Descriptor | UndefinedValue): ValueEvaluator<BooleanValue> {
+  Assert(IsPropertyKey(P));
+
+  if (ownDesc instanceof UndefinedValue) {
+    const parent = Q(yield* O.GetPrototypeOf());
+    if (!(parent instanceof NullValue)) {
+      return Q(yield* parent.Set(P, V, Receiver));
+    }
+    ownDesc = Descriptor({
+      Value: Value.undefined,
+      Writable: Value.true,
+      Enumerable: Value.true,
+      Configurable: Value.true,
+    });
+  }
+
+  if (IsDataDescriptor(ownDesc)) {
+    if (ownDesc.Writable !== undefined && ownDesc.Writable === Value.false) {
+      return Value.false;
+    }
+    if (!(Receiver instanceof ObjectValue)) {
+      return Value.false;
+    }
+
+    const existingDescriptor = Q(yield* Receiver.GetOwnProperty(P));
+    if (!(existingDescriptor instanceof UndefinedValue)) {
+      if (IsAccessorDescriptor(existingDescriptor)) {
+        return Value.false;
+      }
+      if (existingDescriptor.Writable === Value.false) {
+        return Value.false;
+      }
+      const valueDesc = Descriptor({ Value: V });
+      return Q(yield* Receiver.DefineOwnProperty(P, valueDesc));
+    }
+    return yield* CreateDataProperty(Receiver, P, V);
+  }
+
+  Assert(IsAccessorDescriptor(ownDesc));
+  const setter = ownDesc.Setter;
+  if (setter === undefined || setter instanceof UndefinedValue) {
+    return Value.false;
+  }
+  Q(yield* Call(setter, Receiver, [V]));
+  return Value.true;
+}
+
+// 9.1.10.1 OrdinaryDelete
+export function* OrdinaryDelete(O: ObjectValue, P: PropertyKeyValue): ValueEvaluator<BooleanValue> {
+  Assert(IsPropertyKey(P));
+  const desc = Q(yield* O.GetOwnProperty(P));
+  if (desc instanceof UndefinedValue) {
+    return Value.true;
+  }
+  if (desc.Configurable === Value.true) {
+    O.properties.delete(P);
+    return Value.true;
+  }
+  return Value.false;
+}
+
+// 9.1.11.1
+export function OrdinaryOwnPropertyKeys(O: ObjectValue) {
+  const keys: PropertyKeyValue[] = [];
+
+  // For each own property key P of O that is an array index, in ascending numeric index order, do
+  //   Add P as the last element of keys.
+  for (const P of O.properties.keys()) {
+    if (isArrayIndex(P)) {
+      keys.push(P);
+    }
+  }
+  keys.sort((a, b) => Number.parseInt((a as JSStringValue).stringValue(), 10) - Number.parseInt((b as JSStringValue).stringValue(), 10));
+
+  // For each own property key P of O such that Type(P) is String and
+  // P is not an array index, in ascending chronological order of property creation, do
+  //   Add P as the last element of keys.
+  for (const P of O.properties.keys()) {
+    if (P instanceof JSStringValue && isArrayIndex(P) === false) {
+      keys.push(P);
+    }
+  }
+
+  // For each own property key P of O such that Type(P) is Symbol,
+  // in ascending chronological order of property creation, do
+  //   Add P as the last element of keys.
+  for (const P of O.properties.keys()) {
+    if (P instanceof SymbolValue) {
+      keys.push(P);
+    }
+  }
+
+  return keys;
+}
+
+/** https://tc39.es/ecma262/#sec-ordinaryobjectcreate */
+export function OrdinaryObjectCreate<const T extends string>(proto: ObjectValue | NullValue, additionalInternalSlotsList?: readonly T[]) {
+  Assert(!!proto);
+  // 1. Let internalSlotsList be « [[Prototype]], [[Extensible]] ».
+  const internalSlotsList: ['Prototype', 'Extensible', ...T[]] = ['Prototype', 'Extensible'];
+  // 2. If additionalInternalSlotsList is present, append each of its elements to internalSlotsList.
+  if (additionalInternalSlotsList !== undefined) {
+    internalSlotsList.push(...additionalInternalSlotsList);
+  }
+  // 3. Let O be ! MakeBasicObject(internalSlotsList).
+  const O = X(MakeBasicObject(internalSlotsList)) as OrdinaryObject;
+  // 4. Set O.[[Prototype]] to proto.
+  O.Prototype = proto;
+  // 5. Return O.
+  return O;
+}
+
+/** This is a helper function to define non-spec host objects. */
+OrdinaryObjectCreate.from = (object: Record<string, Value | CanBeNativeSteps>, proto?: ObjectValue | NullValue) => {
+  const O = OrdinaryObjectCreate(proto || surroundingAgent.intrinsic('%Object.prototype%'));
+  for (const key in object) {
+    if (Object.hasOwn(object, key)) {
+      const value = object[key];
+      X(CreateDataProperty(O, Value(key), value instanceof Value ? value : CreateBuiltinFunction.from(value, key)));
+    }
+  }
+  return O;
+};
+
+// 9.1.13 OrdinaryCreateFromConstructor
+export function* OrdinaryCreateFromConstructor<const T extends string>(constructor: FunctionObject, intrinsicDefaultProto: keyof Intrinsics, internalSlotsList?: readonly T[]): ValueEvaluator<ObjectValue> {
+  // Assert: intrinsicDefaultProto is a String value that is this specification's name of an intrinsic object.
+  const proto = Q(yield* GetPrototypeFromConstructor(constructor, intrinsicDefaultProto));
+  return OrdinaryObjectCreate(proto, internalSlotsList);
+}
+
+// 9.1.14 GetPrototypeFromConstructor
+export function* GetPrototypeFromConstructor(constructor: FunctionObject, intrinsicDefaultProto: keyof Intrinsics): ValueEvaluator<ObjectValue> {
+  // Assert: intrinsicDefaultProto is a String value that
+  // is this specification's name of an intrinsic object.
+  Assert(IsCallable(constructor));
+  let proto = Q(yield* Get(constructor, Value('prototype')));
+  if (!(proto instanceof ObjectValue)) {
+    const realm = Q(GetFunctionRealm(constructor));
+    proto = realm.Intrinsics[intrinsicDefaultProto];
+  }
+  return proto;
+}

package/src/abstract-ops/private-names.mts

@@ -0,0 +1,170 @@
+import { ObjectValue, PrivateName, Value } from '../value.mts';
+import { Q, X } from '../completion.mts';
+import { ClassElementDefinitionRecord, PrivateElementRecord } from '../runtime-semantics/all.mts';
+import {
+  Assert, Call, IsExtensible,
+} from './all.mts';
+import { Throw, type PlainEvaluator } from '#self';
+
+/** https://tc39.es/ecma262/#sec-privateelementfind */
+export function PrivateElementFind(P: PrivateName, O: ObjectValue) {
+  const entry = O.PrivateElements.find((e) => e.Key === P);
+  // 1. If O.[[PrivateElements]] contains a PrivateElement whose [[Key]] is P, then
+  if (entry) {
+    // a. Let entry be that PrivateElement.
+    // b. Return entry.
+    return entry;
+  }
+  // 2. Return empty.
+  return undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-privateget */
+export function* PrivateGet(O: ObjectValue, P: PrivateName) {
+  // 1. Let entry be ! PrivateElementFind(P, O).
+  const entry = X(PrivateElementFind(P, O));
+  // 2. If entry is empty, throw a TypeError exception.
+  if (entry === undefined) {
+    return Throw.TypeError('$1 does not exist on $2', P, O);
+  }
+  // 3. If entry.[[Kind]] is field or method, then
+  if (entry.Kind === 'field' || entry.Kind === 'method') {
+    // a. Return entry.[[Value]].
+    return entry.Value!;
+  }
+  // 4. Assert: entry.[[Kind]] is accessor.
+  Assert(entry.Kind === 'accessor');
+  // 5. If entry.[[Get]] is undefined, throw a TypeError exception.
+  if (entry.Getter === Value.undefined) {
+    return Throw.TypeError('Private field $1 is not a getter', P);
+  }
+  // 6. Let getter be entry.[[Get]].
+  const getter = entry.Getter!;
+  // 7. Return ? Call(getter, O).
+  return Q(yield* Call(getter, O));
+}
+
+export function* PrivateSet(O: ObjectValue, P: PrivateName, value: Value) {
+  // 1. Let entry be ! PrivateElementFind(P, O).
+  const entry = X(PrivateElementFind(P, O));
+  // 2. If entry is empty, throw a TypeError exception.
+  if (entry === undefined) {
+    return Throw.TypeError('$1 does not exist on $2', P, O);
+  }
+  // 3. If entry.[[Kind]] is field, then
+  if (entry.Kind === 'field') {
+    // a. Set entry.[[Value]] to value.
+    entry.Value = value;
+  } else if (entry.Kind === 'method') { // 4. Else if entry.[[Kind]] is method, then
+    // a. Throw a TypeError exception.
+    return Throw.TypeError('Private method $1 cannot be set', P);
+  } else { // 5. Else,
+    // a. Assert: entry.[[Kind]] is accessor.
+    Assert(entry.Kind === 'accessor');
+    // b. If entry.[[Set]] is undefined, throw a TypeError exception.
+    if (entry.Setter === Value.undefined) {
+      return Throw.TypeError('Private field $1 is not a setter', P);
+    }
+    // c. Let setter be entry.[[Set]].
+    const setter = entry.Setter!;
+    // d. Perform ? Call(setter, O, « value »).
+    Q(yield* Call(setter, O, [value]));
+  }
+  return undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-privatemethodoraccessoradd */
+export function* PrivateMethodOrAccessorAdd(O: ObjectValue, method: PrivateElementRecord) {
+  // 1. Assert: method.[[Kind]] is either method or accessor.
+  Assert(method.Kind === 'method' || method.Kind === 'accessor');
+  if (Q(yield* IsExtensible(O)) === Value.false) {
+    return Throw.TypeError('Cannot define private element to a non-extensible object');
+  }
+  // 2. Let entry be ! PrivateElementFind(method.[[Key]], O).
+  const entry = X(PrivateElementFind(method.Key, O));
+  // 3. If entry is not empty, throw a TypeError exception.
+  if (entry !== undefined) {
+    return Throw.TypeError('Private element $1 is already defined on $2', method.Key, O);
+  }
+  // 4. Append method to O.[[PrivateElements]].
+  O.PrivateElements.push(method);
+  // 5. NOTE: The values for private methods and accessors are shared across instances.
+  //          This step does not create a new copy of the method or accessor.
+  return undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-privatefieldadd */
+export function* PrivateFieldAdd(O: ObjectValue, P: PrivateName, value: Value) {
+  // 1. Let entry be ! PrivateElementFind(P, O).
+  const entry = X(PrivateElementFind(P, O));
+  if (Q(yield* IsExtensible(O)) === Value.false) {
+    return Throw.TypeError('Cannot define private element to a non-extensible object');
+  }
+  // 2. If entry is not empty, throw a TypeError exception.
+  if (entry !== undefined) {
+    return Throw.TypeError('Private element $1 is already defined on $2', P, O);
+  }
+  // 3. Append PrivateElement { [[Key]]: P, [[Kind]]: field, [[Value]]: value } to O.[[PrivateElements]].
+  O.PrivateElements.push(PrivateElementRecord({
+    Key: P,
+    Kind: 'field',
+    Value: value,
+  }));
+  return undefined;
+}
+
+/** https://arai-a.github.io/ecma262-compare/snapshot.html?pr=2417#sec-initializeprivatemethods */
+export function* InitializePrivateMethods(O: ObjectValue, elementDefinitions: readonly ClassElementDefinitionRecord[]): PlainEvaluator<void> {
+  const privateMethods: PrivateElementRecord[] = [];
+  for (const element of elementDefinitions) {
+    if (element.Key instanceof PrivateName && (element.Kind === 'method' || element.Kind === 'getter' || element.Kind === 'setter' || element.Kind === 'accessor')) {
+      if (element.Kind === 'method') {
+        const privateElement = PrivateElementRecord({
+          Key: element.Key,
+          Kind: 'method',
+          Value: element.Value,
+        });
+        privateMethods.push(privateElement);
+      } else if (element.Kind === 'accessor') {
+        const privateElement = PrivateElementRecord({
+          Key: element.Key,
+          Kind: 'accessor',
+          Getter: element.Get,
+          Setter: element.Set,
+        });
+        privateMethods.push(privateElement);
+      } else {
+        Assert(element.Kind === 'getter' || element.Kind === 'setter');
+        let getter = element.Kind === 'getter' ? element.Get : Value.undefined;
+        let setter = element.Kind === 'setter' ? element.Set : Value.undefined;
+        let existing: PrivateElementRecord | undefined;
+        const e = privateMethods.find(((e) => e.Key === element.Key));
+        if (e) {
+          Assert(e.Kind === 'accessor');
+          existing = e;
+          if (e.Getter !== undefined && e.Getter !== Value.undefined) {
+            getter = e.Getter;
+          }
+          if (e.Setter !== undefined && e.Setter !== Value.undefined) {
+            setter = e.Setter;
+          }
+        }
+        const privateElement = PrivateElementRecord({
+          Key: element.Key,
+          Kind: 'accessor',
+          Getter: getter,
+          Setter: setter,
+        });
+        if (existing) {
+          const index = privateMethods.indexOf(existing);
+          privateMethods[index] = privateElement;
+        } else {
+          privateMethods.push(privateElement);
+        }
+      }
+    }
+  }
+  for (const method of privateMethods) {
+    Q(yield* PrivateMethodOrAccessorAdd(O, method));
+  }
+}