@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/runtime-semantics/all.mts

@@ -0,0 +1,109 @@
+export * from './IdentifierReference.mts';
+export * from './This.mts';
+export * from './Literal.mts';
+export * from './ClassExpression.mts';
+export * from './ClassDefinitionEvaluation.mts';
+export * from './DefineMethod.mts';
+export * from './PropertyName.mts';
+export * from './AdditiveExpression.mts';
+export * from './AssignmentExpression.mts';
+export * from './BitwiseOperators.mts';
+export * from './CoalesceExpression.mts';
+export * from './EmptyStatement.mts';
+export * from './ExponentiationExpression.mts';
+export * from './IfStatement.mts';
+export * from './ImportCall.mts';
+export * from './MultiplicativeExpression.mts';
+export * from './ThrowStatement.mts';
+export * from './UpdateExpression.mts';
+export * from './GlobalDeclarationInstantiation.mts';
+export * from './InstantiateFunctionObject.mts';
+export * from './Script.mts';
+export * from './ScriptBody.mts';
+export * from './StatementList.mts';
+export * from './ExpressionStatement.mts';
+export * from './VariableStatement.mts';
+export * from './FunctionDeclaration.mts';
+export * from './CallExpression.mts';
+export * from './EvaluateCall.mts';
+export * from './ArgumentListEvaluation.mts';
+export * from './EvaluateBody.mts';
+export * from './FunctionDeclarationInstantiation.mts';
+export * from './FunctionStatementList.mts';
+export * from './IteratorBindingInitialization.mts';
+export * from './ReturnStatement.mts';
+export * from './ParenthesizedExpression.mts';
+export * from './MemberExpression.mts';
+export * from './EvaluatePropertyAccess.mts';
+export * from './LexicalDeclaration.mts';
+export * from './ObjectLiteral.mts';
+export * from './PropertyDefinitionEvaluation.mts';
+export * from './FunctionExpression.mts';
+export * from './NamedEvaluation.mts';
+export * from './TryStatement.mts';
+export * from './Block.mts';
+export * from './ArrayLiteral.mts';
+export * from './UnaryExpression.mts';
+export * from './EqualityExpression.mts';
+export * from './LogicalANDExpression.mts';
+export * from './LogicalORExpression.mts';
+export * from './NewExpression.mts';
+export * from './ShiftExpression.mts';
+export * from './SuperCall.mts';
+export * from './SuperProperty.mts';
+export * from './BindingInitialization.mts';
+export * from './ForDeclarationBindingInitialization.mts';
+export * from './AsyncFunctionExpression.mts';
+export * from './RelationalExpression.mts';
+export * from './BreakableStatement.mts';
+export * from './LabelledEvaluation.mts';
+export * from './TemplateLiteral.mts';
+export * from './SwitchStatement.mts';
+export * from './CreateDynamicFunction.mts';
+export * from './GeneratorExpression.mts';
+export * from './ArrowFunction.mts';
+export * from './AsyncArrowFunction.mts';
+export * from './BreakStatement.mts';
+export * from './AsyncGeneratorExpression.mts';
+export * from './HoistableDeclaration.mts';
+export * from './CommaOperator.mts';
+export * from './YieldExpression.mts';
+export * from './StringIndexOf.mts';
+export * from './NumberToBigInt.mts';
+export * from './ConditionalExpression.mts';
+export * from './RegularExpressionLiteral.mts';
+export * from './RegExp.mts';
+export * from './StringPad.mts';
+export * from './TrimString.mts';
+export * from './NewTarget.mts';
+export * from './AwaitExpression.mts';
+export * from './ClassDeclaration.mts';
+export * from './WithStatement.mts';
+export * from './Module.mts';
+export * from './ModuleBody.mts';
+export * from './ImportDeclaration.mts';
+export * from './ExportDeclaration.mts';
+export * from './OptionalExpression.mts';
+export * from './TaggedTemplateExpression.mts';
+export * from './GetSubstitution.mts';
+export * from './ContinueStatement.mts';
+export * from './LabelledStatement.mts';
+export * from './MV.mts';
+export * from './ApplyStringOrNumericBinaryOperator.mts';
+export * from './EvaluateStringOrNumericBinaryExpression.mts';
+export * from './ImportMeta.mts';
+export * from './DebuggerStatement.mts';
+export * from './PropertyBindingInitialization.mts';
+export * from './KeyedBindingInitialization.mts';
+export * from './DestructuringAssignmentEvaluation.mts';
+export * from './RestBindingInitialization.mts';
+export * from './Unicode.mts';
+export * from './MethodDefinitionEvaluation.mts';
+export * from './ClassFieldDefinitionEvaluation.mts';
+export * from './InstantiateOrdinaryFunctionExpression.mts';
+export * from './InstantiateGeneratorFunctionExpression.mts';
+export * from './InstantiateArrowFunctionExpression.mts';
+export * from './InstantiateAsyncArrowFunctionExpression.mts';
+export * from './InstantiateAsyncFunctionExpression.mts';
+export * from './InstantiateAsyncGeneratorFunctionExpression.mts';
+export * from './ClassStaticBlockDefinitionEvaluation.mts';

package/src/static-semantics/BodyText.mts

@@ -0,0 +1,7 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-static-semantics-bodytext */
+//  RegularExpressionLiteral :: `/` RegularExpressionBody `/` RegularExpressionFlags
+export function BodyText(RegularExpressionLiteral: ParseNode.RegularExpressionLiteral) {
+  return RegularExpressionLiteral.RegularExpressionBody;
+}

package/src/static-semantics/BoundNames.mts

@@ -0,0 +1,108 @@
+import { OutOfRange, isArray } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { JSStringValue, Value } from '../value.mts';
+import { StringValue } from './all.mts';
+
+export function BoundNames(node: ParseNode | readonly ParseNode[]): JSStringValue[] {
+  if (isArray(node)) {
+    const names = [];
+    for (const item of node) {
+      names.push(...BoundNames(item));
+    }
+    return names;
+  }
+  switch (node.type) {
+    case 'BindingIdentifier':
+      return [StringValue(node)];
+    case 'LexicalDeclaration':
+    case 'UsingDeclaration':
+    case 'AwaitUsingDeclaration':
+      return BoundNames(node.BindingList);
+    case 'LexicalBinding':
+      if (node.BindingIdentifier) {
+        return BoundNames(node.BindingIdentifier);
+      }
+      return BoundNames(node.BindingPattern!);
+    case 'VariableStatement':
+      return BoundNames(node.VariableDeclarationList);
+    case 'VariableDeclaration':
+      if (node.BindingIdentifier) {
+        return BoundNames(node.BindingIdentifier);
+      }
+      return BoundNames(node.BindingPattern!);
+    case 'ForDeclaration':
+      return BoundNames(node.ForBinding);
+    case 'ForBinding':
+      if (node.BindingIdentifier) {
+        return BoundNames(node.BindingIdentifier);
+      }
+      return BoundNames(node.BindingPattern!);
+    case 'FunctionDeclaration':
+    case 'GeneratorDeclaration':
+    case 'AsyncFunctionDeclaration':
+    case 'AsyncGeneratorDeclaration':
+    case 'ClassDeclaration':
+      if (node.BindingIdentifier) {
+        return BoundNames(node.BindingIdentifier);
+      }
+      return [Value('*default*')];
+    case 'ImportDeclaration':
+      if (node.ImportedBinding) {
+        return BoundNames(node.ImportedBinding);
+      }
+      return [];
+    case 'ImportSpecifier':
+      return BoundNames(node.ImportedBinding);
+    case 'ExportDeclaration':
+      if (node.FromClause || node.NamedExports) {
+        return [];
+      }
+      if (node.VariableStatement) {
+        return BoundNames(node.VariableStatement);
+      }
+      if (node.Declaration) {
+        return BoundNames(node.Declaration);
+      }
+      if (node.HoistableDeclaration) {
+        const declarationNames = BoundNames(node.HoistableDeclaration);
+        return declarationNames;
+      }
+      if (node.ClassDeclaration) {
+        const declarationNames = BoundNames(node.ClassDeclaration);
+        return declarationNames;
+      }
+      if (node.AssignmentExpression) {
+        return [Value('*default*')];
+      }
+      throw OutOfRange.exhaustive(node);
+    case 'SingleNameBinding':
+      return BoundNames(node.BindingIdentifier);
+    case 'BindingRestElement':
+      if (node.BindingIdentifier) {
+        return BoundNames(node.BindingIdentifier);
+      }
+      return BoundNames(node.BindingPattern!);
+    case 'BindingRestProperty':
+      return BoundNames(node.BindingIdentifier);
+    case 'BindingElement':
+      return BoundNames(node.BindingPattern);
+    case 'BindingProperty':
+      return BoundNames(node.BindingElement);
+    case 'ObjectBindingPattern': {
+      const names = BoundNames(node.BindingPropertyList);
+      if (node.BindingRestProperty) {
+        names.push(...BoundNames(node.BindingRestProperty));
+      }
+      return names;
+    }
+    case 'ArrayBindingPattern': {
+      const names = BoundNames(node.BindingElementList);
+      if (node.BindingRestElement) {
+        names.push(...BoundNames(node.BindingRestElement));
+      }
+      return names;
+    }
+    default:
+      return [];
+  }
+}

package/src/static-semantics/CharacterValue.mts

@@ -0,0 +1,112 @@
+import { OutOfRange } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { UTF16SurrogatePairToCodePoint } from './all.mts';
+import { Unicode, type CodePoint } from '#self';
+
+export type CharacterValueAcceptNode =
+  | ParseNode.RegExp.CharacterEscape
+  | ParseNode.RegExp.RegExpUnicodeEscapeSequence
+  | ParseNode.RegExp.ClassAtom
+  | ParseNode.RegExp.ClassEscape
+  | ParseNode.RegExp.ClassSetCharacter;
+
+/** https://tc39.es/ecma262/#sec-patterns-static-semantics-character-value */
+export function CharacterValue(node: CharacterValueAcceptNode): CodePoint {
+  switch (node.type) {
+    case 'CharacterEscape':
+      switch (node.production) {
+        case 'ControlEscape':
+          switch (node.ControlEscape) {
+            case 't':
+              return 0x0009 as CodePoint;
+            case 'n':
+              return 0x000A as CodePoint;
+            case 'v':
+              return 0x000B as CodePoint;
+            case 'f':
+              return 0x000C as CodePoint;
+            case 'r':
+              return 0x000D as CodePoint;
+            default:
+              throw OutOfRange.exhaustive(node.ControlEscape);
+          }
+        case 'AsciiLetter': {
+          // 1. Let ch be the code point matched by ControlLetter.
+          const ch = node.AsciiLetter;
+          // 2. Let i be ch's code point value.
+          const i = ch.codePointAt(0)!;
+          // 3. Return the remainder of dividing i by 32.
+          return i % 32 as CodePoint;
+        }
+        case 'HexEscapeSequence':
+          // 1. Return the numeric value of the code unit that is the SV of HexEscapeSequence.
+          return Number.parseInt(`${node.HexEscapeSequence.HexDigit_a}${node.HexEscapeSequence.HexDigit_b}`, 16) as CodePoint;
+        case 'RegExpUnicodeEscapeSequence':
+          return CharacterValue(node.RegExpUnicodeEscapeSequence);
+        case '0':
+          // 1. Return the code point value of U+0000 (NULL).
+          return 0x0000 as CodePoint;
+        case 'IdentityEscape': {
+          // 1. Let ch be the code point matched by IdentityEscape.
+          const ch = node.IdentityEscape.codePointAt(0)!;
+          // 2. Return the code point value of ch.
+          return ch as CodePoint;
+        }
+        default:
+          throw OutOfRange.exhaustive(node);
+      }
+    case 'RegExpUnicodeEscapeSequence':
+      switch (true) {
+        case 'Hex4Digits' in node:
+          return node.Hex4Digits as CodePoint;
+        case 'CodePoint' in node:
+          return node.CodePoint as CodePoint;
+        case 'HexTrailSurrogate' in node:
+          return UTF16SurrogatePairToCodePoint(node.HexLeadSurrogate!, node.HexTrailSurrogate!);
+        case 'HexLeadSurrogate' in node:
+          return node.HexLeadSurrogate as CodePoint;
+        default:
+          throw OutOfRange.nonExhaustive(node);
+      }
+    case 'ClassAtom':
+      switch (node.production) {
+        case '-':
+          // 1. Return the code point value of U+002D (HYPHEN-MINUS).
+          return 0x002D as CodePoint;
+        case 'SourceCharacter': {
+          // 1. Let ch be the code point matched by SourceCharacter.
+          const ch = node.SourceCharacter.codePointAt(0)!;
+          // 2. Return ch.
+          return ch as CodePoint;
+        }
+        case 'ClassEscape':
+          return CharacterValue(node.ClassEscape);
+        default:
+          throw OutOfRange.exhaustive(node);
+      }
+    case 'ClassEscape':
+      switch (node.production) {
+        case 'b':
+          // 1. Return the code point value of U+0008 (BACKSPACE).
+          return 0x0008 as CodePoint;
+        case '-':
+          // 1. Return the code point value of U+002D (HYPHEN-MINUS).
+          return 0x002D as CodePoint;
+        case 'CharacterEscape':
+          return CharacterValue(node.CharacterEscape);
+        case 'CharacterClassEscape':
+          throw OutOfRange.nonExhaustive(node);
+        default:
+          throw OutOfRange.exhaustive(node);
+      }
+    case 'ClassSetCharacter': {
+      if (node.production === 'CharacterEscape') {
+        return CharacterValue(node.CharacterEscape);
+      } else {
+        return Unicode.toCodePoint(node.UnicodeCharacter);
+      }
+    }
+    default:
+      throw OutOfRange.exhaustive(node);
+  }
+}

package/src/static-semantics/CodePointAt.mts

@@ -0,0 +1,53 @@
+import { X } from '../completion.mts';
+import { UTF16SurrogatePairToCodePoint } from './all.mts';
+import { Assert } from '#self';
+import { isLeadingSurrogate, isTrailingSurrogate, type CodePoint } from '#self';
+
+/** https://tc39.es/ecma262/#sec-codepointat */
+export function CodePointAt(string: string, position: number) {
+  // 1 .Let size be the length of string.
+  const size = string.length;
+  // 2. Assert: position ≥ 0 and position < size.
+  Assert(position >= 0 && position < size);
+  // 3. Let first be the code unit at index position within string.
+  const first = string.charCodeAt(position);
+  // 4. Let cp be the code point whose numeric value is that of first.
+  let cp = first;
+  // 5. If first is not a leading surrogate or trailing surrogate, then
+  if (!isLeadingSurrogate(first) && !isTrailingSurrogate(first)) {
+    // a. Return the Record { [[CodePoint]]: cp, [[CodeUnitCount]]: 1, [[IsUnpairedSurrogate]]: false }.
+    return {
+      CodePoint: cp as CodePoint,
+      CodeUnitCount: 1,
+      IsUnpairedSurrogate: false,
+    };
+  }
+  // 6. If first is a trailing surrogate or position + 1 = size, then
+  if (isTrailingSurrogate(first) || position + 1 === size) {
+    // a. Return the Record { [[CodePoint]]: cp, [[CodeUnitCount]]: 1, [[IsUnpairedSurrogate]]: true }.
+    return {
+      CodePoint: cp as CodePoint,
+      CodeUnitCount: 1,
+      IsUnpairedSurrogate: true,
+    };
+  }
+  // 7. Let second be the code unit at index position + 1 within string.
+  const second = string.charCodeAt(position + 1);
+  // 8. If seconds is not a trailing surrogate, then
+  if (!isTrailingSurrogate(second)) {
+    // a. Return the Record { [[CodePoint]]: cp, [[CodeUnitCount]]: 1, [[IsUnpairedSurrogate]]: true }.
+    return {
+      CodePoint: cp as CodePoint,
+      CodeUnitCount: 1,
+      IsUnpairedSurrogate: true,
+    };
+  }
+  // 9. Set cp to ! UTF16SurrogatePairToCodePoint(first, second).
+  cp = X(UTF16SurrogatePairToCodePoint(first, second));
+  // 10. Return the Record { [[CodePoint]]: cp, [[CodeUnitCount]]: 2, [[IsUnpairedSurrogate]]: false }.
+  return {
+    CodePoint: cp as CodePoint,
+    CodeUnitCount: 2,
+    IsUnpairedSurrogate: false,
+  };
+}

package/src/static-semantics/CodePointsToString.mts

@@ -0,0 +1,15 @@
+import { UTF16EncodeCodePoint } from './all.mts';
+import type { CodePoint } from '#self';
+
+/** https://tc39.es/ecma262/#sec-codepointstostring */
+export function CodePointsToString(text: string) {
+  // 1. Let result be the empty String.
+  let result = '';
+  // 2. For each code point cp in text, do
+  for (const cp of text) {
+    // a. Set result to the string-concatenation of result and UTF16EncodeCodePoint(cp).
+    result += UTF16EncodeCodePoint(cp.codePointAt(0)! as CodePoint);
+  }
+  // 3. Return result.
+  return result;
+}

package/src/static-semantics/ConstructorMethod.mts

@@ -0,0 +1,10 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { PropName } from './all.mts';
+
+/** https://tc39.es/ecma262/#sec-static-semantics-constructormethod */
+// ClassElementList :
+//   ClassElement
+//   ClassElementList ClassElement
+export function ConstructorMethod(ClassElementList: ParseNode.ClassElementList): ParseNode.MethodDefinition | undefined {
+  return ClassElementList.find((ClassElement) => ClassElement.static === false && PropName(ClassElement) === 'constructor') as ParseNode.MethodDefinition;
+}

package/src/static-semantics/ContainsArguments.mts

@@ -0,0 +1,33 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+/** https://tc39.es/ecma262/#sec-static-semantics-containsarguments */
+export function ContainsArguments(node: ParseNode): ParseNode.IdentifierReference | null {
+  switch (node.type) {
+    case 'IdentifierReference':
+      if (node.name === 'arguments') {
+        return node;
+      }
+      return null;
+    case 'FunctionDeclaration':
+    case 'FunctionExpression':
+    case 'MethodDefinition':
+    case 'GeneratorMethod':
+    case 'GeneratorDeclaration':
+    case 'GeneratorExpression':
+    case 'AsyncMethod':
+    case 'AsyncFunctionDeclaration':
+    case 'AsyncFunctionExpression':
+      return null;
+    default:
+      for (const value of Object.values(node)) {
+        // TODO(ts): This function does not accept a ParseNode[], when isArray(value), ContainsArguments should never return a result?
+        if ((value?.type || Array.isArray(value))) {
+          const maybe = ContainsArguments(value);
+          if (maybe) {
+            return maybe;
+          }
+        }
+      }
+      return null;
+  }
+}

package/src/static-semantics/ContainsExpression.mts

@@ -0,0 +1,59 @@
+import { OutOfRange, isArray } from '../utils/language.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+export function ContainsExpression(node: ParseNode | readonly ParseNode[]): boolean {
+  if (isArray(node)) {
+    for (const n of node) {
+      if (ContainsExpression(n)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  switch (node.type) {
+    case 'SingleNameBinding':
+      return !!node.Initializer;
+    case 'BindingElement':
+      if (ContainsExpression(node.BindingPattern)) {
+        return true;
+      }
+      return !!node.Initializer;
+    case 'ObjectBindingPattern':
+      if (ContainsExpression(node.BindingPropertyList)) {
+        return true;
+      }
+      if (node.BindingRestProperty) {
+        return ContainsExpression(node.BindingRestProperty);
+      }
+      return false;
+    case 'BindingProperty':
+      if (node.PropertyName && 'ComputedPropertyName' in node.PropertyName && node.PropertyName.ComputedPropertyName) {
+        return true;
+      }
+      return ContainsExpression(node.BindingElement);
+    case 'BindingRestProperty':
+      if (node.BindingIdentifier) {
+        return false;
+      }
+      // TODO(ts): BindingRestProperty and BindingElement is different. Is there missing a case?
+      // @ts-expect-error
+      return ContainsExpression((node as ParseNode.BindingElement).BindingPattern);
+    case 'ArrayBindingPattern':
+      if (ContainsExpression(node.BindingElementList)) {
+        return true;
+      }
+      if (node.BindingRestElement) {
+        return ContainsExpression(node.BindingRestElement);
+      }
+      return false;
+    case 'BindingRestElement':
+      if (node.BindingIdentifier) {
+        return false;
+      }
+      return ContainsExpression(node.BindingPattern!);
+    case 'Elision':
+      return false;
+    default:
+      throw OutOfRange.nonExhaustive(node);
+  }
+}

package/src/static-semantics/ContainsUsing.mts

@@ -0,0 +1,15 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { IsAwaitUsingDeclaration } from './IsAwaitUsingDeclaration.mts';
+import { IsUsingDeclaration } from './IsUsingDeclaration.mts';
+
+/** https://tc39.es/ecma262/#sec-static-semantics-containsusing */
+export function ContainsUsing(node: ParseNode.StatementList | ParseNode.StatementListItem): boolean {
+  // StatementList : StatementList StatementListItem
+  if (!('type' in node)) {
+    return node.some(ContainsUsing);
+  }
+
+  // StatementListItem : Statement
+  // StatementListItem : Declaration
+  return IsUsingDeclaration(node) || IsAwaitUsingDeclaration(node);
+}

package/src/static-semantics/DeclarationPart.mts

@@ -0,0 +1,5 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+
+export function DeclarationPart<T extends ParseNode>(node: T): T {
+  return node;
+}

package/src/static-semantics/ExpectedArgumentCount.mts

@@ -0,0 +1,26 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { HasInitializer } from './all.mts';
+
+export function ExpectedArgumentCount(FormalParameterList: ParseNode.FormalParameters) {
+  if (FormalParameterList.length === 0) {
+    return 0;
+  }
+
+  let count = 0;
+  for (const FormalParameter of FormalParameterList.slice(0, -1)) {
+    const BindingElement = FormalParameter;
+    if (HasInitializer(BindingElement)) {
+      return count;
+    }
+    count += 1;
+  }
+
+  const last = FormalParameterList[FormalParameterList.length - 1];
+  if (last.type === 'BindingRestElement') {
+    return count;
+  }
+  if (HasInitializer(last)) {
+    return count;
+  }
+  return count + 1;
+}