@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/parser/tokens.mts

@@ -0,0 +1,210 @@
+/** Coerces a property key into a numeric index */
+type ToIndex<T extends PropertyKey> =
+  T extends number ? ToIndex<`${T}`> :
+  T extends `${bigint}` ? T extends `${infer I extends number}` ? I : never :
+  never;
+
+type TokenDefinition = readonly [name: string, value: string | null];
+
+type TokenArrayToAssignTokenArray<A extends readonly TokenDefinition[]> = {
+  readonly [P in keyof A]: readonly [`ASSIGN_${A[P][0]}`, `${A[P][1]}=`];
+};
+
+type TokenArrayToEnumLike<A extends readonly TokenDefinition[]> = {
+  readonly [I in ToIndex<keyof A> as A[I][0]]: I;
+};
+
+type TokenArrayToElementArray<A extends readonly TokenDefinition[], I extends 0 | 1> = {
+  readonly [P in keyof A]: A[P][I];
+};
+
+type TokenArrayToKeywordsArray<A extends readonly TokenDefinition[]> = readonly {
+  readonly [I in ToIndex<keyof A>]: A[I][1] extends Lowercase<A[I][0]> ? A[I][1] : never;
+}[ToIndex<keyof A>][];
+
+type KeywordsArrayToEnumLike<A extends readonly string[]> = {
+  readonly [P in A[number]]: typeof Token[Uppercase<P> & keyof typeof Token];
+};
+
+const MaybeAssignTokens = [
+  // Logical
+  ['NULLISH', '??'],
+  ['OR', '||'],
+  ['AND', '&&'],
+
+  // Binop
+  ['BIT_OR', '|'],
+  ['BIT_XOR', '^'],
+  ['BIT_AND', '&'],
+  ['SHL', '<<'],
+  ['SAR', '>>'],
+  ['SHR', '>>>'],
+  ['MUL', '*'],
+  ['DIV', '/'],
+  ['MOD', '%'],
+  ['EXP', '**'],
+
+  // Unop
+  ['ADD', '+'],
+  ['SUB', '-'],
+] as const satisfies readonly TokenDefinition[];
+
+export const RawTokens = [
+  // BEGIN PropertyOrCall
+  // BEGIN Member
+  // BEGIN Template
+  ['TEMPLATE', '`'],
+  // END Template
+
+  // BEGIN Property
+  ['PERIOD', '.'],
+  ['LBRACK', '['],
+  // END Property
+  // END Member
+  ['OPTIONAL', '?.'],
+  ['LPAREN', '('],
+  // END PropertyOrCall
+  ['RPAREN', ')'],
+  ['RBRACK', ']'],
+  ['LBRACE', '{'],
+  ['COLON', ':'],
+  ['ELLIPSIS', '...'],
+  ['CONDITIONAL', '?'],
+  // BEGIN AutoSemicolon
+  ['SEMICOLON', ';'],
+  ['RBRACE', '}'],
+
+  ['EOS', 'EOS'],
+  // END AutoSemicolon
+
+  // BEGIN ArrowOrAssign
+  ['ARROW', '=>'],
+  // BEGIN Assign
+  ['ASSIGN', '='],
+  ...MaybeAssignTokens.map(([name, value]) => [`ASSIGN_${name}`, `${value}=`]) as readonly TokenDefinition[] as TokenArrayToAssignTokenArray<typeof MaybeAssignTokens>,
+  // END Assign
+  // END ArrowOrAssign
+
+  ['COMMA', ','],
+
+  ...MaybeAssignTokens,
+
+  ['NOT', '!'],
+  ['BIT_NOT', '~'],
+  ['DELETE', 'delete'],
+  ['TYPEOF', 'typeof'],
+  ['VOID', 'void'],
+
+  // BEGIN IsCountOp
+  ['INC', '++'],
+  ['DEC', '--'],
+  // END IsCountOp
+  // END IsUnaryOrCountOp
+
+  ['EQ', '=='],
+  ['EQ_STRICT', '==='],
+  ['NE', '!='],
+  ['NE_STRICT', '!=='],
+  ['LT', '<'],
+  ['GT', '>'],
+  ['LTE', '<='],
+  ['GTE', '>='],
+  ['INSTANCEOF', 'instanceof'],
+  ['IN', 'in'],
+
+  ['BREAK', 'break'],
+  ['CASE', 'case'],
+  ['CATCH', 'catch'],
+  ['CONTINUE', 'continue'],
+  ['DEBUGGER', 'debugger'],
+  ['DEFAULT', 'default'],
+  // DELETE
+  ['DO', 'do'],
+  ['ELSE', 'else'],
+  ['FINALLY', 'finally'],
+  ['FOR', 'for'],
+  ['FUNCTION', 'function'],
+  ['IF', 'if'],
+  // IN
+  // INSTANCEOF
+  ['NEW', 'new'],
+  ['RETURN', 'return'],
+  ['SWITCH', 'switch'],
+  ['THROW', 'throw'],
+  ['TRY', 'try'],
+  // TYPEOF
+  ['VAR', 'var'],
+  // VOID
+  ['WHILE', 'while'],
+  ['WITH', 'with'],
+  ['THIS', 'this'],
+
+  ['NULL', 'null'],
+  ['TRUE', 'true'],
+  ['FALSE', 'false'],
+  ['NUMBER', null],
+  ['STRING', null],
+  ['BIGINT', null],
+
+  // BEGIN Callable
+  ['SUPER', 'super'],
+  // BEGIN AnyIdentifier
+  ['IDENTIFIER', null],
+  ['AWAIT', 'await'],
+  ['YIELD', 'yield'],
+  // END AnyIdentifier
+  // END Callable
+  ['CLASS', 'class'],
+  ['CONST', 'const'],
+  ['EXPORT', 'export'],
+  ['EXTENDS', 'extends'],
+  ['IMPORT', 'import'],
+  ['PRIVATE_IDENTIFIER', null],
+  ['AT', '@'],
+
+  ['ENUM', 'enum'],
+
+  ['ESCAPED_KEYWORD', null],
+] as const satisfies readonly TokenDefinition[];
+
+export const Token = RawTokens
+  .reduce((obj, [name], i) => {
+    obj[name] = i;
+    return obj;
+  }, Object.create(null)) as TokenArrayToEnumLike<typeof RawTokens>;
+
+export type Token = typeof Token[keyof typeof Token];
+
+export const TokenNames = RawTokens.map((r) => r[0]) as readonly string[] as TokenArrayToElementArray<typeof RawTokens, 0>;
+
+export const TokenValues = RawTokens.map((r) => r[1]) as readonly (string | null)[] as TokenArrayToElementArray<typeof RawTokens, 1>;
+
+const Keywords = RawTokens
+  .filter(([name, raw]) => name.toLowerCase() === raw)
+  .map(([, raw]) => raw!) as TokenArrayToKeywordsArray<typeof RawTokens>;
+
+export const KeywordLookup = Keywords
+  .reduce((obj, kw) => {
+    obj[kw] = Token[kw.toUpperCase() as Uppercase<typeof kw>];
+    return obj;
+  }, Object.create(null)) as KeywordsArrayToEnumLike<typeof Keywords>;
+
+const KeywordRaw: ReadonlySet<string> = new Set(Object.keys(KeywordLookup));
+const KeywordTokens: ReadonlySet<number> = new Set(Object.values(KeywordLookup));
+
+const isInRange = (t: number, l: number, h: number) => t >= l && t <= h;
+export const isAutomaticSemicolon = (t: number) => isInRange(t, Token.SEMICOLON, Token.EOS);
+export const isMember = (t: number) => isInRange(t, Token.TEMPLATE, Token.LBRACK);
+export const isPropertyOrCall = (t: number) => isInRange(t, Token.TEMPLATE, Token.LPAREN);
+export const isAnyIdentifier = (t: number) => isInRange(t, Token.IDENTIFIER, Token.YIELD)
+  || t === Token.ESCAPED_KEYWORD;
+export const isKeyword = (t: number): t is typeof KeywordLookup[keyof typeof KeywordLookup] => KeywordTokens.has(t);
+export const isKeywordRaw = (s: string): s is keyof typeof KeywordLookup => KeywordRaw.has(s);
+
+const ReservedWordsStrict: ReadonlySet<string> = new Set([
+  'implements', 'interface', 'let',
+  'package', 'private', 'protected',
+  'public', 'static', 'yield',
+]);
+
+export const isReservedWordStrict = (s: string) => ReservedWordsStrict.has(s);

package/src/parser/unicode.d.ts

@@ -0,0 +1,20 @@
+declare module '@unicode/unicode-17.0.0/Binary_Property/ID_Start/regex.js' {
+    let regex: RegExp;
+    export default regex;
+}
+declare module '@unicode/unicode-17.0.0/Binary_Property/ID_Continue/regex.js' {
+    let regex: RegExp;
+    export default regex;
+}
+declare module '@unicode/unicode-17.0.0/General_Category/Space_Separator/regex.js' {
+    let regex: RegExp;
+    export default regex;
+}
+declare module '@unicode/unicode-17.0.0/Case_Folding/C/symbols.js' {
+    let data: Map<string, string>;
+    export default data;
+}
+declare module '@unicode/unicode-17.0.0/Case_Folding/S/symbols.js' {
+    let data: Map<string, string>;
+    export default data;
+}

package/src/parser/utils.mts

@@ -0,0 +1,114 @@
+import type { ParseNode } from '#self';
+
+export type TargetSymbol = ParseNode['type'] | 'super' | 'this';
+
+/** https://tc39.es/ecma262/#sec-static-semantics-contains */
+export function Contains(node: ParseNode, symbol: TargetSymbol): boolean {
+  switch (node.type) {
+    case 'FunctionDeclaration':
+    case 'FunctionExpression':
+    case 'GeneratorDeclaration':
+    case 'GeneratorExpression':
+    case 'AsyncGeneratorDeclaration':
+    case 'AsyncGeneratorExpression':
+    case 'AsyncFunctionDeclaration':
+    case 'AsyncFunctionExpression':
+      return false;
+    case 'ClassTail': {
+      // We don't have ClassBody?
+      throw new Error('TODO');
+    }
+    case 'ClassStaticBlock':
+      return false;
+    case 'ArrowFunction':
+    case 'AsyncArrowFunction':
+      throw new Error('TODO');
+    case 'PropertyDefinition': {
+      // Note && TODO: PropertyDefinition in spec refers to MethodDefinition here,
+      // but our PropertyDefinition is parital one.
+      // We should check this at all use site of PropertyDefinitionList.
+      break;
+    }
+    //  LiteralPropertyName : IdentifierName
+    // throw new Error('TODO');
+    case 'MemberExpression': {
+      //  MemberExpression : MemberExpression . IdentifierName
+      if (node.IdentifierName) {
+        return Contains(node.MemberExpression, symbol);
+      }
+      break;
+    }
+    case 'SuperProperty': {
+      if (node.IdentifierName) {
+        return symbol === 'super';
+      }
+      break;
+    }
+    case 'CallExpression': {
+      throw new Error('TODO');
+    }
+    case 'OptionalChain': {
+      if (node.IdentifierName) {
+        //  OptionalChain : OptionalChain . IdentifierName
+        if (node.OptionalChain) {
+          return Contains(node.OptionalChain, symbol);
+        }
+        //  OptionalChain : ?. IdentifierName
+        return false;
+      }
+      break;
+    }
+    default:
+  }
+
+  // 1. For each child node child of this Parse Node
+  for (const child of avoid_using_children(node)) {
+    // a. If child is an instance of symbol, return true.
+    if (child.type === symbol) {
+      return true;
+    }
+    // b. If child is an instance of a nonterminal, then
+    const contained = Contains(child, symbol);
+    // i. If contained is true, return true.
+    if (contained) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** https://tc39.es/ecma262/#sec-static-semantics-arrayliteralcontentnodes */
+export function ArrayLiteralContentNodes(node: ParseNode.ArrayLiteral) {
+  return node.ElementList;
+}
+
+/** https://tc39.es/ecma262/#sec-static-semantics-propertydefinitionnodes */
+export function PropertyDefinitionNodes(node: ParseNode.ObjectLiteral) {
+  return node.PropertyDefinitionList;
+}
+
+// Note: this is not a correct forEachChild implementation, but it is not worth the effort to implement it fully.
+// defer it to the future if needed.
+export function* avoid_using_children(node: ParseNode): Generator<ParseNode> {
+  for (const key of Reflect.ownKeys(node)) {
+    if (typeof key === 'string' && key !== 'parent' && key !== 'type' && key !== 'location' && key !== 'sourceText') {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const child = (node as any)[key];
+      if (typeof child === 'object' && child) {
+        if (Array.isArray(child)) {
+          for (const element of child) {
+            if (isParseNode(element)) {
+              yield element;
+            }
+          }
+        } else if ('type' in child) {
+          yield child;
+        }
+      }
+    }
+  }
+}
+
+function isParseNode(value: unknown): value is ParseNode {
+  return !!(value && typeof value === 'object' && 'type' in value && 'location' in value);
+}

package/src/runtime-semantics/AdditiveExpression.mts

@@ -0,0 +1,29 @@
+import { Q } from '../completion.mts';
+import type { ValueEvaluator } from '../evaluator.mts';
+import { OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { EvaluateStringOrNumericBinaryExpression } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-addition-operator-plus-runtime-semantics-evaluation */
+//   AdditiveExpression : AdditiveExpression + MultiplicativeExpression
+function* Evaluate_AdditiveExpression_Plus({ AdditiveExpression, MultiplicativeExpression }: ParseNode.AdditiveExpression): ValueEvaluator {
+  // 1. Return ? EvaluateStringOrNumericBinaryExpression(AdditiveExpression, +, MultiplicativeExpression).
+  return Q(yield* EvaluateStringOrNumericBinaryExpression(AdditiveExpression, '+', MultiplicativeExpression));
+}
+
+/** https://tc39.es/ecma262/#sec-subtraction-operator-minus-runtime-semantics-evaluation */
+function* Evaluate_AdditiveExpression_Minus({ AdditiveExpression, MultiplicativeExpression }: ParseNode.AdditiveExpression): ValueEvaluator {
+  // 1. Return ? EvaluateStringOrNumericBinaryExpression(AdditiveExpression, -, MultiplicativeExpression).
+  return Q(yield* EvaluateStringOrNumericBinaryExpression(AdditiveExpression, '-', MultiplicativeExpression));
+}
+
+export function* Evaluate_AdditiveExpression(AdditiveExpression: ParseNode.AdditiveExpression) {
+  switch (AdditiveExpression.operator) {
+    case '+':
+      return yield* Evaluate_AdditiveExpression_Plus(AdditiveExpression);
+    case '-':
+      return yield* Evaluate_AdditiveExpression_Minus(AdditiveExpression);
+    default:
+      throw OutOfRange.nonExhaustive(AdditiveExpression);
+  }
+}

package/src/runtime-semantics/ApplyStringOrNumericBinaryOperator.mts

@@ -0,0 +1,78 @@
+import {
+  JSStringValue, Value,
+  NumberValue,
+  BigIntValue,
+  SameType,
+} from '../value.mts';
+import { Q } from '../completion.mts';
+import {
+  Assert, Throw, ToNumeric, ToPrimitive, ToString,
+} from '#self';
+
+export type BinaryOperator = '+' | '-' | '*' | '/' | '%' | '**' | '<<' | '>>' | '>>>' | '&' | '^' | '|';
+/** https://tc39.es/ecma262/#sec-applystringornumericbinaryoperator */
+export function* ApplyStringOrNumericBinaryOperator(lval: Value, opText: BinaryOperator, rval: Value) {
+  // 1. If opText is +, then
+  if (opText === '+') {
+    // a. Let lprim be ? ToPrimitive(lval).
+    const lprim = Q(yield* ToPrimitive(lval));
+    // b. Let rprim be ? ToPrimitive(rval).
+    const rprim = Q(yield* ToPrimitive(rval));
+    // c. If Type(lprim) is String or Type(rprim) is String, then
+    if (lprim instanceof JSStringValue || rprim instanceof JSStringValue) {
+      // i. Let lstr be ? ToString(lprim).
+      const lstr = Q(yield* ToString(lprim));
+      // ii. Let rstr be ? ToString(rprim).
+      const rstr = Q(yield* ToString(rprim));
+      // iii. Return the string-concatenation of lstr and rstr.
+      return Value(lstr.stringValue() + rstr.stringValue());
+    }
+    // d. Set lval to lprim.
+    lval = lprim;
+    // e. Set rval to rprim.
+    rval = rprim;
+  }
+  // 2. NOTE: At this point, it must be a numeric operation.
+  // 3. Let lnum be ? ToNumeric(lval).
+  const lnum = Q(yield* ToNumeric(lval));
+  // 4. Let rnum be ? ToNumeric(rval).
+  const rnum = Q(yield* ToNumeric(rval));
+  // 5. If SameType(lNum, rNum) is false, throw a TypeError exception.
+  if (!SameType(lnum, rnum)) {
+    return Throw.TypeError('Cannot mix BigInt and other types in $1 operation', opText);
+  }
+  if (lnum instanceof BigIntValue) {
+    const operations = {
+      '**': BigIntValue.exponentiate,
+      '*': BigIntValue.multiply,
+      '/': BigIntValue.divide,
+      '%': BigIntValue.remainder,
+      '+': BigIntValue.add,
+      '-': BigIntValue.subtract,
+      '<<': BigIntValue.leftShift,
+      '>>': BigIntValue.signedRightShift,
+      '>>>': BigIntValue.unsignedRightShift,
+      '&': BigIntValue.bitwiseAND,
+      '^': BigIntValue.bitwiseXOR,
+      '|': BigIntValue.bitwiseOR,
+    };
+    return Q(operations[opText](lnum, rnum as BigIntValue));
+  } else {
+    Assert(lnum instanceof NumberValue);
+    const operations = {
+      '**': NumberValue.exponentiate,
+      '*': NumberValue.multiply,
+      '/': NumberValue.divide,
+      '%': NumberValue.remainder,
+      '+': NumberValue.add,
+      '-': NumberValue.subtract,
+      '<<': NumberValue.leftShift,
+      '>>': NumberValue.signedRightShift,
+      '>>>': NumberValue.unsignedRightShift,
+      '&': NumberValue.bitwiseAND,
+      '^': NumberValue.bitwiseXOR,
+      '|': NumberValue.bitwiseOR,
+    };
+    return Q(operations[opText](lnum, rnum as NumberValue));
+  }
+}

package/src/runtime-semantics/ArgumentListEvaluation.mts

@@ -0,0 +1,178 @@
+import {
+  Value, Descriptor, type Arguments,
+} from '../value.mts';
+import { Evaluate, type PlainEvaluator } from '../evaluator.mts';
+import { Q, X } from '../completion.mts';
+import { OutOfRange, isArray } from '../utils/language.mts';
+import { TemplateStrings } from '../static-semantics/all.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import {
+  surroundingAgent,
+  Assert,
+  ArrayCreate,
+  SetIntegrityLevel,
+  ToString,
+  GetIterator,
+  GetValue,
+  F,
+  IteratorStepValue,
+} from '#self';
+
+/** https://tc39.es/ecma262/#sec-gettemplateobjec */
+function GetTemplateObject(templateLiteral: ParseNode.TemplateLiteral) {
+  // 1. Let realm be the current Realm Record.
+  const realm = surroundingAgent.currentRealmRecord;
+  // 2. Let templateRegistry be realm.[[TemplateMap]].
+  const templateRegistry = realm.TemplateMap;
+  // 3. For each element e of templateRegistry, do
+  for (const e of templateRegistry) {
+    // a. If e.[[Site]] is the same Parse Node as templateLiteral, then
+    if (e.Site === templateLiteral) {
+      // b. Return e.[[Array]].
+      return e.Array;
+    }
+  }
+  // 4. Let rawStrings be TemplateStrings of templateLiteral with argument true.
+  const rawStrings = TemplateStrings(templateLiteral, true);
+  // 5. Let cookedStrings be TemplateStrings of templateLiteral with argument false.
+  const cookedStrings = TemplateStrings(templateLiteral, false);
+  // 6. Let count be the number of elements in the List cookedStrings.
+  const count = cookedStrings.length;
+  // 7. Assert: count ≤ 232 - 1.
+  Assert(count < (2 ** 32) - 1);
+  // 8. Let template be ! ArrayCreate(count).
+  const template = X(ArrayCreate(count));
+  // 9. Let template be ! ArrayCreate(count).
+  const rawObj = X(ArrayCreate(count));
+  // 10. Let index be 0.
+  let index = 0;
+  // 11. Repeat, while index < count
+  while (index < count) {
+    // a. Let prop be ! ToString(𝔽(index)).
+    const prop = X(ToString(F(index)));
+    // b. Let cookedValue be the String value cookedStrings[index].
+    const cookedValue = cookedStrings[index];
+    // c. Call template.[[DefineOwnProperty]](prop, PropertyDescriptor { [[Value]]: cookedValue, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false }).
+    X(template.DefineOwnProperty(prop, Descriptor({
+      Value: cookedValue,
+      Writable: Value.false,
+      Enumerable: Value.true,
+      Configurable: Value.false,
+    })));
+    // d. Let rawValue be the String value rawStrings[index].
+    const rawValue = rawStrings[index];
+    // e. Call rawObj.[[DefineOwnProperty]](prop, PropertyDescriptor { [[Value]]: rawValue, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false }).
+    X(rawObj.DefineOwnProperty(prop, Descriptor({
+      Value: rawValue,
+      Writable: Value.false,
+      Enumerable: Value.true,
+      Configurable: Value.false,
+    })));
+    // f. Call rawObj.[[DefineOwnProperty]](prop, PropertyDescriptor { [[Value]]: rawValue, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false }).
+    index += 1;
+  }
+  // 12. Perform SetIntegrityLevel(rawObj, frozen).
+  X(SetIntegrityLevel(rawObj, 'frozen'));
+  // 13. Perform SetIntegrityLevel(rawObj, frozen).
+  X(template.DefineOwnProperty(Value('raw'), Descriptor({
+    Value: rawObj,
+    Writable: Value.false,
+    Enumerable: Value.false,
+    Configurable: Value.false,
+  })));
+  // 14. Perform SetIntegrityLevel(template, frozen).
+  X(SetIntegrityLevel(template, 'frozen'));
+  // 15. Append the Record { [[Site]]: templateLiteral, [[Array]]: template } to templateRegistry.
+  templateRegistry.push({ Site: templateLiteral, Array: template });
+  // 16. Return template.
+  return template;
+}
+
+/** https://tc39.es/ecma262/#sec-template-literals-runtime-semantics-argumentlistevaluation */
+//   TemplateLiteral : NoSubstitutionTemplate
+//
+// https://github.com/tc39/ecma262/pull/1402
+//   TemplateLiteral : SubstitutionTemplate
+function* ArgumentListEvaluation_TemplateLiteral(TemplateLiteral: ParseNode.TemplateLiteral): PlainEvaluator<Arguments> {
+  switch (true) {
+    case TemplateLiteral.TemplateSpanList.length === 1: {
+      const templateLiteral = TemplateLiteral;
+      const siteObj = GetTemplateObject(templateLiteral);
+      return [siteObj] as Arguments;
+    }
+
+    case TemplateLiteral.TemplateSpanList.length > 1: {
+      const templateLiteral = TemplateLiteral;
+      const siteObj = GetTemplateObject(templateLiteral);
+      const restSub = [];
+      for (const Expression of TemplateLiteral.ExpressionList) {
+        const subRef = Q(yield* Evaluate(Expression));
+        const subValue = Q(yield* GetValue(subRef));
+        restSub.push(subValue);
+      }
+      return [siteObj, ...restSub] as Arguments;
+    }
+
+    default:
+      throw OutOfRange.nonExhaustive(TemplateLiteral);
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-argument-lists-runtime-semantics-argumentlistevaluation */
+//   Arguments : `(` `)`
+//   ArgumentList :
+//     AssignmentExpression
+//     `...` AssignmentExpression
+//     ArgumentList `,` AssignmentExpression
+//     ArgumentList `,` `...` AssignmentExpression
+//
+// (implicit)
+//   Arguments :
+//     `(` ArgumentList `)`
+//     `(` ArgumentList `,` `)`
+function* ArgumentListEvaluation_Arguments(Arguments: ParseNode.Arguments): PlainEvaluator<Arguments> {
+  const precedingArgs = [];
+  for (const element of Arguments) {
+    if (element.type === 'AssignmentRestElement') {
+      const { AssignmentExpression } = element;
+      // 2. Let spreadRef be the result of evaluating AssignmentExpression.
+      const spreadRef = Q(yield* Evaluate(AssignmentExpression));
+      // 3. Let spreadObj be ? GetValue(spreadRef).
+      const spreadObj = Q(yield* GetValue(spreadRef));
+      // 4. Let iteratorRecord be ? GetIterator(spreadObj).
+      const iteratorRecord = Q(yield* GetIterator(spreadObj, 'sync'));
+      // 5. Repeat,
+      while (true) {
+        // a. Let next be ? IteratorStepValue(iteratorRecord).
+        const next = Q(yield* IteratorStepValue(iteratorRecord));
+        // b. If next is false, return list.
+        if (next === 'done') {
+          break;
+        }
+        // d. Append next as the last element of list.
+        precedingArgs.push(next);
+      }
+    } else {
+      const AssignmentExpression = element;
+      // 2. Let ref be the result of evaluating AssignmentExpression.
+      const ref = Q(yield* Evaluate(AssignmentExpression));
+      // 3. Let arg be ? GetValue(ref).
+      const arg = Q(yield* GetValue(ref));
+      // 4. Append arg to the end of precedingArgs.
+      precedingArgs.push(arg);
+      // 5. Return precedingArgs.
+    }
+  }
+  return precedingArgs as Arguments;
+}
+
+export function ArgumentListEvaluation(ArgumentsOrTemplateLiteral: ParseNode.TemplateLiteral | ParseNode.Arguments) {
+  switch (true) {
+    case isArray(ArgumentsOrTemplateLiteral):
+      return ArgumentListEvaluation_Arguments(ArgumentsOrTemplateLiteral);
+    case ('type' in ArgumentsOrTemplateLiteral && ArgumentsOrTemplateLiteral.type === 'TemplateLiteral'):
+      return ArgumentListEvaluation_TemplateLiteral(ArgumentsOrTemplateLiteral);
+    default:
+      throw OutOfRange.nonExhaustive(ArgumentsOrTemplateLiteral);
+  }
+}