@engine262/engine262 0.0.1-0574c6b92a2925de851f895445b7cfd7e97cc0ba

package/src/abstract-ops/spec-types.mts

@@ -0,0 +1,220 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  BigIntValue,
+  DataBlock,
+  Descriptor,
+  NumberValue,
+  ObjectValue,
+  UndefinedValue,
+  Value,
+  BooleanValue,
+} from '../value.mts';
+import { NormalCompletion, Q, X } from '../completion.mts';
+import type { PlainEvaluator } from '../evaluator.mts';
+import {
+  Assert,
+  CreateDataProperty,
+  Get,
+  HasProperty,
+  IsCallable,
+  OrdinaryObjectCreate,
+  ToBoolean,
+  type FunctionObject,
+} from './all.mts';
+import { isNonNegativeInteger } from './data-types-and-values.mts';
+
+// #𝔽
+export function F(x: number): NumberValue {
+  Assert(typeof x === 'number');
+  return Value(x);
+}
+
+// #ℤ
+export function Z(x: bigint): BigIntValue {
+  Assert(typeof x === 'bigint');
+  return Value(x);
+}
+
+// #ℝ
+export function R(x: NumberValue): number;
+export function R(x: BigIntValue): bigint;
+export function R(x: BigIntValue | NumberValue): bigint | number;
+export function R(x: unknown) {
+  if (x instanceof BigIntValue) {
+    return x.bigintValue(); // eslint-disable-line @engine262/mathematical-value
+  }
+  Assert(x instanceof NumberValue);
+  return x.numberValue(); // eslint-disable-line @engine262/mathematical-value
+}
+
+// 6.2.5.1 IsAccessorDescriptor
+export function IsAccessorDescriptor(Desc: Descriptor): Desc is Descriptor & { Get: Value; Set: Value } {
+  if (Desc.Get === undefined && Desc.Set === undefined) {
+    return false;
+  }
+
+  return true;
+}
+
+// 6.2.5.2 IsDataDescriptor
+export function IsDataDescriptor(Desc: Descriptor): Desc is Descriptor & { Value: Value; Writable: BooleanValue } {
+  if (Desc.Value === undefined && Desc.Writable === undefined) {
+    return false;
+  }
+
+  return true;
+}
+
+// 6.2.5.3 IsGenericDescriptor
+export function IsGenericDescriptor(Desc: Descriptor) {
+  if (!IsAccessorDescriptor(Desc) && !IsDataDescriptor(Desc)) {
+    return true;
+  }
+
+  return false;
+}
+
+/** https://tc39.es/ecma262/#sec-frompropertydescriptor */
+export function FromPropertyDescriptor(Desc: Descriptor | UndefinedValue) {
+  if (Desc instanceof UndefinedValue) {
+    return Value.undefined;
+  }
+  const obj = OrdinaryObjectCreate(surroundingAgent.intrinsic('%Object.prototype%'));
+  if (Desc.Value !== undefined) {
+    X(CreateDataProperty(obj, Value('value'), Desc.Value));
+  }
+  if (Desc.Writable !== undefined) {
+    X(CreateDataProperty(obj, Value('writable'), Desc.Writable));
+  }
+  if (Desc.Get !== undefined) {
+    X(CreateDataProperty(obj, Value('get'), Desc.Get));
+  }
+  if (Desc.Set !== undefined) {
+    X(CreateDataProperty(obj, Value('set'), Desc.Set));
+  }
+  if (Desc.Enumerable !== undefined) {
+    X(CreateDataProperty(obj, Value('enumerable'), Desc.Enumerable));
+  }
+  if (Desc.Configurable !== undefined) {
+    X(CreateDataProperty(obj, Value('configurable'), Desc.Configurable));
+  }
+  // Assert: All of the above CreateDataProperty operations return true.
+  return obj;
+}
+
+/** https://tc39.es/ecma262/#sec-topropertydescriptor */
+export function* ToPropertyDescriptor(Obj: Value): PlainEvaluator<Descriptor> {
+  if (!(Obj instanceof ObjectValue)) {
+    return surroundingAgent.Throw('TypeError', 'NotAnObject', Obj);
+  }
+
+  let desc = Descriptor({});
+  const hasEnumerable = Q(yield* HasProperty(Obj, Value('enumerable')));
+  if (hasEnumerable === Value.true) {
+    const enumerable = ToBoolean(Q(yield* Get(Obj, Value('enumerable'))));
+    desc = Descriptor({ ...desc, Enumerable: enumerable });
+  }
+  const hasConfigurable = Q(yield* HasProperty(Obj, Value('configurable')));
+  if (hasConfigurable === Value.true) {
+    const conf = ToBoolean(Q(yield* Get(Obj, Value('configurable'))));
+    desc = Descriptor({ ...desc, Configurable: conf });
+  }
+  const hasValue = Q(yield* HasProperty(Obj, Value('value')));
+  if (hasValue === Value.true) {
+    const value = Q(yield* Get(Obj, Value('value')));
+    desc = Descriptor({ ...desc, Value: value });
+  }
+  const hasWritable = Q(yield* HasProperty(Obj, Value('writable')));
+  if (hasWritable === Value.true) {
+    const writable = ToBoolean(Q(yield* Get(Obj, Value('writable'))));
+    desc = Descriptor({ ...desc, Writable: writable });
+  }
+  const hasGet = Q(yield* HasProperty(Obj, Value('get')));
+  if (hasGet === Value.true) {
+    const getter = Q(yield* Get(Obj, Value('get')));
+    if (!IsCallable(getter) && !(getter instanceof UndefinedValue)) {
+      return surroundingAgent.Throw('TypeError', 'NotAFunction', getter);
+    }
+    desc = Descriptor({ ...desc, Get: getter as FunctionObject });
+  }
+  const hasSet = Q(yield* HasProperty(Obj, Value('set')));
+  if (hasSet === Value.true) {
+    const setter = Q(yield* Get(Obj, Value('set')));
+    if (!IsCallable(setter) && !(setter instanceof UndefinedValue)) {
+      return surroundingAgent.Throw('TypeError', 'NotAFunction', setter);
+    }
+    desc = Descriptor({ ...desc, Set: setter as FunctionObject });
+  }
+  if (desc.Get !== undefined || desc.Set !== undefined) {
+    if (desc.Value !== undefined || desc.Writable !== undefined) {
+      return surroundingAgent.Throw('TypeError', 'InvalidPropertyDescriptor');
+    }
+  }
+  return desc;
+}
+
+/** https://tc39.es/ecma262/#sec-completepropertydescriptor */
+export function CompletePropertyDescriptor(Desc: Descriptor) {
+  Assert(Desc instanceof Descriptor);
+  const like = Descriptor({
+    Value: Value.undefined,
+    Writable: Value.false,
+    Get: Value.undefined,
+    Set: Value.undefined,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  });
+  if (IsGenericDescriptor(Desc) || IsDataDescriptor(Desc)) {
+    if (Desc.Value === undefined) {
+      Desc = Descriptor({ ...Desc, Value: like.Value });
+    }
+    if (Desc.Writable === undefined) {
+      Desc = Descriptor({ ...Desc, Writable: like.Writable });
+    }
+  } else {
+    if (Desc.Get === undefined) {
+      Desc = Descriptor({ ...Desc, Get: like.Get });
+    }
+    if (Desc.Set === undefined) {
+      Desc = Descriptor({ ...Desc, Set: like.Set });
+    }
+  }
+  if (Desc.Enumerable === undefined) {
+    Desc = Descriptor({ ...Desc, Enumerable: like.Enumerable });
+  }
+  if (Desc.Configurable === undefined) {
+    Desc = Descriptor({ ...Desc, Configurable: like.Configurable });
+  }
+  return Desc;
+}
+
+/** https://tc39.es/ecma262/#sec-createbytedatablock */
+export function CreateByteDataBlock(size: number) {
+  Assert(isNonNegativeInteger(size));
+  let db;
+  try {
+    db = new DataBlock(size);
+  } catch (err) {
+    return surroundingAgent.Throw('RangeError', 'CannotAllocateDataBlock');
+  }
+  return db;
+}
+
+/** https://tc39.es/ecma262/#sec-copydatablockbytes */
+export function CopyDataBlockBytes(toBlock: DataBlock, toIndex: number, fromBlock: DataBlock, fromIndex: number, count: number) {
+  Assert(fromBlock !== toBlock);
+  Assert(Number.isSafeInteger(fromIndex) && fromIndex >= 0);
+  Assert(Number.isSafeInteger(toIndex) && toIndex >= 0);
+  Assert(Number.isSafeInteger(count) && count >= 0);
+  const fromSize = fromBlock.byteLength;
+  Assert(fromIndex + count <= fromSize);
+  const toSize = toBlock.byteLength;
+  Assert(toIndex + count <= toSize);
+  while (count > 0) {
+    toBlock[toIndex] = fromBlock[fromIndex];
+    toIndex += 1;
+    fromIndex += 1;
+    count -= 1;
+  }
+  return NormalCompletion(undefined);
+}

package/src/abstract-ops/string-objects.mts

@@ -0,0 +1,156 @@
+import {
+  Descriptor,
+  ObjectValue,
+  SymbolValue,
+  JSStringValue,
+  UndefinedValue,
+  Value,
+  type PropertyKeyValue,
+  type ObjectInternalMethods,
+} from '../value.mts';
+import { X } from '../completion.mts';
+import type { StringObject } from '../intrinsics/String.mts';
+import type { Mutable } from '../helpers.mts';
+import {
+  Assert,
+  CanonicalNumericIndexString,
+  DefinePropertyOrThrow,
+  IsIntegralNumber,
+  IsPropertyKey,
+  MakeBasicObject,
+  OrdinaryGetOwnProperty,
+  OrdinaryDefineOwnProperty,
+  IsCompatiblePropertyDescriptor,
+  ToIntegerOrInfinity,
+  ToString,
+  isArrayIndex,
+  F, R,
+} from './all.mts';
+
+const InternalMethods = {
+  * GetOwnProperty(P) {
+    const S = this;
+    Assert(IsPropertyKey(P));
+    const desc = OrdinaryGetOwnProperty(S, P);
+    if (!(desc instanceof UndefinedValue)) {
+      return desc;
+    }
+    return X(StringGetOwnProperty(S, P));
+  },
+  * DefineOwnProperty(P, Desc) {
+    const S = this;
+    Assert(IsPropertyKey(P));
+    const stringDesc = X(StringGetOwnProperty(S, P));
+    if (!(stringDesc instanceof UndefinedValue)) {
+      const extensible = S.Extensible;
+      return X(IsCompatiblePropertyDescriptor(extensible, Desc, stringDesc));
+    }
+    return X(OrdinaryDefineOwnProperty(S, P, Desc));
+  },
+  * OwnPropertyKeys() {
+    const O = this;
+    const keys = [];
+    const str = O.StringData;
+    Assert(str instanceof JSStringValue);
+    const len = str.stringValue().length;
+
+    // 5. For each non-negative integer i starting with 0 such that i < len, in ascending order, do
+    for (let i = 0; i < len; i += 1) {
+      // a. Add ! ToString(𝔽(i)) as the last element of keys.
+      keys.push(X(ToString(F(i))));
+    }
+
+    // For each own property key P of O such that P is an array index and
+    // ToIntegerOrInfinity(P) ≥ len, in ascending numeric index order, do
+    //   Add P as the last element of keys.
+    for (const P of O.properties.keys()) {
+      // This is written with two nested ifs to work around https://github.com/devsnek/engine262/issues/24
+      if (isArrayIndex(P)) {
+        if (X(ToIntegerOrInfinity(P)) >= len) {
+          keys.push(P);
+        }
+      }
+    }
+
+    // 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;
+  },
+} satisfies Partial<ObjectInternalMethods<StringObject>>;
+
+/** https://tc39.es/ecma262/#sec-stringcreate */
+export function StringCreate(value: JSStringValue, prototype: ObjectValue) {
+  // 1. Assert: Type(value) is String.
+  Assert(value instanceof JSStringValue);
+  // 2. Let S be ! MakeBasicObject(« [[Prototype]], [[Extensible]], [[StringData]] »).
+  const S = X(MakeBasicObject(['Prototype', 'Extensible', 'StringData'])) as Mutable<StringObject>;
+  // 3. Set S.[[Prototype]] to prototype.
+  S.Prototype = prototype;
+  // 4. Set S.[[StringData]] to value.
+  S.StringData = value;
+  // 5. Set S.[[GetOwnProperty]] as specified in 9.4.3.1.
+  S.GetOwnProperty = InternalMethods.GetOwnProperty;
+  // 6. Set S.[[DefineOwnProperty]] as specified in 9.4.3.2.
+  S.DefineOwnProperty = InternalMethods.DefineOwnProperty;
+  // 7. Set S.[[OwnPropertyKeys]] as specified in 9.4.3.3.
+  S.OwnPropertyKeys = InternalMethods.OwnPropertyKeys;
+  // 8. Let length be the number of code unit elements in value.
+  const length = value.stringValue().length;
+  // 9. Perform ! DefinePropertyOrThrow(S, "length", PropertyDescriptor { [[Value]]: length, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }).
+  X(DefinePropertyOrThrow(S, Value('length'), Descriptor({
+    Value: F(length),
+    Writable: Value.false,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+  // 10. Return S.
+  return S;
+}
+
+/** https://tc39.es/ecma262/#sec-stringgetownproperty */
+export function StringGetOwnProperty(S: ObjectValue, P: PropertyKeyValue) {
+  Assert(S instanceof ObjectValue && 'StringData' in S);
+  Assert(IsPropertyKey(P));
+  if (!(P instanceof JSStringValue)) {
+    return Value.undefined;
+  }
+  const index = X(CanonicalNumericIndexString(P));
+  if (index instanceof UndefinedValue) {
+    return Value.undefined;
+  }
+  if (IsIntegralNumber(index) === Value.false) {
+    return Value.undefined;
+  }
+  if (Object.is(R(index), -0)) {
+    return Value.undefined;
+  }
+  const str = S.StringData;
+  Assert(str instanceof JSStringValue);
+  const len = str.stringValue().length;
+  if (R(index) < 0 || len <= R(index)) {
+    return Value.undefined;
+  }
+  const resultStr = str.stringValue()[R(index)];
+  return Descriptor({
+    Value: Value(resultStr),
+    Writable: Value.false,
+    Enumerable: Value.true,
+    Configurable: Value.false,
+  });
+}

package/src/abstract-ops/symbol-objects.mts

@@ -0,0 +1,30 @@
+import { GlobalSymbolRegistry } from '../intrinsics/Symbol.mjs';
+import {
+  UndefinedValue, SymbolValue, Value, JSStringValue,
+} from '../value.mts';
+import { Assert, SameValue } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-symboldescriptivestring */
+export function SymbolDescriptiveString(sym: SymbolValue) {
+  Assert(sym instanceof SymbolValue);
+  let desc = sym.Description;
+  if (desc instanceof UndefinedValue) {
+    desc = Value('');
+  }
+  return Value(`Symbol(${desc.stringValue()})`);
+}
+
+/** https://tc39.es/ecma262/#sec-keyforsymbol */
+export function KeyForSymbol(sym: SymbolValue): JSStringValue | UndefinedValue {
+  // 1. For each element e of the GlobalSymbolRegistry List, do
+  for (const e of GlobalSymbolRegistry) {
+    // a. If SameValue(e.[[Symbol]], sym) is true, return e.[[Key]].
+    if (SameValue(e.Symbol, sym) === Value.true) {
+      return e.Key;
+    }
+  }
+
+  // 2. Assert: The GlobalSymbolRegistry List does not currently contain an entry for sym.
+  // 3. Return undefined.
+  return Value.undefined;
+}