@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/intrinsics/Map.mts

@@ -0,0 +1,129 @@
+import {
+  ObjectValue,
+  UndefinedValue,
+  Value,
+  wellKnownSymbols,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import {
+  IfAbruptCloseIterator,
+  Q,
+  X,
+  type ValueEvaluator,
+} from '../completion.mts';
+import { __ts_cast__, type Mutable } from '../utils/language.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import { surroundingAgent } from '#self';
+import {
+  Assert,
+  Call,
+  Construct,
+  CreateArrayFromList,
+  Get,
+  GetIterator,
+  GroupBy,
+  IsCallable,
+  IteratorClose,
+  IteratorStepValue,
+  OrdinaryCreateFromConstructor,
+  Realm,
+  Throw,
+  type FunctionObject,
+  type KeyedGroupRecord,
+  type OrdinaryObject,
+} from '#self';
+
+export function* AddEntriesFromIterable(target: ObjectValue, iterable: Value, adder: FunctionObject): ValueEvaluator {
+  Assert(iterable !== Value.undefined && iterable !== Value.null);
+  const iteratorRecord = Q(yield* GetIterator(iterable, 'sync'));
+  while (true) {
+    const next = Q(yield* IteratorStepValue(iteratorRecord));
+    if (next === 'done') {
+      return target;
+    }
+    if (!(next instanceof ObjectValue)) {
+      const error = Throw.TypeError('$1 is not an object', next);
+      return Q(yield* IteratorClose(iteratorRecord, error));
+    }
+    // e. Let k be Get(nextItem, "0").
+    const k = yield* Get(next, Value('0'));
+    // f. IfAbruptCloseIterator(k, iteratorRecord).
+    IfAbruptCloseIterator(k, iteratorRecord);
+    __ts_cast__<Value>(k);
+    // g. Let v be Get(nextItem, "1").
+    const v = yield* Get(next, Value('1'));
+    // h. IfAbruptCloseIterator(v, iteratorRecord).
+    IfAbruptCloseIterator(v, iteratorRecord);
+    __ts_cast__<Value>(v);
+    // i. Let status be Call(adder, target, « k, v »).
+    const status = yield* Call(adder, target, [k, v]);
+    // j. IfAbruptCloseIterator(status, iteratorRecord).
+    IfAbruptCloseIterator(status, iteratorRecord);
+  }
+}
+
+export interface MapObject extends OrdinaryObject {
+  readonly MapData: { Key: Value | undefined, Value: Value | undefined }[];
+}
+export function isMapObject(value: Value): value is MapObject {
+  return 'MapData' in value;
+}
+/** https://tc39.es/ecma262/#sec-map-iterable */
+function* MapConstructor(this: FunctionObject, [iterable = Value.undefined]: Arguments, { NewTarget }: FunctionCallContext) {
+  // 1. If NewTarget is undefined, throw a TypeError exception.
+  if (NewTarget instanceof UndefinedValue) {
+    return Throw.TypeError('Map cannot be invoked without new');
+  }
+  // 2. Let map be ? OrdinaryCreateFromConstructor(NewTarget, "%Map.prototype%", « [[MapData]] »).
+  const map = Q(yield* OrdinaryCreateFromConstructor(NewTarget, '%Map.prototype%', ['MapData'])) as Mutable<MapObject>;
+  // 3. Set map.[[MapData]] to a new empty List.
+  map.MapData = [];
+  // 4. If iterable is either undefined or null, return map.
+  if (iterable === Value.undefined || iterable === Value.null) {
+    return map;
+  }
+  // 5. Let adder be ? Get(map, "set").
+  const adder = Q(yield* Get(map, Value('set')));
+  if (!IsCallable(adder)) {
+    return Throw.TypeError('$1 is not a function', adder);
+  }
+  // 6. Return ? AddEntriesFromIterable(map, iterable, adder).
+  return Q(yield* AddEntriesFromIterable(map, iterable, adder));
+}
+
+/** https://tc39.es/ecma262/#sec-map.groupby */
+function* Map_groupBy([items = Value.undefined, callback = Value.undefined]: Arguments): ValueEvaluator {
+  /*
+  1. Let groups be ? GroupBy(items, callback, collection).
+  2. Let map be ! Construct(%Map%).
+  3. For each Record { [[Key]], [[Elements]] } g of groups, do
+    a. Let elements be CreateArrayFromList(g.[[Elements]]).
+    b. Let entry be the Record { [[Key]]: g.[[Key]], [[Value]]: elements }.
+    c. Append entry to map.[[MapData]].
+  4. Return map.
+  */
+  const groups: KeyedGroupRecord[] = Q(yield* GroupBy(items, callback, 'collection'));
+  const map: MapObject = X(Construct(surroundingAgent.intrinsic('%Map%'))) as MapObject;
+  for (const g of groups) {
+    const elements = CreateArrayFromList(g.Elements);
+    const entry = { Key: g.Key, Value: elements };
+    map.MapData.push(entry);
+  }
+  return map;
+}
+
+/** https://tc39.es/ecma262/#sec-get-map-@@species */
+function Map_speciesGetter(_args: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Return the this value.
+  return thisValue;
+}
+
+export function bootstrapMap(realmRec: Realm) {
+  const mapConstructor = bootstrapConstructor(realmRec, MapConstructor, 'Map', 0, realmRec.Intrinsics['%Map.prototype%'], [
+    ['groupBy', Map_groupBy, 2],
+    [wellKnownSymbols.species, [Map_speciesGetter]],
+  ]);
+
+  realmRec.Intrinsics['%Map%'] = mapConstructor;
+}

package/src/intrinsics/MapIteratorPrototype.mts

@@ -0,0 +1,81 @@
+import { Q, X } from '../completion.mts';
+import { Value, type Arguments } from '../value.mts';
+import type { YieldEvaluator } from '../evaluator.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import {
+  surroundingAgent,
+  Assert,
+  CreateArrayFromList,
+  CreateIteratorFromClosure,
+  GeneratorResume,
+  Realm,
+  RequireInternalSlot,
+  Yield,
+} from '#self';
+import type {
+  ValueEvaluator, FunctionCallContext, GeneratorObject, MapObject,
+  ValueCompletion,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-createmapiterator */
+export function CreateMapIterator(map: Value, kind: 'key+value' | 'key' | 'value'): ValueCompletion<GeneratorObject> {
+  Assert(kind === 'key+value' || kind === 'key' || kind === 'value');
+  // 1. Perform ? RequireInternalSlot(map, [[MapData]]).
+  Q(RequireInternalSlot(map, 'MapData'));
+  // 2. Let closure be a new Abstract Closure with no parameters that captures map and kind and performs the following steps when called:
+  const closure = function* closure(): YieldEvaluator {
+    // a. Let entries be the List that is map.[[MapData]].
+    const entries = (map as MapObject).MapData;
+    // b. Let index be 0.
+    let index = 0;
+    // c. Let numEntries be the number of elements of entries.
+    let numEntries = entries.length;
+    // d. Repeat, while index < numEntries,
+    while (index < numEntries) {
+      // i. Let e be the Record { [[Key]], [[Value]] } that is the value of entries[index].
+      const e = entries[index];
+      // ii. Set index to index + 1.
+      index += 1;
+      // iii. If e.[[Key]] is not empty, then
+      if (e.Key !== undefined) {
+        let result;
+        // 1. If kind is key, let result be e.[[Key]].
+        if (kind === 'key') {
+          result = e.Key;
+        } else if (kind === 'value') { // 2. Else if kind is value, let result be e.[[Value]].
+          result = e.Value;
+        } else { // 3. Else,
+          // a. Assert: kind is key+value.
+          Assert(kind === 'key+value');
+          // b. Let result be ! CreateArrayFromList(« e.[[Key]], e.[[Value]] »).
+          result = X(CreateArrayFromList([e.Key, e.Value!]));
+        }
+        // 4. Perform ? Yield(result).
+        Q(yield* Yield(result!));
+      }
+      // iv. Set numEntries to the number of elements of entries.
+      numEntries = entries.length;
+    }
+    // NON-SPEC
+    generator.HostCapturedValues = undefined;
+    // e. Return undefined.
+    return Value.undefined;
+  };
+  // 3. Return ! CreateIteratorFromClosure(closure, "%MapIteratorPrototype%", %MapIteratorPrototype%).
+  const generator = X(CreateIteratorFromClosure(closure, Value('%MapIteratorPrototype%'), surroundingAgent.intrinsic('%MapIteratorPrototype%'), ['HostCapturedValues'], [map]));
+  return generator;
+}
+
+/** https://tc39.es/ecma262/#sec-%mapiteratorprototype%.next */
+function* MapIteratorPrototype_next(_args: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Return ? GeneratorResume(this value, empty, "%MapIteratorPrototype%")
+  return Q(yield* GeneratorResume(thisValue, undefined, Value('%MapIteratorPrototype%')));
+}
+
+export function bootstrapMapIteratorPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['next', MapIteratorPrototype_next, 0],
+  ], realmRec.Intrinsics['%Iterator.prototype%'], 'Map Iterator');
+
+  realmRec.Intrinsics['%MapIteratorPrototype%'] = proto;
+}

package/src/intrinsics/MapPrototype.mts

@@ -0,0 +1,295 @@
+import {
+  NumberValue,
+  Value,
+  wellKnownSymbols,
+} from '../value.mts';
+import { Q, X } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import { CreateMapIterator } from './MapIteratorPrototype.mts';
+import type { MapObject } from './Map.mts';
+import {
+  surroundingAgent,
+  Call,
+  CanonicalizeKeyedCollectionKey,
+  F,
+  IsCallable,
+  RequireInternalSlot,
+  SameValue, SameValueZero, Throw,
+} from '#self';
+import type {
+  Arguments, Descriptor, ValueEvaluator, FunctionCallContext, Realm,
+  ValueCompletion,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-map.prototype.clear */
+function MapProto_clear(_args: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue as MapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[MapData]]).
+  Q(RequireInternalSlot(M, 'MapData'));
+  // 3. Let entries be the List that is M.[[MapData]].
+  const entries = M.MapData;
+  // 4. For each Record { [[Key]], [[Value]] } p that is an element of entries, do
+  if (entries.length) {
+    Q(surroundingAgent.debugger_tryTouchDuringPreview(M));
+  }
+  for (const p of entries) {
+    // a. Set p.[[Key]] to empty.
+    p.Key = undefined;
+    // b. Set p.[[Value]] to empty.
+    p.Value = undefined;
+  }
+  // 5. Return undefined.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-map.prototype.delete */
+function MapProto_delete([key = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue as MapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[MapData]]).
+  Q(RequireInternalSlot(M, 'MapData'));
+  // 3. Let entires be M.[[MapData]].
+  const entries = M.MapData;
+  // 4. For each Record { [[Key]], [[Value]] } p that is an element of entries, do
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty and SameValueZero(p.[[Key]], key) is true, then
+    if (p.Key !== undefined && SameValueZero(p.Key, key)) {
+      Q(surroundingAgent.debugger_tryTouchDuringPreview(M));
+      // i. Set p.[[Key]] to empty.
+      p.Key = undefined;
+      // ii. Set p.[[Value]] to empty.
+      p.Value = undefined;
+      // iii. Return true.
+      return Value.true;
+    }
+  }
+  return Value.false;
+}
+
+/** https://tc39.es/ecma262/#sec-map.prototype.entries */
+function MapProto_entries(_args: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue;
+  // 2. Return ? CreateMapIterator(M, key+value);
+  return Q(CreateMapIterator(M, 'key+value'));
+}
+
+/** https://tc39.es/ecma262/#sec-map.prototype.foreach */
+function* MapProto_forEach([callbackfn = Value.undefined, thisArg = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let M be the this value.
+  const M = thisValue as MapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[MapData]]).
+  Q(RequireInternalSlot(M, 'MapData'));
+  // 3. If IsCallable(callbackfn) is false, throw a TypeError exception.
+  if (!IsCallable(callbackfn)) {
+    return Throw.TypeError('$1 is not a function', callbackfn);
+  }
+  // 4. Let entries be the List that is M.[[MapData]].
+  const entries = M.MapData;
+  // 5. For each Record { [[Key]], [[Value]] } e that is an element of entries, in original key insertion order, do
+  for (const e of entries) {
+    // a. If e.[[Key]] is not empty, then
+    if (e.Key !== undefined) {
+      // i. Perform ? Call(callbackfn, thisArg, « e.[[Value]], e.[[Key]], M »).
+      Q(yield* Call(callbackfn, thisArg, [e.Value!, e.Key, M]));
+    }
+  }
+  // 6. Return undefined.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-map.prototype.get */
+function MapProto_get([key = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue as MapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[MapData]]).
+  Q(RequireInternalSlot(M, 'MapData'));
+  // 3. Let entries be the List that is M.[[MapData]].
+  const entries = M.MapData;
+  // 4. For each Record { [[Key]], [[Value]] } p that is an element of entries, do
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty and SameValueZero(p.[[Key]], key) is true, return p.[[Value]].
+    if (p.Key !== undefined && SameValueZero(p.Key, key)) {
+      // i. Return p.[[Value]].
+      return p.Value!;
+    }
+  }
+  // 5. Return undefined.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-map.prototype.getorinsert */
+function MapProto_getOrInsert([key = Value.undefined, value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue as MapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[MapData]]).
+  Q(RequireInternalSlot(M, 'MapData'));
+  // 3. Set key to CanonicalizeKeyedCollectionKey(key).
+  key = CanonicalizeKeyedCollectionKey(key);
+  // 4. For each Record { [[Key]], [[Value]] } p of M.[[MapData]], do
+  const entries = M.MapData;
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, return p.[[Value]].
+    if (p.Key !== undefined && SameValue(p.Key, key)) {
+      return p.Value!;
+    }
+  }
+  // 5. Let p be the Record { [[Key]]: key, [[Value]]: value }.
+  const p = { Key: key, Value: value };
+  // 6. Append p to M.[[MapData]].
+  entries.push(p);
+  // 7. Return value.
+  return value;
+}
+
+/** https://tc39.es/ecma262/#sec-map.prototype.getorinsertcomputed */
+function* MapProto_getOrInsertComputed([key = Value.undefined, callbackfn = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueEvaluator {
+  // 1. Let M be the this value.
+  const M = thisValue as MapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[MapData]]).
+  Q(RequireInternalSlot(M, 'MapData'));
+  // 3. If IsCallable(callbackfn) is false, throw a TypeError exception.
+  if (!IsCallable(callbackfn)) {
+    return Throw.TypeError('$1 is not a function', callbackfn);
+  }
+  // 4. Set key to CanonicalizeKeyedCollectionKey(key).
+  key = CanonicalizeKeyedCollectionKey(key);
+  // 5. For each Record { [[Key]], [[Value]] } p of M.[[MapData]], do
+  const entries = M.MapData;
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, return p.[[Value]].
+    if (p.Key !== undefined && SameValueZero(p.Key, key)) {
+      return p.Value!;
+    }
+  }
+  // 6. Let value be ? Call(callbackfn, undefined, « key »).
+  const value = Q(yield* Call(callbackfn, Value.undefined, [key]));
+  // 7. NOTE: The Map may have been modified during execution of callbackfn.
+  // 8. For each Record { [[Key]], [[Value]] } p of M.[[MapData]], do
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, then
+    if (p.Key !== undefined && SameValueZero(p.Key, key)) {
+      // i. Set p.[[Value]] to value.
+      p.Value = value;
+      // ii. Return value.
+      return value;
+    }
+  }
+  // 9. Let p be the Record { [[Key]]: key, [[Value]]: value }.
+  const p = { Key: key, Value: value };
+  // 10. Append p to M.[[MapData]].
+  entries.push(p);
+  // 11. Return value.
+  return value;
+}
+
+/** https://tc39.es/ecma262/#sec-map.prototype.has */
+function MapProto_has([key = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue as MapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[MapData]]).
+  Q(RequireInternalSlot(M, 'MapData'));
+  // 3. Let entries be the List that is M.[[MapData]].
+  const entries = M.MapData;
+  // 4. For each Record { [[Key]], [[Value]] } p that is an element of entries, do
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty and SameValueZero(p.[[Key]], key) is true, return true.
+    if (p.Key !== undefined && SameValueZero(p.Key, key)) {
+      return Value.true;
+    }
+  }
+  // 5. Return false.
+  return Value.false;
+}
+
+/** https://tc39.es/ecma262/#sec-map.prototype.keys */
+function MapProto_keys(_args: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue;
+  // 2. Return ? CreateMapIterator(M, key).
+  return Q(CreateMapIterator(M, 'key'));
+}
+
+/** https://tc39.es/ecma262/#sec-map.prototype.set */
+function MapProto_set([key = Value.undefined, value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue as MapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[MapData]]).
+  Q(RequireInternalSlot(M, 'MapData'));
+  // 3. Let entries be the List that is M.[[MapData]].
+  const entries = M.MapData;
+  // 4. For each Record { [[Key]], [[Value]] } p that is an element of entries, do
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty and SameValueZero(p.[[Key]], key) is true, then
+    if (p.Key !== undefined && SameValueZero(p.Key, key)) {
+      // i. Set p.[[Value]] to value.
+      Q(surroundingAgent.debugger_tryTouchDuringPreview(M));
+      p.Value = value;
+      // ii. Return M.
+      return M;
+    }
+  }
+  // 5. If key is -0𝔽, set key to +0𝔽.
+  if (key instanceof NumberValue && Object.is(key.value, -0)) {
+    key = F(+0);
+  }
+  // 6. Let p be the Record { [[Key]]: key, [[Value]]: value }.
+  const p = { Key: key, Value: value };
+  // 7. Append p as the last element of entries.
+  Q(surroundingAgent.debugger_tryTouchDuringPreview(M));
+  entries.push(p);
+  // 8. Return M.
+  return M;
+}
+
+/** https://tc39.es/ecma262/#sec-get-map.prototype.size */
+function MapProto_sizeGetter(_args: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue as MapObject;
+  // 2. Perform ? RequireInternalSlot(M, [[MapData]]).
+  Q(RequireInternalSlot(M, 'MapData'));
+  // 3. Let entries be the List that is M.[[MapData]].
+  const entries = M.MapData;
+  // 4. Let count be 0.
+  let count = 0;
+  // 5. For each Record { [[Key]], [[Value]] } p that is an element of entries, do
+  for (const p of entries) {
+    // a. If p.[[Key]] is not empty, set count to count + 1.
+    if (p.Key !== undefined) {
+      count += 1;
+    }
+  }
+  // 6. Return 𝔽(count).
+  return F(count);
+}
+
+/** https://tc39.es/ecma262/#sec-map.prototype.values */
+function MapProto_values(_args: Arguments, { thisValue }: FunctionCallContext): ValueCompletion {
+  // 1. Let M be the this value.
+  const M = thisValue;
+  // 2. Return ? CreateMapIterator(M, value).
+  return Q(CreateMapIterator(M, 'value'));
+}
+
+export function bootstrapMapPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    ['clear', MapProto_clear, 0],
+    ['delete', MapProto_delete, 1],
+    ['entries', MapProto_entries, 0],
+    ['forEach', MapProto_forEach, 1],
+    ['get', MapProto_get, 1],
+    ['getOrInsert', MapProto_getOrInsert, 2],
+    ['getOrInsertComputed', MapProto_getOrInsertComputed, 2],
+    ['has', MapProto_has, 1],
+    ['keys', MapProto_keys, 0],
+    ['set', MapProto_set, 2],
+    ['size', [MapProto_sizeGetter]],
+    ['values', MapProto_values, 0],
+  ], realmRec.Intrinsics['%Object.prototype%'], 'Map');
+
+  const entriesFunc = X(proto.GetOwnProperty(Value('entries')));
+  X(proto.DefineOwnProperty(wellKnownSymbols.iterator, entriesFunc as Descriptor));
+
+  realmRec.Intrinsics['%Map.prototype%'] = proto;
+}