@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/src/abstract-ops/objects.mts

@@ -0,0 +1,435 @@
+import {
+  Descriptor,
+  ObjectValue,
+  SymbolValue, JSStringValue, UndefinedValue, NullValue,
+  Value,
+  BooleanValue,
+  type PropertyKeyValue,
+  type DescriptorInit,
+  type CanBeNativeSteps,
+} from '../value.mts';
+import {
+  Q, X,
+  type ExpressionCompletion,
+} from '../completion.mts';
+import type { Mutable } from '../helpers.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;
+}
+// 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) === Value.true) {
+    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) === Value.true) {
+      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: OrdinaryObject, 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.Get = x.Get;
+    D.Set = x.Set;
+  }
+  D.Enumerable = x.Enumerable;
+  D.Configurable = x.Configurable;
+
+  return Descriptor(D);
+}
+
+// 9.1.6.1 OrdinaryDefineOwnProperty
+export function OrdinaryDefineOwnProperty(O: OrdinaryObject, P: PropertyKeyValue, Desc: Descriptor): ExpressionCompletion<BooleanValue> {
+  const current = Q(O.GetOwnProperty(P));
+  const extensible = Q(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: OrdinaryObject | UndefinedValue, P: PropertyKeyValue | UndefinedValue, extensible: BooleanValue, Desc: Descriptor, current: UndefinedValue | Descriptor) {
+  Assert(O === Value.undefined || IsPropertyKey(P));
+
+  if (current === Value.undefined) {
+    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({
+          Get: Desc.Get === undefined ? Value.undefined : Desc.Get,
+          Set: Desc.Set === undefined ? Value.undefined : Desc.Set,
+          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.Get = Value.undefined;
+        entry.Set = Value.undefined;
+        O.properties.set(P as PropertyKeyValue, Descriptor(entry));
+      }
+    } else {
+      if (!(O instanceof UndefinedValue)) {
+        const entry = { ...O.properties.get(P as PropertyKeyValue) };
+        entry.Get = undefined;
+        entry.Set = 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) === Value.false) {
+        return Value.false;
+      }
+      return Value.true;
+    }
+  } else {
+    Assert(IsAccessorDescriptor(current) && IsAccessorDescriptor(Desc));
+    if (current.Configurable === Value.false) {
+      if (Desc.Set !== undefined && SameValue(Desc.Set, current.Set) === Value.false) {
+        return Value.false;
+      }
+      if (Desc.Get !== undefined && SameValue(Desc.Get, current.Get) === Value.false) {
+        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.Get !== undefined) {
+      target.Get = Desc.Get;
+    }
+    if (Desc.Set !== undefined) {
+      target.Set = Desc.Set;
+    }
+    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: OrdinaryObject, P: PropertyKeyValue): ExpressionCompletion<BooleanValue> {
+  Assert(IsPropertyKey(P));
+
+  const hasOwn = Q(O.GetOwnProperty(P));
+  if (!(hasOwn instanceof UndefinedValue)) {
+    return Value.true;
+  }
+  const parent = Q(O.GetPrototypeOf());
+  if (!(parent instanceof NullValue)) {
+    return Q(parent.HasProperty(P));
+  }
+  return Value.false;
+}
+
+// 9.1.8.1
+export function OrdinaryGet(O: OrdinaryObject, P: PropertyKeyValue, Receiver: Value): ExpressionCompletion {
+  Assert(IsPropertyKey(P));
+
+  const desc = Q(O.GetOwnProperty(P));
+  if (desc instanceof UndefinedValue) {
+    const parent = Q(O.GetPrototypeOf());
+    if (parent instanceof NullValue) {
+      return Value.undefined;
+    }
+    return Q(parent.Get(P, Receiver));
+  }
+  if (IsDataDescriptor(desc)) {
+    return desc.Value;
+  }
+  Assert(IsAccessorDescriptor(desc));
+  const getter = desc.Get;
+  if (getter instanceof UndefinedValue) {
+    return Value.undefined;
+  }
+  return Q(Call(getter, Receiver));
+}
+
+// 9.1.9.1 OrdinarySet
+export function OrdinarySet(O: OrdinaryObject, P: PropertyKeyValue, V: Value, Receiver: Value) {
+  Assert(IsPropertyKey(P));
+  const ownDesc = Q(O.GetOwnProperty(P));
+  return OrdinarySetWithOwnDescriptor(O, P, V, Receiver, ownDesc);
+}
+
+// 9.1.9.2 OrdinarySetWithOwnDescriptor
+export function OrdinarySetWithOwnDescriptor(O: OrdinaryObject, P: PropertyKeyValue, V: Value, Receiver: Value, ownDesc: Descriptor | UndefinedValue): ExpressionCompletion<BooleanValue> {
+  Assert(IsPropertyKey(P));
+
+  if (ownDesc instanceof UndefinedValue) {
+    const parent = Q(O.GetPrototypeOf());
+    if (!(parent instanceof NullValue)) {
+      return Q(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(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(Receiver.DefineOwnProperty(P, valueDesc));
+    }
+    return CreateDataProperty(Receiver, P, V);
+  }
+
+  Assert(IsAccessorDescriptor(ownDesc));
+  const setter = ownDesc.Set;
+  if (setter === undefined || setter instanceof UndefinedValue) {
+    return Value.false;
+  }
+  Q(Call(setter, Receiver, [V]));
+  return Value.true;
+}
+
+// 9.1.10.1 OrdinaryDelete
+export function OrdinaryDelete(O: OrdinaryObject, P: PropertyKeyValue): ExpressionCompletion<BooleanValue> {
+  Assert(IsPropertyKey(P));
+  const desc = Q(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: OrdinaryObject) {
+  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>) => {
+  const O = OrdinaryObjectCreate(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[]): ExpressionCompletion<ObjectValue> {
+  // Assert: intrinsicDefaultProto is a String value that is this specification's name of an intrinsic object.
+  const proto = Q(GetPrototypeFromConstructor(constructor, intrinsicDefaultProto));
+  return OrdinaryObjectCreate(proto, internalSlotsList);
+}
+
+// 9.1.14 GetPrototypeFromConstructor
+export function GetPrototypeFromConstructor(constructor: FunctionObject, intrinsicDefaultProto: keyof Intrinsics): ExpressionCompletion<ObjectValue> {
+  // Assert: intrinsicDefaultProto is a String value that
+  // is this specification's name of an intrinsic object.
+  Assert(IsCallable(constructor) === Value.true);
+  let proto = Q(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,106 @@
+import { ObjectValue, PrivateName, Value } from '../value.mts';
+import { surroundingAgent } from '../engine.mts';
+import { Q, X } from '../completion.mts';
+import { PrivateElementRecord } from '../runtime-semantics/all.mts';
+import { Assert, Call } from './all.mts';
+
+/** 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(P: PrivateName, O: ObjectValue) {
+  // 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 surroundingAgent.Throw('TypeError', 'UnknownPrivateName', O, P);
+  }
+  // 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.Get === Value.undefined) {
+    return surroundingAgent.Throw('TypeError', 'PrivateNameNoGetter', P);
+  }
+  // 6. Let getter be entry.[[Get]].
+  const getter = entry.Get!;
+  // 7. Return ? Call(getter, O).
+  return Q(Call(getter, O));
+}
+
+export function PrivateSet(P: PrivateName, O: ObjectValue, 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 surroundingAgent.Throw('TypeError', 'UnknownPrivateName', O, P);
+  }
+  // 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 surroundingAgent.Throw('TypeError', 'PrivateNameIsMethod', 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.Set === Value.undefined) {
+      return surroundingAgent.Throw('TypeError', 'PrivateNameNoSetter', P);
+    }
+    // c. Let setter be entry.[[Set]].
+    const setter = entry.Set!;
+    // d. Perform ? Call(setter, O, « value »).
+    Q(Call(setter, O, [value]));
+  }
+  return undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-privatemethodoraccessoradd */
+export function PrivateMethodOrAccessorAdd(method: PrivateElementRecord, O: ObjectValue) {
+  // 1. Assert: method.[[Kind]] is either method or accessor.
+  Assert(method.Kind === 'method' || method.Kind === 'accessor');
+  // 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 surroundingAgent.Throw('TypeError', 'AlreadyDeclared', method.Key);
+  }
+  // 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(P: PrivateName, O: ObjectValue, value: Value) {
+  // 1. Let entry be ! PrivateElementFind(P, O).
+  const entry = X(PrivateElementFind(P, O));
+  // 2. If entry is not empty, throw a TypeError exception.
+  if (entry !== undefined) {
+    return surroundingAgent.Throw('TypeError', 'AlreadyDeclared', P);
+  }
+  // 3. Append PrivateElement { [[Key]]: P, [[Kind]]: field, [[Value]]: value } to O.[[PrivateElements]].
+  O.PrivateElements.push(new PrivateElementRecord({
+    Key: P,
+    Kind: 'field',
+    Value: value,
+  }));
+  return undefined;
+}