@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

package/src/intrinsics/FunctionPrototype.mts

@@ -0,0 +1,272 @@
+import {
+  surroundingAgent,
+  HostHasSourceTextAvailable,
+} from '../engine.mts';
+import {
+  Assert,
+  Call,
+  Construct,
+  CreateListFromArrayLike,
+  Get,
+  HasOwnProperty,
+  IsCallable,
+  IsConstructor,
+  OrdinaryHasInstance,
+  PrepareForTailCall,
+  SameValue,
+  SetFunctionLength,
+  SetFunctionName,
+  ToIntegerOrInfinity,
+  CreateBuiltinFunction,
+  MakeBasicObject, R,
+  Realm,
+  type ExoticObject,
+  type FunctionObject,
+  isBuiltinFunctionObject,
+  type BuiltinFunctionObject,
+  isECMAScriptFunctionObject,
+} from '../abstract-ops/all.mts';
+import {
+  JSStringValue,
+  NumberValue,
+  ObjectValue,
+  UndefinedValue,
+  Value,
+  wellKnownSymbols,
+  type Arguments,
+  type FunctionCallContext,
+} from '../value.mts';
+import { Q, X, type ExpressionCompletion } from '../completion.mts';
+import { __ts_cast__, type Mutable } from '../helpers.mts';
+import { assignProps } from './bootstrap.mts';
+
+export interface BoundFunctionObject extends ExoticObject, BuiltinFunctionObject {
+  readonly BoundTargetFunction: FunctionObject;
+  readonly BoundThis: Value;
+  readonly BoundArguments: Arguments;
+}
+
+export function isBoundFunctionObject(object: object): object is BoundFunctionObject {
+  return 'BoundTargetFunction' in object;
+}
+
+/** https://tc39.es/ecma262/#sec-properties-of-the-function-prototype-object */
+function FunctionProto() {
+  // * accepts any arguments and returns undefined when invoked.
+  return Value.undefined;
+}
+
+/** https://tc39.es/ecma262/#sec-function.prototype.apply */
+function FunctionProto_apply([thisArg = Value.undefined, argArray = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let func be the this value.
+  const func = thisValue;
+  // 2. If IsCallable(func) is false, throw a TypeError exception.
+  if (IsCallable(func) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'ThisNotAFunction', func);
+  }
+  // 3. If argArray is undefined or null, then
+  if (argArray === Value.undefined || argArray === Value.null) {
+    // a. Perform PrepareForTailCall().
+    PrepareForTailCall();
+    // b. Return ? Call(func, thisArg).
+    return Q(Call(func, thisArg));
+  }
+  // 4. Let argList be ? CreateListFromArrayLike(argArray).
+  const argList = Q(CreateListFromArrayLike(argArray));
+  // 5. Perform PrepareForTailCall().
+  PrepareForTailCall();
+  // 6. Return ? Call(func, thisArg, argList).
+  return Q(Call(func, thisArg, argList));
+}
+
+function BoundFunctionExoticObjectCall(this: BoundFunctionObject, _thisArgument: ObjectValue, argumentsList: Arguments): ExpressionCompletion {
+  const F = this;
+
+  const target = F.BoundTargetFunction;
+  const boundThis = F.BoundThis;
+  const boundArgs = F.BoundArguments;
+  const args = [...boundArgs, ...argumentsList];
+  return Q(Call(target, boundThis, args));
+}
+
+function BoundFunctionExoticObjectConstruct(this: BoundFunctionObject, argumentsList: Arguments, newTarget: FunctionObject | UndefinedValue): ExpressionCompletion<ObjectValue> {
+  const F = this;
+
+  const target = F.BoundTargetFunction;
+  Assert(IsConstructor(target) === Value.true);
+  const boundArgs = F.BoundArguments;
+  const args = [...boundArgs, ...argumentsList];
+  if (SameValue(F, newTarget) === Value.true) {
+    newTarget = target;
+  }
+  return Q(Construct(target, args, newTarget));
+}
+
+/** https://tc39.es/ecma262/#sec-boundfunctioncreate */
+function BoundFunctionCreate(targetFunction: ObjectValue, boundThis: Value, boundArgs: Arguments): ExpressionCompletion<BoundFunctionObject> {
+  // 1. Assert: Type(targetFunction) is Object.
+  Assert(targetFunction instanceof ObjectValue);
+  // 2. Let proto be ? targetFunction.[[GetPrototypeOf]]().
+  const proto = Q(targetFunction.GetPrototypeOf());
+  // 3. Let internalSlotsList be the internal slots listed in Table 30, plus [[Prototype]] and [[Extensible]].
+  const internalSlotsList = [
+    'BoundTargetFunction',
+    'BoundThis',
+    'BoundArguments',
+    'Prototype',
+    'Extensible',
+  ];
+  // 4. Let obj be ! MakeBasicObject(internalSlotsList).
+  const obj = X(MakeBasicObject(internalSlotsList)) as Mutable<BoundFunctionObject>;
+  // 5. Set obj.[[Prototype]] to proto.
+  obj.Prototype = proto;
+  // 6. Set obj.[[Call]] as described in 9.4.1.1.
+  obj.Call = BoundFunctionExoticObjectCall;
+  // 7. If IsConstructor(targetFunction) is true, then
+  if (IsConstructor(targetFunction) === Value.true) {
+    // a. Set obj.[[Construct]] as described in 9.4.1.2.
+    obj.Construct = BoundFunctionExoticObjectConstruct;
+  }
+  // 8. Set obj.[[BoundTargetFunction]] to targetFunction.
+  obj.BoundTargetFunction = targetFunction as FunctionObject;
+  // 9. Set obj.[[BoundThis]] to boundThis.
+  obj.BoundThis = boundThis;
+  // 10. Set obj.[[BoundArguments]] to boundArguments.
+  obj.BoundArguments = boundArgs;
+  // 11. Return obj.
+  return obj;
+}
+
+/** https://tc39.es/ecma262/#sec-function.prototype.bind */
+function FunctionProto_bind([thisArg = Value.undefined, ...args]: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let Target be the this value.
+  const Target = thisValue;
+  // 2. If IsCallable(Target) is false, throw a TypeError exception.
+  if (IsCallable(Target) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'ThisNotAFunction', Target);
+  }
+  __ts_cast__<ObjectValue>(Target);
+  // 3. Let F be ? BoundFunctionCreate(Target, thisArg, args).
+  const F = Q(BoundFunctionCreate(Target, thisArg, args));
+  // 4. Let L be 0.
+  let L = 0;
+  // 5. Let targetHasLength be ? HasOwnProperty(Target, "length").
+  const targetHasLength = Q(HasOwnProperty(Target, Value('length')));
+  // 6. If targetHasLength is true, then
+  if (targetHasLength === Value.true) {
+    // a. Let targetLen be ? Get(Target, "length").
+    const targetLen = Q(Get(Target, Value('length')));
+    // b. If Type(targetLen) is Number, then
+    if (targetLen instanceof NumberValue) {
+      // i. If targetLen is +∞𝔽, set L to +∞.
+      if (R(targetLen) === +Infinity) {
+        L = +Infinity;
+      } else if (R(targetLen) === -Infinity) { // ii. Else if targetLen is -∞𝔽, set L to 0.
+        L = 0;
+      } else { // iii. Else,
+        // 1. Set targetLen to ! ToIntegerOrInfinity(targetLen).
+        const targetLenAsInt = Q(ToIntegerOrInfinity(targetLen));
+        // 2. Assert: targetLenAsInt is finite.
+        Assert(Number.isFinite(targetLenAsInt));
+        // 3. Let argCount be the number of elements in args.
+        const argCount = args.length;
+        // 4. Set L to max(targetLenAsInt - argCount, 0).
+        L = Math.max(targetLenAsInt - argCount, 0);
+      }
+    }
+  }
+  // 7. Perform ! SetFunctionLength(F, L).
+  X(SetFunctionLength(F, L));
+  // 8. Let targetName be ? Get(Target, "name").
+  let targetName = Q(Get(Target, Value('name')));
+  // 9. If Type(targetName) is not String, set targetName to the empty String.
+  if (!(targetName instanceof JSStringValue)) {
+    targetName = Value('');
+  }
+  // 10. Perform SetFunctionName(F, targetName, "bound").
+  SetFunctionName(F, targetName, Value('bound'));
+  // 11. Return F.
+  return F;
+}
+
+/** https://tc39.es/ecma262/#sec-function.prototype.call */
+function FunctionProto_call([thisArg = Value.undefined, ...args]: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let func be the this value.
+  const func = thisValue;
+  // 2. If IsCallable(func) is false, throw a TypeError exception.
+  if (IsCallable(func) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'ThisNotAFunction', func);
+  }
+  // 3. Let argList be a new empty List.
+  const argList = [];
+  // 4. If this method was called with more than one argument, then in left to right order, starting with the second argument, append each argument as the last element of argList.
+  for (const arg of args) {
+    argList.push(arg);
+  }
+  // 5. Perform PrepareForTailCall().
+  PrepareForTailCall();
+  // 6. Return ? Call(func, thisArg, argList).
+  return Q(Call(func, thisArg, argList));
+}
+
+/** https://tc39.es/ecma262/#sec-function.prototype.tostring */
+function FunctionProto_toString(_args: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let func be the this value.
+  const func = thisValue;
+  // 2. If Type(func) is Object and func has a [[SourceText]] internal slot and func.[[SourceText]]
+  //    is a sequence of Unicode code points and ! HostHasSourceTextAvailable(func) is true, then
+  if (isECMAScriptFunctionObject(func)
+    && X(HostHasSourceTextAvailable(func)) === Value.true) {
+    // Return ! UTF16Encode(func.[[SourceText]]).
+    return Value(func.SourceText);
+  }
+  // 3. If func is a built-in function object, then return an implementation-defined
+  //    String source code representation of func. The representation must have the
+  //    syntax of a NativeFunction. Additionally, if func has an [[InitialName]] internal
+  //    slot and func.[[InitialName]] is a String, the portion of the returned String
+  //    that would be matched by `NativeFunctionAccessor? PropertyName` must be the
+  //    value of func.[[InitialName]].
+  if (isBuiltinFunctionObject(func)) {
+    if (func.InitialName instanceof JSStringValue) {
+      return Value(`function ${func.InitialName.stringValue()}() { [native code] }`);
+    }
+    return Value('function() { [native code] }');
+  }
+  // 4. If Type(func) is Object and IsCallable(func) is true, then return an implementation
+  //    dependent String source code representation of func. The representation must have
+  //    the syntax of a NativeFunction.
+  if (func instanceof ObjectValue && IsCallable(func) === Value.true) {
+    return Value('function() { [native code] }');
+  }
+  // 5. Throw a TypeError exception.
+  return surroundingAgent.Throw('TypeError', 'NotAFunction', func);
+}
+
+/** https://tc39.es/ecma262/#sec-function.prototype-@@hasinstance */
+function FunctionProto_hasInstance([V = Value.undefined]: Arguments, { thisValue }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let F be this value.
+  const F = thisValue;
+  // 2. Return ? OrdinaryHasInstance(F, V).
+  return Q(OrdinaryHasInstance(F, V));
+}
+
+export function bootstrapFunctionPrototype(realmRec: Realm) {
+  const proto = CreateBuiltinFunction(
+    FunctionProto,
+    0,
+    Value(''),
+    [],
+    realmRec,
+    realmRec.Intrinsics['%Object.prototype%'],
+  );
+  realmRec.Intrinsics['%Function.prototype%'] = proto;
+
+  const readonly = { Writable: Value.false, Configurable: Value.false };
+  assignProps(realmRec, proto, [
+    ['apply', FunctionProto_apply, 2],
+    ['bind', FunctionProto_bind, 1],
+    ['call', FunctionProto_call, 1],
+    ['toString', FunctionProto_toString, 0],
+    [wellKnownSymbols.hasInstance, FunctionProto_hasInstance, 1, readonly],
+  ]);
+}

package/src/intrinsics/GeneratorFunction.mts

@@ -0,0 +1,32 @@
+import { surroundingAgent } from '../engine.mts';
+import {
+  Descriptor, Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { DefinePropertyOrThrow, Realm, type FunctionObject } from '../abstract-ops/all.mts';
+import { Q, X, type ExpressionCompletion } from '../completion.mts';
+import { CreateDynamicFunction } from '../runtime-semantics/all.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+
+/** https://tc39.es/ecma262/#sec-generatorfunction */
+function GeneratorFunctionConstructor(args: Arguments, { NewTarget }: FunctionCallContext): ExpressionCompletion {
+  // 1. Let C be the active function object.
+  const C = surroundingAgent.activeFunctionObject as FunctionObject;
+  // 2. Let args be the argumentsList that was passed to this function by [[Call]] or [[Construct]].
+  // 3. Return ? CreateDynamicFunction(C, NewTarget, generator, args).
+  return Q(CreateDynamicFunction(C, NewTarget, 'generator', args));
+}
+
+export function bootstrapGeneratorFunction(realmRec: Realm) {
+  const generator = realmRec.Intrinsics['%GeneratorFunction.prototype%'];
+
+  const cons = bootstrapConstructor(realmRec, GeneratorFunctionConstructor, 'GeneratorFunction', 1, generator, []);
+  X(DefinePropertyOrThrow(cons, Value('prototype'), Descriptor({
+    Writable: Value.false,
+    Configurable: Value.false,
+  })));
+  X(DefinePropertyOrThrow(generator, Value('constructor'), Descriptor({
+    Writable: Value.false,
+  })));
+
+  realmRec.Intrinsics['%GeneratorFunction%'] = cons;
+}

package/src/intrinsics/GeneratorFunctionPrototype.mts

@@ -0,0 +1,21 @@
+import { Descriptor, Value } from '../value.mts';
+import { DefinePropertyOrThrow, Realm } from '../abstract-ops/all.mts';
+import { X } from '../completion.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+
+export function bootstrapGeneratorFunctionPrototype(realmRec: Realm) {
+  const generatorPrototype = realmRec.Intrinsics['%GeneratorFunction.prototype.prototype%'];
+
+  const generator = bootstrapPrototype(realmRec, [
+    ['prototype', generatorPrototype, undefined, { Writable: Value.false }],
+  ], realmRec.Intrinsics['%Function.prototype%'], 'GeneratorFunction');
+
+  X(DefinePropertyOrThrow(generatorPrototype, Value('constructor'), Descriptor({
+    Value: generator,
+    Writable: Value.false,
+    Enumerable: Value.false,
+    Configurable: Value.true,
+  })));
+
+  realmRec.Intrinsics['%GeneratorFunction.prototype%'] = generator;
+}

package/src/intrinsics/GeneratorFunctionPrototypePrototype.mts

@@ -0,0 +1,57 @@
+import {
+  GeneratorResume,
+  GeneratorResumeAbrupt,
+  Realm,
+  type FunctionObject,
+} from '../abstract-ops/all.mts';
+import {
+  Completion,
+  ThrowCompletion,
+  Q,
+  X,
+} from '../completion.mts';
+import {
+  Value, type Arguments, type FunctionCallContext,
+} from '../value.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+
+/** https://tc39.es/ecma262/#sec-generator.prototype.next */
+function GeneratorProto_next([value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Let g be the this value.
+  const g = thisValue;
+  // 2. Return ? GeneratorResume(g, value, empty).
+  return Q(GeneratorResume(g, value, undefined));
+}
+
+/** https://tc39.es/ecma262/#sec-generator.prototype.return */
+function GeneratorProto_return([value = Value.undefined]: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Let g be the this value.
+  const g = thisValue;
+  // 2. Let C be Completion { [[Type]]: return, [[Value]]: value, [[Target]]: empty }.
+  const C = new Completion({ Type: 'return', Value: value, Target: undefined });
+  // 3. Return ? GeneratorResumeAbrupt(g, C, empty).
+  return Q(GeneratorResumeAbrupt(g, C, undefined));
+}
+
+/** https://tc39.es/ecma262/#sec-generator.prototype.throw */
+function GeneratorProto_throw([exception = Value.undefined]: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Let g be the this value.
+  const g = thisValue;
+  // 2. Let C be ThrowCompletion(exception).
+  const C = ThrowCompletion(exception);
+  // 3. Return ? GeneratorResumeAbrupt(g, C, empty).
+  return Q(GeneratorResumeAbrupt(g, C, undefined));
+}
+
+export function bootstrapGeneratorFunctionPrototypePrototype(realmRec: Realm) {
+  const generatorPrototype = bootstrapPrototype(realmRec, [
+    ['next', GeneratorProto_next, 1],
+    ['return', GeneratorProto_return, 1],
+    ['throw', GeneratorProto_throw, 1],
+  ], realmRec.Intrinsics['%IteratorPrototype%'], 'Generator');
+
+  realmRec.Intrinsics['%GeneratorFunction.prototype.prototype%'] = generatorPrototype;
+
+  // Used by `CreateListIteratorRecord`:
+  realmRec.Intrinsics['%GeneratorFunction.prototype.prototype.next%'] = X(generatorPrototype.Get(Value('next'), generatorPrototype)) as FunctionObject;
+}

package/src/intrinsics/IteratorPrototype.mts

@@ -0,0 +1,17 @@
+import { wellKnownSymbols } from '../value.mts';
+import { bootstrapPrototype } from './bootstrap.mts';
+import type { Arguments, FunctionCallContext, Realm } from '#self';
+
+/** https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator */
+function IteratorPrototype_iterator(_args: Arguments, { thisValue }: FunctionCallContext) {
+  // 1. Return this value.
+  return thisValue;
+}
+
+export function bootstrapIteratorPrototype(realmRec: Realm) {
+  const proto = bootstrapPrototype(realmRec, [
+    [wellKnownSymbols.iterator, IteratorPrototype_iterator, 0],
+  ], realmRec.Intrinsics['%Object.prototype%']);
+
+  realmRec.Intrinsics['%IteratorPrototype%'] = proto;
+}