@engine262/engine262 0.0.1-0574c6b92a2925de851f895445b7cfd7e97cc0ba

package/src/runtime-semantics/ImportCall.mts

@@ -0,0 +1,134 @@
+import { surroundingAgent, HostLoadImportedModule } from '../host-defined/engine.mts';
+import { Evaluate, type ValueEvaluator } from '../evaluator.mts';
+import {
+  GetValue,
+  ToString,
+  NewPromiseCapability,
+  GetActiveScriptOrModule,
+} from '../abstract-ops/all.mts';
+import {
+  Q, X, IfAbruptRejectPromise,
+} from '../completion.mts';
+import {
+  AbstractModuleRecord, AllImportAttributesSupported, Call, CyclicModuleRecord, EnumerableOwnProperties, Get, JSStringValue, NullValue, ObjectValue, Realm, Value, type ModuleRequestRecord, type PromiseObject, type ScriptRecord,
+} from '../index.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { __ts_cast__ } from '../helpers.mts';
+
+/** https://tc39.es/ecma262/#sec-import-calls */
+// ImportCall : `import` `(` AssignmentExpression `)`
+export function* Evaluate_ImportCall(ImportCall: ParseNode.ImportCall): ValueEvaluator<PromiseObject> {
+  Q(surroundingAgent.debugger_cannotPreview);
+  return yield* EvaluateImportCall(ImportCall.AssignmentExpression, ImportCall.OptionsExpression, /* [import-defer] */ ImportCall.Phase);
+}
+
+/** https://tc39.es/ecma262/#sec-evaluate-import-call */
+function* EvaluateImportCall(
+  specifiersExpression: ParseNode.AssignmentExpressionOrHigher,
+  optionsExpression: undefined | ParseNode.AssignmentExpressionOrHigher,
+  /* [import-defer] */ phase: 'defer' | 'evaluation',
+): ValueEvaluator<PromiseObject> {
+  // 1. Let referrer be ! GetActiveScriptOrModule().
+  let referrer: NullValue | AbstractModuleRecord | ScriptRecord | Realm = X(GetActiveScriptOrModule());
+  // 2. If referrer is null, set referrer to the current Realm Record.
+  if (referrer instanceof NullValue) {
+    referrer = surroundingAgent.currentRealmRecord;
+  }
+  // 3. Let specifierRef be ? Evaluation of AssignmentExpression.
+  const specifierRef = Q(yield* Evaluate(specifiersExpression));
+  // 4. Let specifier be ? GetValue(specifierRef).
+  const specifier = Q(yield* GetValue(specifierRef));
+  let options: Value;
+  // 5. If optionsExpression is present, then
+  if (optionsExpression) {
+    // a. Let optionsRef be ? Evaluation of optionsExpression.
+    const optionsRef = Q(yield* Evaluate(optionsExpression));
+    // b. Let options be ? GetValue(optionsRef).
+    options = Q(yield* GetValue(optionsRef));
+  } else { // 6. Else,
+    // a. Let options be undefined.
+    options = Value.undefined;
+  }
+  // 7. Let promiseCapability be ! NewPromiseCapability(%Promise%).
+  const promiseCapability = X(NewPromiseCapability(surroundingAgent.intrinsic('%Promise%')));
+  // 8. Let specifierString be ToString(specifier).
+  const specifierString = yield* ToString(specifier);
+  // 9. IfAbruptRejectPromise(specifierString, promiseCapability).
+  IfAbruptRejectPromise(specifierString, promiseCapability);
+  __ts_cast__<JSStringValue>(specifierString);
+  // 10. Let attributes nw a new empty List.
+  const attributes = [];
+  // 11. If options is not undefined, then
+  if (options !== Value.undefined) {
+    // a. If options is not an Object, then
+    if (!(options instanceof ObjectValue)) {
+      // i. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »).
+      X(Call(promiseCapability.Reject, Value.undefined, [
+        surroundingAgent.Throw('TypeError', 'NotAnObject', options).Value,
+      ]));
+      // ii. Return promiseCapability.[[Promise]].
+      return promiseCapability.Promise;
+    }
+    // b. Let attributesObj be Completion(Get(options, "with")).
+    const attributesObj = yield* Get(options, Value('with'));
+    // c. IfAbruptRejectPromise(attributesObj, promiseCapability).
+    IfAbruptRejectPromise(attributesObj, promiseCapability);
+    __ts_cast__<Value>(attributesObj);
+    // d. If attributesObj is not undefined, then
+    if (attributesObj !== Value.undefined) {
+      // i. If attributesObj is not an Object, then
+      if (!(attributesObj instanceof ObjectValue)) {
+        // 1. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »).
+        X(Call(promiseCapability.Reject, Value.undefined, [
+          surroundingAgent.Throw('TypeError', 'NotAnObject', attributesObj).Value,
+        ]));
+        // 2. Return promiseCapability.[[Promise]].
+        return promiseCapability.Promise;
+      }
+      // ii. Let entries be Completion(EnumerableOwnProperties(attributesObj, key+value)).
+      const entries = yield* EnumerableOwnProperties(attributesObj, 'key+value');
+      // iii. IfAbruptRejectPromise(entries, promiseCapability).
+      IfAbruptRejectPromise(entries, promiseCapability);
+      __ts_cast__<ObjectValue[]>(entries);
+      // iv. For each element entry of entries, do
+      for (const entry of entries) {
+        // 1. Let key be ! Get(entry, "0").
+        const key = Q(yield* Get(entry, Value('0')));
+        // 2. Let value be ! Get(entry, "1").
+        const value = Q(yield* Get(entry, Value('1')));
+        // 3. If key is a String, then
+        if (key instanceof JSStringValue) {
+          // a. If value is not a String, then
+          if (!(value instanceof JSStringValue)) {
+            // i. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »).
+            X(Call(promiseCapability.Reject, Value.undefined, [
+              surroundingAgent.Throw('TypeError', 'NotAString', value).Value,
+            ]));
+            // ii. Return promiseCapability.[[Promise]].
+            return promiseCapability.Promise;
+          }
+          // b. Append the ImportAttribute Record { [[Key]]: key, [[Value]]: value } to attributes.
+          attributes.push({ Key: key, Value: value });
+        }
+      }
+      // e. If AllImportAttributesSupported(attributes) is false, then
+      const unsupportedAttributeKey = AllImportAttributesSupported(attributes);
+      if (unsupportedAttributeKey) {
+        // i. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »).
+        X(Call(promiseCapability.Reject, Value.undefined, [
+          surroundingAgent.Throw('TypeError', 'UnsupportedImportAttribute', unsupportedAttributeKey).Value,
+        ]));
+        // ii. Return promiseCapability.[[Promise]].
+        return promiseCapability.Promise;
+      }
+      // f. Sort attributes according to the lexicographic order of their [[Key]] field, treating the value of each such field as a sequence of UTF-16 code unit values.
+      attributes.sort((a, b) => (a.Key.value < b.Key.value ? -1 : 1));
+    }
+  }
+  // 12. Let moduleRequest be a new ModuleRequest Record { [[Specifier]]: specifierString, [[Attributes]]: attributes }.
+  const moduleRequest: ModuleRequestRecord = { Specifier: specifierString, Attributes: attributes, /* [import-defer] */ Phase: phase };
+  // 10. Perform HostLoadImportedModule(referrer, specifierString, ~empty~, promiseCapability).
+  HostLoadImportedModule(referrer as CyclicModuleRecord | ScriptRecord | Realm, moduleRequest, undefined, promiseCapability);
+  // 9. Return promiseCapability.[[Promise]].
+  return promiseCapability.Promise;
+}

package/src/runtime-semantics/ImportDeclaration.mts

@@ -0,0 +1,9 @@
+import { NormalCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-module-semantics-runtime-semantics-evaluation */
+// ModuleItem : ImportDeclaration
+export function Evaluate_ImportDeclaration(_ImportDeclaration: ParseNode.ImportDeclaration) {
+  // 1. Return NormalCompletion(empty).
+  return NormalCompletion(undefined);
+}

package/src/runtime-semantics/ImportMeta.mts

@@ -0,0 +1,45 @@
+import { HostGetImportMetaProperties, HostFinalizeImportMeta } from '../host-defined/engine.mts';
+import { ObjectValue, Value } from '../value.mts';
+import {
+  Assert,
+  GetActiveScriptOrModule,
+  OrdinaryObjectCreate,
+  CreateDataPropertyOrThrow,
+} from '../abstract-ops/all.mts';
+import { X } from '../completion.mts';
+import { SourceTextModuleRecord } from '../modules.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-meta-properties */
+//   ImportMeta : `import` `.` `meta`
+export function Evaluate_ImportMeta(_ImportMeta: ParseNode.ImportMeta) {
+  // 1. Let module be ! GetActiveScriptOrModule().
+  const module = X(GetActiveScriptOrModule());
+  // 2. Assert: module is a Source Text Module Record.
+  Assert(module instanceof SourceTextModuleRecord);
+  // 3. Let importMeta be module.[[ImportMeta]].
+  let importMeta = module.ImportMeta;
+  // 4. If importMeta is empty, then
+  if (importMeta === undefined) {
+    // a. Set importMeta to ! OrdinaryObjectCreate(null).
+    importMeta = X(OrdinaryObjectCreate(Value.null));
+    // b. Let importMetaValues be ! HostGetImportMetaProperties(module).
+    const importMetaValues = X(HostGetImportMetaProperties(module));
+    // c. For each Record { [[Key]], [[Value]] } p that is an element of importMetaValues, do
+    for (const p of importMetaValues) {
+      // i. Perform ! CreateDataPropertyOrThrow(importMeta, p.[[Key]], p.[[Value]]).
+      X(CreateDataPropertyOrThrow(importMeta, p.Key, p.Value));
+    }
+    // d. Perform ! HostFinalizeImportMeta(importMeta, module).
+    X(HostFinalizeImportMeta(importMeta, module));
+    // e. Set module.[[ImportMeta]] to importMeta.
+    module.ImportMeta = importMeta;
+    // f. Return importMeta.
+    return importMeta;
+  } else { // 5. Else,
+    // a. Assert: Type(importMeta) is Object.
+    Assert(importMeta instanceof ObjectValue);
+    // b. Return importMeta.
+    return importMeta;
+  }
+}

package/src/runtime-semantics/InstantiateArrowFunctionExpression.mts

@@ -0,0 +1,35 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import { Value } from '../value.mts';
+import { OrdinaryFunctionCreate, SetFunctionName, sourceTextMatchedBy } from '../abstract-ops/all.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { PrivateName, PropertyKeyValue } from '#self';
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-instantiatearrowfunctionexpression */
+// ArrowFunction : ArrowParameters `=>` ConciseBody
+export function InstantiateArrowFunctionExpression(ArrowFunction: ParseNode.ArrowFunction, name?: PropertyKeyValue | PrivateName) {
+  const { ArrowParameters, ConciseBody } = ArrowFunction;
+  // 1. If name is not present, set name to "".
+  if (name === undefined) {
+    name = Value('');
+  }
+  // 2. Let scope be the LexicalEnvironment of the running execution context.
+  const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 3. Let privateScope be the running execution context's PrivateEnvironment.
+  const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 4. Let sourceText be the source text matched by ArrowFunction.
+  const sourceText = sourceTextMatchedBy(ArrowFunction);
+  // 5. Let closure be OrdinaryFunctionCreate(%Function.prototype%, sourceText, ArrowParameters, ConciseBody, lexical-this, scope, privateScope).
+  const closure = OrdinaryFunctionCreate(
+    surroundingAgent.intrinsic('%Function.prototype%'),
+    sourceText,
+    ArrowParameters,
+    ConciseBody,
+    'lexical-this',
+    scope,
+    privateScope,
+  );
+  // 6. Perform SetFunctionName(closure, name).
+  SetFunctionName(closure, name);
+  // 7. Return closure.
+  return closure;
+}

package/src/runtime-semantics/InstantiateAsyncArrowFunctionExpression.mts

@@ -0,0 +1,37 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import { Value } from '../value.mts';
+import { OrdinaryFunctionCreate, SetFunctionName, sourceTextMatchedBy } from '../abstract-ops/all.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { PrivateName, PropertyKeyValue } from '#self';
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-instantiateasyncarrowfunctionexpression */
+// AsyncArrowFunction : ArrowParameters `=>` AsyncConciseBody
+export function InstantiateAsyncArrowFunctionExpression(AsyncArrowFunction: ParseNode.AsyncArrowFunction, name?: PropertyKeyValue | PrivateName) {
+  const { ArrowParameters, AsyncConciseBody } = AsyncArrowFunction;
+  // 1. If name is not present, set name to "".
+  if (name === undefined) {
+    name = Value('');
+  }
+  // 2. Let scope be the LexicalEnvironment of the running execution context.
+  const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 3. Let privateScope be the running execution context's PrivateEnvironment.
+  const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 4. Let sourceText be the source text matched by AsyncArrowFunction.
+  const sourceText = sourceTextMatchedBy(AsyncArrowFunction);
+  // 5. Let parameters be AsyncArrowBindingIdentifier.
+  const parameters = ArrowParameters;
+  // 6. Let closure be OrdinaryFunctionCreate(%AsyncFunction.prototype%, sourceText, ArrowParameters, AsyncConciseBody, lexical-this, scope, privateScope).
+  const closure = OrdinaryFunctionCreate(
+    surroundingAgent.intrinsic('%AsyncFunction.prototype%'),
+    sourceText,
+    parameters,
+    AsyncConciseBody,
+    'lexical-this',
+    scope,
+    privateScope,
+  );
+  // 7. Perform SetFunctionName(closure, name).
+  SetFunctionName(closure, name);
+  // 8. Return closure.
+  return closure;
+}

package/src/runtime-semantics/InstantiateAsyncFunctionExpression.mts

@@ -0,0 +1,75 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  PrivateName, Value, type PropertyKeyValue,
+} from '../value.mts';
+import {
+  Assert,
+  OrdinaryFunctionCreate,
+  SetFunctionName,
+  sourceTextMatchedBy,
+} from '../abstract-ops/all.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import { X } from '../completion.mts';
+import { DeclarativeEnvironmentRecord } from '../environment.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-instantiateasyncfunctionexpression */
+export function InstantiateAsyncFunctionExpression(AsyncFunctionExpression: ParseNode.AsyncFunctionExpression, name?: PropertyKeyValue | PrivateName) {
+  const { BindingIdentifier, FormalParameters, AsyncBody } = AsyncFunctionExpression;
+  if (BindingIdentifier) {
+    // 1. Assert: name is not present.
+    Assert(name === undefined);
+    // 2. Set name to StringValue of BindingIdentifier.
+    name = StringValue(BindingIdentifier);
+    // 3. Let scope be the LexicalEnvironment of the running execution context.
+    const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+    // 4. Let funcEnv be ! NewDeclarativeEnvironment(scope).
+    const funcEnv = X(new DeclarativeEnvironmentRecord(scope));
+    // 5. Perform ! funcEnv.CreateImmutableBinding(name, false).
+    X(funcEnv.CreateImmutableBinding(name, Value.false));
+    // 6. Let privateScope be the running execution context's PrivateEnvironment.
+    const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+    // 7. Let sourceText be the source text matched by AsyncFunctionExpression.
+    const sourceText = sourceTextMatchedBy(AsyncFunctionExpression);
+    // 8. Let closure be ! OrdinaryFunctionCreate(%AsyncFunction.prototype%, sourceText, FormalParameters, AsyncBody, non-lexical-this, funcEnv, privateScope).
+    const closure = X(OrdinaryFunctionCreate(
+      surroundingAgent.intrinsic('%AsyncFunction.prototype%'),
+      sourceText,
+      FormalParameters,
+      AsyncBody,
+      'non-lexical-this',
+      funcEnv,
+      privateScope,
+    ));
+    // 9. Perform ! SetFunctionName(closure, name).
+    X(SetFunctionName(closure, name));
+    // 10. Perform ! funcEnv.InitializeBinding(name, closure).
+    X(funcEnv.InitializeBinding(name, closure));
+    // 11. Return closure.
+    return closure;
+  }
+  // 1. If name is not present, set name to "".
+  if (name === undefined) {
+    name = Value('');
+  }
+  // 2. Let scope be the LexicalEnvironment of the running execution context.
+  const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 3. Let privateScope be the running execution context's PrivateEnvironment.
+  const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 4. Let sourceText be the source text matched by AsyncFunctionExpression.
+  const sourceText = sourceTextMatchedBy(AsyncFunctionExpression);
+  // 5. Let closure be ! OrdinaryFunctionCreate(%AsyncFunction.prototype%, sourceText, FormalParameters, AsyncBody, non-lexical-this, scope, privateScope).
+  const closure = X(OrdinaryFunctionCreate(
+    surroundingAgent.intrinsic('%AsyncFunction.prototype%'),
+    sourceText,
+    FormalParameters,
+    AsyncBody,
+    'non-lexical-this',
+    scope,
+    privateScope,
+  ));
+  // 6. Perform SetFunctionName(closure, name).
+  SetFunctionName(closure, name);
+  // 7. Return closure.
+  return closure;
+}

package/src/runtime-semantics/InstantiateAsyncGeneratorFunctionExpression.mts

@@ -0,0 +1,90 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  Value, Descriptor, type PropertyKeyValue, PrivateName,
+} from '../value.mts';
+import {
+  Assert,
+  DefinePropertyOrThrow,
+  OrdinaryFunctionCreate,
+  OrdinaryObjectCreate,
+  SetFunctionName,
+  sourceTextMatchedBy,
+} from '../abstract-ops/all.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import { X } from '../completion.mts';
+import { DeclarativeEnvironmentRecord } from '../environment.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-instantiateasyncgeneratorfunctionexpression */
+//   AsyncGeneratorExpression :
+//     `async` `function` `*` `(` FormalParameters `)` `{` AsyncGeneratorBody `}`
+//     `async` `function` `*` BindingIdentifier `(` FormalParameters `)` `{` AsyncGeneratorBody `}`
+export function InstantiateAsyncGeneratorFunctionExpression(AsyncGeneratorExpression: ParseNode.AsyncGeneratorExpression, name?: PropertyKeyValue | PrivateName) {
+  const { BindingIdentifier, FormalParameters, AsyncGeneratorBody } = AsyncGeneratorExpression;
+  if (BindingIdentifier) {
+    // 1. Assert: name is not present.
+    Assert(name === undefined);
+    // 2. Set name to StringValue of BindingIdentifier.
+    name = StringValue(BindingIdentifier);
+    // 3. Let scope be the running execution context's LexicalEnvironment.
+    const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+    // 4. Let funcEnv be NewDeclarativeEnvironment(scope).
+    const funcEnv = new DeclarativeEnvironmentRecord(scope);
+    // 5. Perform funcEnv.CreateImmutableBinding(name, false).
+    funcEnv.CreateImmutableBinding(name, Value.false);
+    // 6. Let privateScope be the running execution context's PrivateEnvironment.
+    const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+    // 7. Let source text be the source textmatched by AsyncGeneratorExpression.
+    const sourceText = sourceTextMatchedBy(AsyncGeneratorExpression);
+    // 8. Let closure be OrdinaryFunctionCreate(%AsyncGeneratorFunction.prototype%, sourceText, FormalParameters, AsyncGeneratorBody, non-lexical-this, funcEnv, privateScope).
+    const closure = X(OrdinaryFunctionCreate(surroundingAgent.intrinsic('%AsyncGeneratorFunction.prototype%'), sourceText, FormalParameters, AsyncGeneratorBody, 'non-lexical-this', funcEnv, privateScope));
+    // 9. Perform SetFunctionName(closure, name).
+    SetFunctionName(closure, name);
+    // 10. Let prototype be OrdinaryObjectCreate(%AsyncGeneratorFunction.prototype.prototype%).
+    const prototype = OrdinaryObjectCreate(surroundingAgent.intrinsic('%AsyncGeneratorFunction.prototype.prototype%'));
+    // 11. Perform DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
+    X(DefinePropertyOrThrow(
+      closure,
+      Value('prototype'),
+      Descriptor({
+        Value: prototype,
+        Writable: Value.true,
+        Enumerable: Value.false,
+        Configurable: Value.false,
+      }),
+    ));
+    // 12. Perform funcEnv.InitializeBinding(name, closure).
+    X(funcEnv.InitializeBinding(name, closure));
+    // 13. Return closure.
+    return closure;
+  }
+  // 1. If name is not present, set name to "".
+  if (name === undefined) {
+    name = Value('');
+  }
+  // 2. Let scope be the LexicalEnvironment of the running execution context.
+  const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 3. Let privateScope be the running execution context's PrivateEnvironment.
+  const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 4. Let sourceText be the source text matched by AsyncGeneratorExpression.
+  const sourceText = sourceTextMatchedBy(AsyncGeneratorExpression);
+  // 5. Let closure be ! OrdinaryFunctionCreate(%AsyncGeneratorFunction.prototype%, sourceText, FormalParameters, AsyncGeneratorBody, non-lexical-this, scope, privateScope).
+  const closure = X(OrdinaryFunctionCreate(surroundingAgent.intrinsic('%AsyncGeneratorFunction.prototype%'), sourceText, FormalParameters, AsyncGeneratorBody, 'non-lexical-this', scope, privateScope));
+  // 6. Perform SetFunctionName(closure, name).
+  SetFunctionName(closure, name);
+  // 7. Let prototype be ! OrdinaryObjectCreate(%AsyncGeneratorFunction.prototype.prototype%).
+  const prototype = OrdinaryObjectCreate(surroundingAgent.intrinsic('%AsyncGeneratorFunction.prototype.prototype%'));
+  // 8. Perform ! DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
+  X(DefinePropertyOrThrow(
+    closure,
+    Value('prototype'),
+    Descriptor({
+      Value: prototype,
+      Writable: Value.true,
+      Enumerable: Value.false,
+      Configurable: Value.false,
+    }),
+  ));
+  // 9. Return closure.
+  return closure;
+}

package/src/runtime-semantics/InstantiateFunctionObject.mts

@@ -0,0 +1,123 @@
+import {
+  DefinePropertyOrThrow,
+  MakeConstructor,
+  OrdinaryObjectCreate,
+  SetFunctionName,
+  OrdinaryFunctionCreate,
+  sourceTextMatchedBy,
+} from '../abstract-ops/all.mts';
+import { X } from '../completion.mts';
+import { surroundingAgent } from '../host-defined/engine.mts';
+import { OutOfRange } from '../helpers.mts';
+import { Descriptor, Value } from '../value.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { EnvironmentRecord, NullValue, PrivateEnvironmentRecord } from '#self';
+
+/** https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-instantiatefunctionobject */
+//   FunctionDeclaration :
+//     `function` BindingIdentifier `(` FormalParameters `)` `{` FunctionBody `}`
+//     `function` `(` FormalParameters `)` `{` FunctionBody `}`
+export function InstantiateFunctionObject_FunctionDeclaration(FunctionDeclaration: ParseNode.FunctionDeclaration, env: EnvironmentRecord, privateEnv: PrivateEnvironmentRecord | NullValue) {
+  const { BindingIdentifier, FormalParameters, FunctionBody } = FunctionDeclaration;
+  // 1. Let name be StringValue of BindingIdentifier.
+  const name = BindingIdentifier ? StringValue(BindingIdentifier) : Value('default');
+  // 2. Let sourceText be the source text matched by FunctionDeclaration.
+  const sourceText = sourceTextMatchedBy(FunctionDeclaration);
+  // 3. Let F be OrdinaryFunctionCreate(%Function.prototype%, sourceText, FormalParameters, FunctionBody, non-lexical-this, scope, privateScope).
+  const F = X(OrdinaryFunctionCreate(surroundingAgent.intrinsic('%Function.prototype%'), sourceText, FormalParameters, FunctionBody, 'non-lexical-this', env, privateEnv));
+  // 4. Perform SetFunctionName(F, name).
+  SetFunctionName(F, name);
+  // 5. Perform MakeConstructor(F).
+  MakeConstructor(F);
+  // 6. Return F.
+  return F;
+}
+
+/** https://tc39.es/ecma262/#sec-generator-function-definitions-runtime-semantics-instantiatefunctionobject */
+//   GeneratorDeclaration :
+//     `function` `*` BindingIdentifier `(` FormalParameters `)` `{` GeneratorBody `}`
+//     `function` `*` `(` FormalParameters `)` `{` GeneratorBody `}`
+export function InstantiateFunctionObject_GeneratorDeclaration(GeneratorDeclaration: ParseNode.GeneratorDeclaration, env: EnvironmentRecord, privateEnv: PrivateEnvironmentRecord | NullValue) {
+  const { BindingIdentifier, FormalParameters, GeneratorBody } = GeneratorDeclaration;
+  // 1. Let name be StringValue of BindingIdentifier.
+  const name = BindingIdentifier ? StringValue(BindingIdentifier) : Value('default');
+  // 2. Let sourceText be the source text matched by GeneratorDeclaration.
+  const sourceText = sourceTextMatchedBy(GeneratorDeclaration);
+  // 3. Let F be OrdinaryFunctionCreate(%GeneratorFunction.prototype%, sourceText, FormalParameters, GeneratorBody, non-lexical-this, scope, privateScope).
+  const F = X(OrdinaryFunctionCreate(surroundingAgent.intrinsic('%GeneratorFunction.prototype%'), sourceText, FormalParameters, GeneratorBody, 'non-lexical-this', env, privateEnv));
+  // 4. Perform SetFunctionName(F, name).
+  SetFunctionName(F, name);
+  // 5. Let prototype be OrdinaryObjectCreate(%GeneratorFunction.prototype.prototype%).
+  const prototype = X(OrdinaryObjectCreate(surroundingAgent.intrinsic('%GeneratorFunction.prototype.prototype%')));
+  // 6. Perform DefinePropertyOrThrow(F, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
+  X(DefinePropertyOrThrow(F, Value('prototype'), Descriptor({
+    Value: prototype,
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+  // 7. Return F.
+  return F;
+}
+
+/** https://tc39.es/ecma262/#sec-async-function-definitions-InstantiateFunctionObject */
+//  AsyncFunctionDeclaration :
+//    `async` `function` BindingIdentifier `(` FormalParameters `)` `{` AsyncBody `}`
+//    `async` `function` `(` FormalParameters `)` `{` AsyncBody `}`
+export function InstantiateFunctionObject_AsyncFunctionDeclaration(AsyncFunctionDeclaration: ParseNode.AsyncFunctionDeclaration, env: EnvironmentRecord, privateEnv: PrivateEnvironmentRecord | NullValue) {
+  const { BindingIdentifier, FormalParameters, AsyncBody } = AsyncFunctionDeclaration;
+  // 1. Let name be StringValue of BindingIdentifier.
+  const name = BindingIdentifier ? StringValue(BindingIdentifier) : Value('default');
+  // 2. Let sourceText be the source text matched by AsyncFunctionDeclaration.
+  const sourceText = sourceTextMatchedBy(AsyncFunctionDeclaration);
+  // 3. Let F be ! OrdinaryFunctionCreate(%AsyncFunction.prototype%, sourceText, FormalParameters, AsyncBody, non-lexical-this, scope, privateScope).
+  const F = X(OrdinaryFunctionCreate(surroundingAgent.intrinsic('%AsyncFunction.prototype%'), sourceText, FormalParameters, AsyncBody, 'non-lexical-this', env, privateEnv));
+  // 4. Perform ! SetFunctionName(F, name).
+  SetFunctionName(F, name);
+  // 5. Return F.
+  return F;
+}
+
+/** https://tc39.es/ecma262/#sec-asyncgenerator-definitions-evaluatebody */
+//  AsyncGeneratorDeclaration :
+//    `async` `function` `*` BindingIdentifier `(` FormalParameters`)` `{` AsyncGeneratorBody `}`
+//    `async` `function` `*` `(` FormalParameters`)` `{` AsyncGeneratorBody `}`
+export function InstantiateFunctionObject_AsyncGeneratorDeclaration(AsyncGeneratorDeclaration: ParseNode.AsyncGeneratorDeclaration, env: EnvironmentRecord, privateEnv: PrivateEnvironmentRecord | NullValue) {
+  const { BindingIdentifier, FormalParameters, AsyncGeneratorBody } = AsyncGeneratorDeclaration;
+  // 1. Let name be StringValue of BindingIdentifier.
+  const name = BindingIdentifier ? StringValue(BindingIdentifier) : Value('default');
+  // 2. Let sourceText be the source text matched by AsyncGeneratorDeclaration.
+  const sourceText = sourceTextMatchedBy(AsyncGeneratorDeclaration);
+  // 3. Let F be ! OrdinaryFunctionCreate(%AsyncGeneratorFunction.prototype%, sourceText, FormalParameters, AsyncGeneratorBody, non-lexical-this, scope, privateScope).
+  const F = X(OrdinaryFunctionCreate(surroundingAgent.intrinsic('%AsyncGeneratorFunction.prototype%'), sourceText, FormalParameters, AsyncGeneratorBody, 'non-lexical-this', env, privateEnv));
+  // 4. Perform ! SetFunctionName(F, name).
+  SetFunctionName(F, name);
+  // 5. Let prototype be ! OrdinaryObjectCreate(%AsyncGeneratorFunction.prototype.prototype%).
+  const prototype = X(OrdinaryObjectCreate(surroundingAgent.intrinsic('%AsyncGeneratorFunction.prototype.prototype%')));
+  // 6. Perform ! DefinePropertyOrThrow(F, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
+  X(DefinePropertyOrThrow(F, Value('prototype'), Descriptor({
+    Value: prototype,
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+  // 7. Return F.
+  return F;
+}
+
+export function InstantiateFunctionObject(AnyFunctionDeclaration: ParseNode.FunctionDeclaration | ParseNode.GeneratorDeclaration | ParseNode.AsyncFunctionDeclaration | ParseNode.AsyncGeneratorDeclaration, env: EnvironmentRecord, privateEnv: PrivateEnvironmentRecord | NullValue) {
+  switch (AnyFunctionDeclaration.type) {
+    case 'FunctionDeclaration':
+      return InstantiateFunctionObject_FunctionDeclaration(AnyFunctionDeclaration, env, privateEnv);
+    case 'GeneratorDeclaration':
+      return InstantiateFunctionObject_GeneratorDeclaration(AnyFunctionDeclaration, env, privateEnv);
+    case 'AsyncFunctionDeclaration':
+      return InstantiateFunctionObject_AsyncFunctionDeclaration(AnyFunctionDeclaration, env, privateEnv);
+    case 'AsyncGeneratorDeclaration':
+      return InstantiateFunctionObject_AsyncGeneratorDeclaration(AnyFunctionDeclaration, env, privateEnv);
+
+    default:
+      throw new OutOfRange('InstantiateFunctionObject', AnyFunctionDeclaration);
+  }
+}

package/src/runtime-semantics/InstantiateGeneratorFunctionExpression.mts

@@ -0,0 +1,82 @@
+import { surroundingAgent } from '../host-defined/engine.mts';
+import {
+  Value, Descriptor, type PropertyKeyValue, PrivateName,
+} from '../value.mts';
+import {
+  Assert,
+  DefinePropertyOrThrow,
+  OrdinaryFunctionCreate,
+  OrdinaryObjectCreate,
+  SetFunctionName,
+  sourceTextMatchedBy,
+} from '../abstract-ops/all.mts';
+import { X } from '../completion.mts';
+import { StringValue } from '../static-semantics/all.mts';
+import { DeclarativeEnvironmentRecord } from '../environment.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-runtime-semantics-instantiategeneratorfunctionexpression */
+//   GeneratorExpression :
+//     `function` `*` `(` FormalParameters `)` `{` GeneratorBody `}`
+//     `function` `* `BindingIdentifier `(` FormalParameters `)` `{` GeneratorBody `}`
+export function InstantiateGeneratorFunctionExpression(GeneratorExpression: ParseNode.GeneratorExpression, name?: PropertyKeyValue | PrivateName) {
+  const { BindingIdentifier, FormalParameters, GeneratorBody } = GeneratorExpression;
+  if (BindingIdentifier) {
+    // 1. Assert: name is not present.
+    Assert(name === undefined);
+    // 2. Set name to StringValue of BindingIdentifier.
+    name = StringValue(BindingIdentifier);
+    // 3. Let scope be the running execution context's LexicalEnvironment.
+    const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+    // 4. Let funcEnv be NewDeclarativeEnvironment(scope).
+    const funcEnv = new DeclarativeEnvironmentRecord(scope);
+    // 5. Perform funcEnv.CreateImmutableBinding(name, false).
+    funcEnv.CreateImmutableBinding(name, Value.false);
+    // 6. Let privateScope be the running execution context's PrivateEnvironment.
+    const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+    // 7. Let sourceText be the source text matched by GeneratorExpression.
+    const sourceText = sourceTextMatchedBy(GeneratorExpression);
+    // 8. Let closure be OrdinaryFunctionCreate(%GeneratorFunction.prototype%, sourceText, FormalParameters, GeneratorBody, non-lexical-this, funcEnv, privateScope).
+    const closure = OrdinaryFunctionCreate(surroundingAgent.intrinsic('%GeneratorFunction.prototype%'), sourceText, FormalParameters, GeneratorBody, 'non-lexical-this', funcEnv, privateScope);
+    // 9. Perform SetFunctionName(closure, name).
+    SetFunctionName(closure, name);
+    // 10. Let prototype be ! OrdinaryObjectCreate(%GeneratorFunction.prototype.prototype%).
+    const prototype = X(OrdinaryObjectCreate(surroundingAgent.intrinsic('%GeneratorFunction.prototype.prototype%')));
+    // 11. Perform DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
+    X(DefinePropertyOrThrow(closure, Value('prototype'), new Descriptor({
+      Value: prototype,
+      Writable: Value.true,
+      Enumerable: Value.false,
+      Configurable: Value.false,
+    })));
+    // 12. Perform funcEnv.InitializeBinding(name, closure).
+    X(funcEnv.InitializeBinding(name, closure));
+    // 13. Return closure.
+    return closure;
+  }
+  // 1. If name is not present, set name to "".
+  if (name === undefined) {
+    name = Value('');
+  }
+  // 2. Let scope be the running execution context's LexicalEnvironment.
+  const scope = surroundingAgent.runningExecutionContext.LexicalEnvironment;
+  // 3. Let privateScope be the running execution context's PrivateEnvironment.
+  const privateScope = surroundingAgent.runningExecutionContext.PrivateEnvironment;
+  // 4. Let sourceText be the source text matched by GeneratorExpression.
+  const sourceText = sourceTextMatchedBy(GeneratorExpression);
+  // 5. Let closure be OrdinaryFunctionCreate(%GeneratorFunction.prototype%, sourceText, FormalParameters, GeneratorBody, non-lexical-this, scope, privateScope).
+  const closure = OrdinaryFunctionCreate(surroundingAgent.intrinsic('%GeneratorFunction.prototype%'), sourceText, FormalParameters, GeneratorBody, 'non-lexical-this', scope, privateScope);
+  // 6. Perform SetFunctionName(closure, name).
+  SetFunctionName(closure, name);
+  // 7. Let prototype be ! OrdinaryObjectCreate(%GeneratorFunction.prototype.prototype%).
+  const prototype = X(OrdinaryObjectCreate(surroundingAgent.intrinsic('%GeneratorFunction.prototype.prototype%')));
+  // 8. Perform DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
+  X(DefinePropertyOrThrow(closure, Value('prototype'), new Descriptor({
+    Value: prototype,
+    Writable: Value.true,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+  // 9. Return closure.
+  return closure;
+}