@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/abstract-ops/iterator-operations.mts

@@ -0,0 +1,409 @@
+import {
+  BooleanValue,
+  JSStringValue,
+  ObjectValue,
+  UndefinedValue,
+  Value,
+  wellKnownSymbols,
+  type Arguments,
+} from '../value.mts';
+import {
+  Completion,
+  EnsureCompletion,
+  IfAbruptRejectPromise,
+  Q, X,
+  Await,
+  NormalCompletion,
+  type ValueEvaluator,
+  ThrowCompletion,
+  AbruptCompletion,
+} from '../completion.mts';
+import { __ts_cast__, type Mutable } from '../utils/language.mts';
+import type { AsyncFromSyncIteratorObject } from '../intrinsics/AsyncFromSyncIteratorPrototype.mts';
+import type {
+  Evaluator, PlainEvaluator, YieldEvaluator,
+} from '../evaluator.mts';
+import {
+  Assert,
+  Call,
+  CreateBuiltinFunction,
+  Get,
+  GetMethod,
+  PromiseResolve,
+  OrdinaryObjectCreate,
+  PerformPromiseThen,
+  ToBoolean,
+  CreateIteratorFromClosure,
+  type FunctionObject,
+  PromiseCapabilityRecord,
+  CreateDataPropertyOrThrow,
+  GeneratorYield,
+  Yield,
+  type GeneratorObject,
+} from './all.mts';
+import { surroundingAgent } from '#self';
+import {
+  type ValueCompletion, type PromiseObject, type OrdinaryObject, Throw,
+  ReturnCompletion,
+  IfAbruptCloseIterators,
+} from '#self';
+
+// This file covers abstract operations defined in
+/** https://tc39.es/ecma262/#sec-operations-on-iterator-objects */
+// and
+/** https://tc39.es/ecma262/#sec-iteration */
+
+export interface IteratorRecord {
+  readonly Iterator: ObjectValue;
+  readonly NextMethod: Value;
+  Done: BooleanValue;
+}
+
+export interface IteratorObject extends OrdinaryObject {
+  Iterated: IteratorRecord;
+}
+
+/** https://tc39.es/ecma262/#sec-getiteratordirect */
+export function* GetIteratorDirect(obj: ObjectValue): PlainEvaluator<IteratorRecord> {
+  const nextMethod = Q(yield* Get(obj, Value('next')));
+  const iteratorRecord: IteratorRecord = {
+    Iterator: obj,
+    NextMethod: nextMethod,
+    Done: Value.false,
+  };
+  return iteratorRecord;
+}
+
+/** https://tc39.es/ecma262/#sec-getiteratorfrommethod */
+export function* GetIteratorFromMethod(obj: Value, method: FunctionObject): PlainEvaluator<IteratorRecord> {
+  const iterator = Q(yield* Call(method, obj));
+  if (!(iterator instanceof ObjectValue)) {
+    return Throw.TypeError('$1 is not an object', iterator);
+  }
+  return yield* GetIteratorDirect(iterator);
+}
+
+/** https://tc39.es/ecma262/#sec-getiterator */
+export function* GetIterator(obj: Value, kind: 'sync' | 'async'): PlainEvaluator<IteratorRecord> {
+  let method;
+  if (kind === 'async') {
+    method = Q(yield* GetMethod(obj, wellKnownSymbols.asyncIterator));
+    if (method === Value.undefined) {
+      const syncMethod = Q(yield* GetMethod(obj, wellKnownSymbols.iterator));
+      if (syncMethod instanceof UndefinedValue) {
+        return Throw.TypeError('$1 is not iterable', obj);
+      }
+      const syncIteratorRecord = Q(yield* GetIteratorFromMethod(obj, syncMethod));
+      return CreateAsyncFromSyncIterator(syncIteratorRecord);
+    }
+  } else {
+    method = Q(yield* GetMethod(obj, wellKnownSymbols.iterator));
+  }
+  if (method instanceof UndefinedValue) {
+    return Throw.TypeError('$1 is not iterable', obj);
+  }
+  return yield* GetIteratorFromMethod(obj, method);
+}
+
+export type PrimitiveHanding = 'iterate-string-primitives' | 'reject-primitives'
+export function* GetIteratorFlattenable(obj: Value, primitiveHandling: PrimitiveHanding): PlainEvaluator<IteratorRecord> {
+  if (!(obj instanceof ObjectValue)) {
+    if (primitiveHandling === 'reject-primitives') {
+      return Throw.TypeError('$1 is not an object', obj);
+    }
+    Assert(primitiveHandling === 'iterate-string-primitives');
+    if (!(obj instanceof JSStringValue)) {
+      return Throw.TypeError('$1 is not a string', obj);
+    }
+  }
+  const method = Q(yield* GetMethod(obj, wellKnownSymbols.iterator));
+  let iterator;
+  if (method instanceof UndefinedValue) {
+    iterator = obj;
+  } else {
+    iterator = Q(yield* Call(method, obj));
+  }
+  if (!(iterator instanceof ObjectValue)) {
+    return Throw.TypeError('$1 is not an object', iterator);
+  }
+  return yield* GetIteratorDirect(iterator);
+}
+
+/** https://tc39.es/ecma262/#sec-iteratornext */
+export function* IteratorNext(iteratorRecord: IteratorRecord, value?: Value): ValueEvaluator<ObjectValue> {
+  let result;
+  if (!value) {
+    result = EnsureCompletion(yield* Call(iteratorRecord.NextMethod, iteratorRecord.Iterator));
+  } else {
+    result = EnsureCompletion(yield* Call(iteratorRecord.NextMethod, iteratorRecord.Iterator, [value]));
+  }
+  if (result instanceof ThrowCompletion) {
+    iteratorRecord.Done = Value.true;
+    return Q(result);
+  }
+  result = X(result);
+  if (!(result instanceof ObjectValue)) {
+    iteratorRecord.Done = Value.true;
+    return Throw.TypeError('$1 is not an object', result);
+  }
+  return result;
+}
+
+/** https://tc39.es/ecma262/#sec-iteratorcomplete */
+export function* IteratorComplete(iteratorResult: ObjectValue): ValueEvaluator<BooleanValue> {
+  return ToBoolean(Q(yield* Get(iteratorResult, Value('done'))));
+}
+
+/** https://tc39.es/ecma262/#sec-iteratorvalue */
+export function IteratorValue(iterResult: ObjectValue): ValueEvaluator {
+  return Get(iterResult, Value('value'));
+}
+
+/** https://tc39.es/ecma262/#sec-iteratorstep */
+export function* IteratorStep(iteratorRecord: IteratorRecord): PlainEvaluator<ObjectValue | 'done'> {
+  const result = Q(yield* IteratorNext(iteratorRecord));
+  let done: ValueCompletion = EnsureCompletion(yield* IteratorComplete(result));
+  if (done instanceof ThrowCompletion) {
+    iteratorRecord.Done = Value.true;
+    return done;
+  }
+  done = X(done);
+  if (done === Value.true) {
+    iteratorRecord.Done = Value.true;
+    return 'done';
+  }
+  return result;
+}
+
+/** https://tc39.es/ecma262/#sec-iteratorstepvalue */
+export function* IteratorStepValue(iteratorRecord: IteratorRecord): PlainEvaluator<Value | 'done'> {
+  const result = Q(yield* IteratorStep(iteratorRecord));
+  if (result === 'done') {
+    return 'done';
+  }
+  const value = EnsureCompletion(yield* IteratorValue(result));
+  if (value instanceof ThrowCompletion) {
+    iteratorRecord.Done = Value.true;
+  }
+  return value;
+}
+
+/** https://tc39.es/ecma262/#sec-iteratorclose */
+export function* IteratorClose<T, C extends Completion<T>>(iteratorRecord: IteratorRecord, completion: C): Evaluator<C | ThrowCompletion> {
+  Assert(iteratorRecord.Iterator instanceof ObjectValue);
+  const iterator = iteratorRecord.Iterator;
+  let innerResult: ValueCompletion = EnsureCompletion(yield* GetMethod(iterator, Value('return')));
+  if (innerResult instanceof NormalCompletion) {
+    const ret = innerResult.Value;
+    if (ret === Value.undefined) {
+      return completion;
+    }
+    innerResult = EnsureCompletion(yield* Call(ret, iterator));
+  }
+  if (completion instanceof ThrowCompletion) {
+    return completion;
+  }
+  if (innerResult instanceof ThrowCompletion) {
+    return innerResult;
+  }
+  if (!(innerResult.Value instanceof ObjectValue)) {
+    return Throw.TypeError('$1 is not an object', innerResult.Value);
+  }
+  return completion;
+}
+
+/** https://tc39.es/ecma262/#sec-iteratorcloseall */
+export function* IteratorCloseAll<C>(iters: Iterable<IteratorRecord>, completion: Completion<C>): Evaluator<Completion<C>> {
+  for (const iter of [...iters].reverse()) {
+    completion = yield* IteratorClose(iter, completion);
+  }
+  return completion;
+}
+
+/** https://tc39.es/ecma262/#sec-asynciteratorclose */
+export function* AsyncIteratorClose<T, C extends Completion<T>>(iteratorRecord: IteratorRecord, completion: C | T) {
+  Assert(iteratorRecord.Iterator instanceof ObjectValue);
+  const iterator = iteratorRecord.Iterator;
+  let innerResult: NormalCompletion<Value> | ThrowCompletion = EnsureCompletion(yield* GetMethod(iterator, Value('return')));
+  if (innerResult instanceof NormalCompletion) {
+    const ret = innerResult.Value;
+    if (ret instanceof UndefinedValue) {
+      return completion;
+    }
+    innerResult = EnsureCompletion(yield* Call(ret, iterator));
+    if (innerResult instanceof NormalCompletion) {
+      innerResult = EnsureCompletion(yield* Await(innerResult.Value));
+    }
+  }
+  if (completion instanceof ThrowCompletion) {
+    return completion;
+  }
+  if (innerResult instanceof ThrowCompletion) {
+    return innerResult;
+  }
+  if (!(innerResult.Value instanceof ObjectValue)) {
+    return Throw.TypeError('$1 is not an object', innerResult.Value);
+  }
+  return completion;
+}
+
+/** https://tc39.es/ecma262/#sec-createiterresultobject */
+export function CreateIteratorResultObject(value: Value, done: BooleanValue) {
+  const obj = OrdinaryObjectCreate(surroundingAgent.intrinsic('%Object.prototype%'));
+  X(CreateDataPropertyOrThrow(obj, Value('value'), value));
+  X(CreateDataPropertyOrThrow(obj, Value('done'), done));
+  return obj;
+}
+
+/** https://tc39.es/ecma262/#sec-createlistiteratorRecord */
+export function CreateListIteratorRecord(list: Iterable<Value>): IteratorRecord {
+  const closure = function* closure(): YieldEvaluator {
+    for (const E of list) {
+      Q(yield* GeneratorYield(CreateIteratorResultObject(E, Value.false)));
+    }
+    return NormalCompletion(Value.undefined);
+  };
+  const iterator = CreateIteratorFromClosure(closure, undefined, surroundingAgent.intrinsic('%Iterator.prototype%'));
+  return {
+    Iterator: iterator,
+    NextMethod: surroundingAgent.intrinsic('%GeneratorFunction.prototype.prototype.next%'),
+    Done: Value.false,
+  };
+}
+
+/** https://tc39.es/ecma262/#sec-iteratortolist */
+export function* IteratorToList(iteratorRecord: IteratorRecord): PlainEvaluator<Value[]> {
+  const list: Value[] = [];
+  while (true) {
+    const next = Q(yield* IteratorStepValue(iteratorRecord));
+    if (next === 'done') {
+      return list;
+    }
+    list.push(next);
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-createasyncfromsynciterator */
+export function CreateAsyncFromSyncIterator(syncIteratorRecord: IteratorRecord): IteratorRecord {
+  const asyncIterator = OrdinaryObjectCreate(surroundingAgent.intrinsic('%AsyncFromSyncIteratorPrototype%'), [
+    'SyncIteratorRecord',
+  ]) as Mutable<AsyncFromSyncIteratorObject>;
+  asyncIterator.SyncIteratorRecord = syncIteratorRecord;
+  const nextMethod = X(Get(asyncIterator, Value('next')));
+  return {
+    Iterator: asyncIterator,
+    NextMethod: nextMethod,
+    Done: Value.false,
+  };
+}
+
+/** https://tc39.es/ecma262/#sec-asyncfromsynciteratorcontinuation */
+export function* AsyncFromSyncIteratorContinuation(result: ObjectValue, promiseCapability: PromiseCapabilityRecord, syncIteratorRecord: IteratorRecord, closeOnRejection: BooleanValue): ValueEvaluator<PromiseObject> {
+  const done = yield* IteratorComplete(result);
+  IfAbruptRejectPromise(done, promiseCapability);
+  __ts_cast__<BooleanValue>(done);
+  const value = yield* IteratorValue(result);
+  IfAbruptRejectPromise(value, promiseCapability);
+  __ts_cast__<Value>(value);
+  let valueWrapper = yield* PromiseResolve(surroundingAgent.intrinsic('%Promise%'), value);
+  if (valueWrapper instanceof AbruptCompletion && done === Value.false && closeOnRejection === Value.true) {
+    valueWrapper = yield* IteratorClose(syncIteratorRecord, valueWrapper);
+  }
+  IfAbruptRejectPromise(valueWrapper, promiseCapability);
+  __ts_cast__<PromiseObject>(valueWrapper);
+  const unwrap = ([v = Value.undefined]: Arguments) => CreateIteratorResultObject(v, done);
+  const onFullfilled = CreateBuiltinFunction(unwrap, 1, Value(''), []);
+  let onRejected;
+  if (done === Value.true || closeOnRejection === Value.false) {
+    onRejected = Value.undefined;
+  } else {
+    const closeIterator = ([error = Value.undefined]: Arguments) => IteratorClose(syncIteratorRecord, ThrowCompletion(error));
+    onRejected = CreateBuiltinFunction(closeIterator, 1, Value(''), []);
+  }
+  PerformPromiseThen(valueWrapper, onFullfilled, onRejected, promiseCapability);
+  return promiseCapability.Promise;
+}
+export type IteratorZipMode = 'shortest' | 'longest' | 'strict';
+/** https://tc39.es/ecma262/#sec-IteratorZip */
+export function IteratorZip(
+  _iters: readonly IteratorRecord[],
+  mode: IteratorZipMode,
+  padding: readonly Value[],
+  finishResults: (results: readonly Value[]) => Value,
+) {
+  const iters: (null | IteratorRecord)[] = [..._iters];
+  const iterCount = iters.length;
+  const openIters = [..._iters];
+  const closure = function* IteratorZipClosure(): YieldEvaluator {
+    if (iterCount === 0) {
+      return ReturnCompletion(Value.undefined);
+    }
+    while (true) {
+      const results: Value[] = [];
+      Assert(openIters.length !== 0);
+      for (let i = 0; i < iterCount; i += 1) {
+        const iter = iters[i];
+        let result: Value | 'done';
+        if (iter === null) {
+          Assert(mode === 'longest');
+          result = padding[i];
+        } else {
+          const _result = yield* IteratorStepValue(iter);
+          if (_result instanceof AbruptCompletion) {
+            // Remove iter from openIters.
+            openIters.splice(openIters.indexOf(iter), 1);
+            return Q(yield* IteratorCloseAll(openIters, _result));
+          }
+          result = X(_result);
+          if (result === 'done') {
+            // Remove iter from openIters.
+            openIters.splice(openIters.indexOf(iter), 1);
+            if (mode === 'shortest') {
+              return Q(yield* IteratorCloseAll(openIters, ReturnCompletion(Value.undefined)));
+            } else if (mode === 'strict') {
+              if (i !== 0) {
+                return Q(yield* IteratorCloseAll(openIters, Throw.TypeError('Iterator.zip strict mode requires all iterators to end together')));
+              }
+              for (let k = 1; k < iterCount; k += 1) {
+                const itersK = iters[k];
+                Assert(itersK !== null);
+                const _open = yield* IteratorStep(itersK);
+                if (_open instanceof AbruptCompletion) {
+                  // Remove itersK from openIters.
+                  openIters.splice(openIters.indexOf(itersK), 1);
+                  return Q(yield* IteratorCloseAll(openIters, _open));
+                }
+                const open = X(_open);
+                if (open === 'done') {
+                  // Remove itersK from openIters.
+                  openIters.splice(openIters.indexOf(itersK), 1);
+                } else {
+                  return Q(yield* IteratorCloseAll(openIters, Throw.TypeError('Iterator.zip strict mode requires all iterators to end together')));
+                }
+              }
+              return ReturnCompletion(Value.undefined);
+            }
+            Assert(mode === 'longest');
+            if (openIters.length === 0) {
+              return ReturnCompletion(Value.undefined);
+            }
+            iters[i] = null;
+            result = padding[i];
+          }
+        }
+        results.push(result);
+      }
+      const _results = finishResults(results);
+      const completion = yield* Yield(_results);
+      IfAbruptCloseIterators(completion, openIters);
+    }
+  };
+  const gen = CreateIteratorFromClosure(
+    closure,
+    Value('Iterator Helper'),
+    surroundingAgent.intrinsic('%IteratorHelperPrototype%'),
+    ['UnderlyingIterators'],
+  ) as GeneratorObject;
+  gen.UnderlyingIterators = openIters;
+  return gen;
+}

package/src/abstract-ops/keyed-collections.mts

@@ -0,0 +1,15 @@
+import {
+  F,
+} from './all.mts';
+import {
+  NumberValue, Value,
+} from '#self';
+
+// This file covers abstract operations defined in
+// https://tc39.es/ecma262/#sec-abstract-operations-for-keyed-collections
+
+/** https://tc39.es/ecma262/#sec-canonicalizekeyedcollectionkey */
+export function CanonicalizeKeyedCollectionKey(key: Value): Value {
+  if (key instanceof NumberValue && Object.is(key.value, -0)) return F(+0);
+  return key;
+}

package/src/abstract-ops/math.mts

@@ -0,0 +1,72 @@
+/** https://tc39.es/ecma262/#eqn-truncate */
+export function truncateDiv(x: bigint, y: bigint): bigint {
+  // https://tc39.es/ecma262/#sec-numeric-types-bigint-divide
+  return x / y;
+}
+
+export function truncate(x: number) {
+  const xd = Math.trunc(x);
+  if (Object.is(xd, -0)) return 0;
+  return xd;
+}
+
+/** https://tc39.es/ecma262/#eqn-floor */
+export function floorDiv(x: bigint, y: bigint): bigint {
+  // Return floor(x / y) (round toward -infinity).
+  const q = x / y; // truncating division toward 0
+  if (x % y !== 0n && ((x < 0n) !== (y < 0n))) {
+    return q - 1n;
+  }
+  return q;
+}
+
+/** https://tc39.es/ecma262/#eqn-abs */
+export function abs(x: number): number
+export function abs(x: bigint): bigint
+export function abs(x: bigint | number): bigint | number
+export function abs(x: bigint | number): bigint | number {
+  if (x < 0) {
+    return -x;
+  }
+  return x;
+}
+
+/** https://tc39.es/ecma262/#clamping */
+export function clamp<T extends bigint>(lower: T, x: T, upper: T): T
+export function clamp(lower: number, x: number, upper: number): number
+export function clamp(lower: number | bigint, x: number | bigint, upper: number | bigint): number | bigint {
+  if (x < lower) return lower;
+  if (x > upper) return upper;
+  return x;
+}
+
+/** https://tc39.es/ecma262/#eqn-min */
+export function min(x: bigint, y: bigint): bigint {
+  return x < y ? x : y;
+}
+
+/** https://tc39.es/ecma262/#eqn-max */
+export function max(x: bigint, y: bigint): bigint {
+  return x > y ? x : y;
+}
+
+/** https://tc39.es/ecma262/#eqn-modulo */
+export function modulo(x: bigint, y: bigint): bigint
+export function modulo(x: number, y: number): number
+export function modulo(x: number | bigint, y: number | bigint): number | bigint {
+  // (x % y + y) % y
+  return (((x as bigint) % (y as bigint)) + (y as bigint)) % (y as bigint);
+}
+
+/** https://tc39.es/ecma262/#eqn-remainder */
+export function remainder(x: bigint, y: bigint): bigint
+export function remainder(x: number, y: number): number
+export function remainder(x: number | bigint, y: number | bigint): number | bigint {
+  if (typeof x === 'bigint' && typeof y === 'bigint') {
+    return (x >= 0 ? modulo(abs(x), y) : -modulo(abs(x), y));
+  } else if (typeof x === 'number' && typeof y === 'number') {
+    return (x >= 0 ? modulo(Math.abs(x), y) : -modulo(Math.abs(x), y));
+  } else {
+    throw new TypeError('Mismatched types for remainder operation');
+  }
+}