@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/parser/FunctionParser.mts

@@ -0,0 +1,398 @@
+import { IsSimpleParameterList } from '../static-semantics/all.mts';
+import { type Mutable } from '../utils/language.mts';
+import { Throw } from '../host-defined/error-messages.mts';
+import { getDeclarations, type ArrowInfo } from './Scope.mts';
+import { isReservedWordStrict, Token } from './tokens.mts';
+import { IdentifierParser } from './IdentifierParser.mts';
+import type { ParseNode, ParseNodesByType } from './ParseNode.mts';
+
+export enum FunctionKind {
+  NORMAL = 0,
+  ASYNC = 1,
+}
+
+interface ArrowParameterConversions {
+  'IdentifierReference': ParseNode.SingleNameBinding;
+  'BindingRestElement': ParseNode.BindingRestElement;
+  'Elision': ParseNode.Elision;
+  'ArrayLiteral': ParseNode.BindingElement;
+  'ObjectLiteral': ParseNode.BindingElement;
+  'AssignmentExpression': ParseNode.SingleNameBinding | ParseNode.BindingElement;
+  'CoverInitializedName': ParseNode.SingleNameBinding;
+  'PropertyDefinition': ParseNode.BindingRestProperty | ParseNode.BindingProperty;
+  'SpreadElement': ParseNode.BindingRestElement;
+  'AssignmentRestElement': ParseNode.BindingRestElement;
+}
+
+type ConvertArrowParameterResult<T> =
+  T extends keyof ArrowParameterConversions ? ArrowParameterConversions[T] : never;
+
+interface ConciseBodyInfo {
+  'ConciseBody': ParseNode.ConciseBodyLike;
+  'AsyncConciseBody': ParseNode.AsyncConciseBodyLike;
+}
+
+export abstract class FunctionParser extends IdentifierParser {
+  abstract parseStatementList(token: string | Token, directives?: readonly string[]): ParseNode.StatementList;
+
+  abstract parseAssignmentExpression(): ParseNode.AssignmentExpressionOrHigher;
+
+  abstract parseBindingElement(): ParseNode.BindingElementLike;
+
+  abstract parseBindingRestElement(): ParseNode.BindingRestElement;
+
+  // FunctionDeclaration :
+  //   `function` BindingIdentifier `(` FormalParameters `)` `{` FunctionBody `}`
+  //   [+Default] `function` `(` FormalParameters `)` `{` FunctionBody `}`
+  // FunctionExpression :
+  //   `function` BindingIdentifier? `(` FormalParameters `)` `{` FunctionBody `}`
+  // GeneratorDeclaration :
+  //   `function` `*` BindingIdentifier `(` FormalParameters `)` `{` GeneratorBody `}`
+  //   [+Default] `function` `*` `(` FormalParameters `)` `{` GeneratorBody `}`
+  // GeneratorExpression :
+  //   `function` BindingIdentifier? `(` FormalParameters `)` `{` GeneratorBody `}`
+  // AsyncGeneratorDeclaration :
+  //   `async` `function` `*` BindingIdentifier `(` FormalParameters `)` `{` AsyncGeneratorBody `}`
+  //   [+Default] `async` `function` `*` `(` FormalParameters `)` `{` AsyncGeneratorBody `}`
+  // AsyncGeneratorExpression :
+  //   `async` `function` BindingIdentifier? `(` FormalParameters `)` `{` AsyncGeneratorBody `}`
+  // AsyncFunctionDeclaration :
+  //   `async` `function` BindingIdentifier `(` FormalParameters `)` `{` FunctionBody `}`
+  //   [+Default] `async` `function` `(` FormalParameters `)` `{` AsyncBody `}`
+  // Async`FunctionExpression :
+  //   `async` `function` BindingIdentifier? `(` FormalParameters `)` `{` AsyncBody `}`
+  parseFunction(isExpression: boolean, kind: FunctionKind) {
+    const isAsync = kind === FunctionKind.ASYNC;
+    const node = this.startNode<ParseNode.FunctionLike>();
+    if (isAsync) {
+      this.expect('async');
+    }
+    this.expect(Token.FUNCTION);
+    const isGenerator = this.eat(Token.MUL);
+    if (!this.test(Token.LPAREN)) {
+      node.BindingIdentifier = this.scope.with({
+        await: isExpression ? false : undefined,
+        yield: isExpression ? false : undefined,
+      }, () => this.parseBindingIdentifier());
+      if (!isExpression) {
+        this.scope.declare(node.BindingIdentifier, 'function');
+      }
+    } else if (isExpression === false && !this.scope.isDefault()) {
+      this.unexpected();
+    } else {
+      node.BindingIdentifier = null;
+    }
+
+    this.scope.with({
+      default: false,
+      await: isAsync,
+      yield: isGenerator,
+      lexical: true,
+      variable: true,
+      variableFunctions: true,
+      parameters: false,
+      classStaticBlock: false,
+      newTarget: true,
+    }, () => {
+      this.scope.arrowInfoStack.push(null);
+
+      node.FormalParameters = this.parseFormalParameters();
+
+      const body = this.parseFunctionBody(isAsync, isGenerator, false);
+      this.setFunctionBodyGeneric(node, body.type, body);
+
+      if (node.BindingIdentifier) {
+        if (body.strict && (node.BindingIdentifier.name === 'eval' || node.BindingIdentifier.name === 'arguments' || isReservedWordStrict(node.BindingIdentifier.name))) {
+          this.addEarlyError(Throw.SyntaxError('$1 cannot be used as an identifier in strict mode', node.BindingIdentifier.name), node.BindingIdentifier);
+        }
+        if (isExpression) {
+          if (this.scope.hasYield() && node.BindingIdentifier.name === 'yield') {
+            this.addEarlyError(Throw.SyntaxError('yield cannot be used as an identifier inside generator functions'), node.BindingIdentifier);
+          }
+          if (this.scope.hasAwait() && node.BindingIdentifier.name === 'await') {
+            this.addEarlyError(Throw.SyntaxError('await cannot be used as an identifier inside async functions'), node.BindingIdentifier);
+          }
+        }
+      }
+
+      this.validateFormalParameters(node.FormalParameters, body);
+
+      this.scope.arrowInfoStack.pop();
+    });
+
+    const name = `${isAsync ? 'Async' : ''}${isGenerator ? 'Generator' : 'Function'}${isExpression ? 'Expression' : 'Declaration'}` as const;
+    return this.finishNode(node, name);
+  }
+
+  private setFunctionBodyGeneric<T extends ParseNode.FunctionBodyLike['type']>(node: { [P in T]?: ParseNodesByType[T] }, type: T, body: ParseNodesByType[T]) {
+    node[type] = body;
+  }
+
+  validateFormalParameters(parameters: ParseNode.FormalParameters, body: ParseNode.FunctionBodyLike | ParseNode.ConciseBody | ParseNode.AsyncConciseBody, wantsUnique = false) {
+    const isStrict = body.strict;
+    const hasStrictDirective = body.directives && body.directives.includes('use strict');
+    if (wantsUnique === false && !IsSimpleParameterList(parameters)) {
+      wantsUnique = true;
+    }
+
+    if (hasStrictDirective) {
+      parameters.forEach((p) => {
+        if (p.type !== 'SingleNameBinding' || p.Initializer) {
+          this.addEarlyError(Throw.SyntaxError('Non-simple parameter cannot be used with "use strict" directive'), p);
+        }
+      });
+    }
+
+    const names = new Set();
+    getDeclarations(parameters)
+      .forEach((d) => {
+        if (isStrict) {
+          if (d.name === 'arguments' || d.name === 'eval') {
+            this.addEarlyError(Throw.SyntaxError('$1 cannot be used as an identifier in strict mode', d.name), d.node);
+          }
+          if (isReservedWordStrict(d.name)) {
+            this.addEarlyError(Throw.SyntaxError('$1 cannot be used as an identifier in strict mode', d.name), d.node);
+          }
+        }
+        if (isStrict || wantsUnique) {
+          if (names.has(d.name)) {
+            this.addEarlyError(Throw.SyntaxError('Identifier has already been declared'), d.node);
+          } else {
+            names.add(d.name);
+          }
+        }
+      });
+  }
+
+  convertArrowParameter<T extends ParseNode>(node: T): ConvertArrowParameterResult<T['type']>;
+
+  convertArrowParameter(node: ParseNode) {
+    switch (node.type) {
+      case 'IdentifierReference': {
+        const BindingIdentifier = this.repurpose(node, 'BindingIdentifier');
+        const SingleNameBinding = this.startNode<ParseNode.SingleNameBinding>(node);
+        SingleNameBinding.BindingIdentifier = BindingIdentifier;
+        SingleNameBinding.Initializer = null;
+        this.scope.declare(node, 'parameter');
+        return this.finishNode(SingleNameBinding, 'SingleNameBinding');
+      }
+      case 'BindingRestElement':
+        this.scope.declare(node, 'parameter');
+        return node;
+      case 'Elision':
+        return node;
+      case 'ArrayLiteral': {
+        const BindingPattern = this.repurpose(node, 'ArrayBindingPattern', (asNew, asOld, asPartial) => {
+          const BindingElementList: Mutable<ParseNode.BindingElementList> = [];
+          asNew.BindingElementList = BindingElementList;
+          for (const [i, p] of asOld.ElementList.entries()) {
+            const c = this.convertArrowParameter(p);
+            if (c.type === 'BindingRestElement') {
+              if (i !== asOld.ElementList.length - 1) {
+                this.addEarlyError(Throw.SyntaxError('Rest element must be last element'), c);
+              }
+              asNew.BindingRestElement = c;
+            } else {
+              BindingElementList.push(c);
+            }
+          }
+          delete asPartial.ElementList;
+        });
+        const BindingElement = this.startNode<ParseNode.BindingElement>(node);
+        BindingElement.BindingPattern = BindingPattern;
+        BindingElement.Initializer = null;
+        return this.finishNode(BindingElement, 'BindingElement');
+      }
+      case 'ObjectLiteral': {
+        const BindingPattern = this.repurpose(node, 'ObjectBindingPattern', (asNew, asOld, asPartial) => {
+          const BindingPropertyList: Mutable<ParseNode.BindingPropertyList> = [];
+          asNew.BindingPropertyList = BindingPropertyList;
+          for (const p of asOld.PropertyDefinitionList) {
+            const c = this.convertArrowParameter(p);
+            if (c.type === 'BindingRestProperty') {
+              asNew.BindingRestProperty = c;
+            } else {
+              BindingPropertyList.push(c);
+            }
+          }
+          delete asPartial.PropertyDefinitionList;
+        });
+        const BindingElement = this.startNode<ParseNode.BindingElement>(node);
+        BindingElement.BindingPattern = BindingPattern;
+        BindingElement.Initializer = null;
+        return this.finishNode(BindingElement, 'BindingElement');
+      }
+      case 'AssignmentExpression': {
+        const result = this.convertArrowParameter(node.LeftHandSideExpression) as ParseNode.Unfinished<ParseNode.SingleNameBinding | ParseNode.BindingElement>;
+        result.Initializer = node.AssignmentExpression;
+        return result as ParseNode.SingleNameBinding | ParseNode.BindingElement;
+      }
+      case 'CoverInitializedName': {
+        const SingleNameBinding = this.repurpose(node, 'SingleNameBinding', (asNew, asOld, asPartial) => {
+          asNew.BindingIdentifier = this.repurpose(asOld.IdentifierReference, 'BindingIdentifier');
+          delete asPartial.IdentifierReference;
+        });
+        this.scope.declare(SingleNameBinding, 'parameter');
+        return SingleNameBinding;
+      }
+      case 'PropertyDefinition': {
+        let BindingProperty: ParseNode.BindingProperty | ParseNode.BindingRestProperty;
+        if (node.PropertyName === null) {
+          BindingProperty = this.repurpose(node, 'BindingRestProperty', (asNew, asOld, asPartial) => {
+            asNew.BindingIdentifier = this.repurpose(asOld.AssignmentExpression, 'BindingIdentifier');
+            delete asPartial.AssignmentExpression;
+          });
+        } else {
+          BindingProperty = this.repurpose(node, 'BindingProperty', (asNew, asOld, asPartial) => {
+            asNew.BindingElement = this.convertArrowParameter(asOld.AssignmentExpression);
+            delete asPartial.AssignmentExpression;
+          });
+        }
+        this.scope.declare(node, 'parameter');
+        return BindingProperty;
+      }
+      case 'SpreadElement':
+      case 'AssignmentRestElement': {
+        const BindingRestElement = this.repurpose(node, 'BindingRestElement', (asNew, asOld, asPartial) => {
+          const { AssignmentExpression } = asOld;
+          if (AssignmentExpression.type === 'AssignmentExpression') {
+            this.addEarlyError(Throw.SyntaxError('Invalid assignment in rest element'), node);
+          } else if (AssignmentExpression.type === 'IdentifierReference') {
+            asNew.BindingIdentifier = this.repurpose(AssignmentExpression, 'BindingIdentifier');
+          } else {
+            asNew.BindingPattern = this.convertArrowParameter(AssignmentExpression).BindingPattern;
+          }
+          delete asPartial.AssignmentExpression;
+        });
+        this.scope.declare(BindingRestElement, 'parameter');
+        return BindingRestElement;
+      }
+      default:
+        this.addEarlyError(Throw.SyntaxError('Unexpected token'), node);
+        return node;
+    }
+  }
+
+  parseArrowFunction(node: ParseNode.Unfinished<ParseNode.ArrowFunction | ParseNode.AsyncArrowFunction>, { arrowInfo, Arguments }: { arrowInfo?: ArrowInfo, Arguments: ParseNode.CoverParenthesizedExpressionAndArrowParameterList['Arguments'] }, kind: FunctionKind): ParseNode.ArrowFunction | ParseNode.AsyncArrowFunction {
+    const isAsync = kind === FunctionKind.ASYNC;
+    this.expect(Token.ARROW);
+    if (arrowInfo) {
+      const beforeArrow = <T extends { location: { startIndex: number } }>(nodes: readonly T[]) => nodes
+        .filter((n) => n.location.startIndex < this.currentToken.startIndex);
+      beforeArrow(arrowInfo.awaitExpressions).forEach((e) => {
+        this.addEarlyError(Throw.SyntaxError('await cannot be used inside parameters of arrow functions'), e);
+      });
+      beforeArrow(arrowInfo.yieldExpressions).forEach((e) => {
+        this.addEarlyError(Throw.SyntaxError('yield cannot be used inside parameters of arrow functions'), e);
+      });
+      if (isAsync) {
+        beforeArrow(arrowInfo.awaitIdentifiers).forEach((e) => {
+          this.addEarlyError(Throw.SyntaxError('await cannot be used as an identifier inside parameters of async functions'), e);
+        });
+      }
+    }
+    this.scope.with({
+      default: false,
+      lexical: true,
+      variable: true,
+    }, () => {
+      node.ArrowParameters = this.scope.with({
+        parameters: true,
+      }, () => Arguments.map((p) => this.convertArrowParameter(p)));
+      this.scope.enterArrowBody();
+      const body = this.parseConciseBody(isAsync);
+      this.scope.exitArrowBody();
+      this.validateFormalParameters(node.ArrowParameters, body, true);
+      let bodyType: 'ConciseBody' | 'AsyncConciseBody';
+      if (body.type === 'FunctionBody') {
+        bodyType = 'ConciseBody';
+      } else if (body.type === 'AsyncBody') {
+        bodyType = 'AsyncConciseBody';
+      } else {
+        bodyType = body.type;
+      }
+      this.setConciseBodyGeneric(node, bodyType, body);
+    });
+    return this.finishNode(node, `${isAsync ? 'Async' : ''}ArrowFunction`);
+  }
+
+  private setConciseBodyGeneric<T extends 'ConciseBody' | 'AsyncConciseBody'>(node: { [P in T]?: ConciseBodyInfo[T] }, type: T, body: ConciseBodyInfo[T]) {
+    node[type] = body;
+  }
+
+  parseConciseBody(isAsync: boolean): ParseNode.ConciseBody | ParseNode.FunctionBody | ParseNode.AsyncConciseBody | ParseNode.AsyncBody {
+    if (this.test(Token.LBRACE)) {
+      return this.parseFunctionBody(isAsync, false, true) as ParseNode.FunctionBody | ParseNode.AsyncBody;
+    }
+    const asyncBody = this.startNode<ParseNode.ConciseBody | ParseNode.AsyncConciseBody>();
+    const exprBody = this.startNode<ParseNode.ExpressionBody>();
+    this.scope.with({ await: isAsync }, () => {
+      exprBody.AssignmentExpression = this.parseAssignmentExpression();
+    });
+    asyncBody.ExpressionBody = this.finishNode(exprBody, 'ExpressionBody');
+    return this.finishNode(asyncBody, `${isAsync ? 'Async' : ''}ConciseBody`);
+  }
+
+  // FormalParameter : BindingElement
+  parseFormalParameter(): ParseNode.FormalParameter {
+    return this.parseBindingElement();
+  }
+
+  parseFormalParameters(): ParseNode.FormalParameters {
+    this.expect(Token.LPAREN);
+    if (this.eat(Token.RPAREN)) {
+      return [];
+    }
+    const params: Mutable<ParseNode.FormalParameters> = [];
+    this.scope.with({ parameters: true }, () => {
+      while (true) {
+        if (this.test(Token.ELLIPSIS)) {
+          const element = this.parseBindingRestElement();
+          this.scope.declare(element, 'parameter');
+          params.push(element);
+          this.expect(Token.RPAREN);
+          break;
+        } else {
+          const formal = this.parseFormalParameter();
+          this.scope.declare(formal, 'parameter');
+          params.push(formal);
+        }
+        if (this.eat(Token.RPAREN)) {
+          break;
+        }
+        this.expect(Token.COMMA);
+        if (this.eat(Token.RPAREN)) {
+          break;
+        }
+      }
+    });
+    return params;
+  }
+
+  parseUniqueFormalParameters(): ParseNode.UniqueFormalParameters {
+    return this.parseFormalParameters();
+  }
+
+  parseFunctionBody(isAsync: boolean, isGenerator: boolean, isArrow: boolean): ParseNode.FunctionBodyLike {
+    const node = this.startNode<ParseNode.FunctionBodyLike>();
+    this.expect(Token.LBRACE);
+    this.scope.with({
+      newTarget: isArrow ? undefined : true,
+      return: true,
+      await: isAsync,
+      yield: isGenerator,
+      label: 'boundary',
+    }, () => {
+      node.directives = [];
+      node.FunctionStatementList = this.parseStatementList(Token.RBRACE, node.directives);
+      node.strict = node.strict || node.directives.includes('use strict');
+    });
+    let name: ParseNode.FunctionBodyLike['type'];
+    if (isAsync) {
+      name = isGenerator ? 'AsyncGeneratorBody' : 'AsyncBody';
+    } else {
+      name = isGenerator ? 'GeneratorBody' : 'FunctionBody';
+    }
+    return this.finishNode(node, name);
+  }
+}

package/src/parser/IdentifierParser.mts

@@ -0,0 +1,149 @@
+import { Throw } from '../host-defined/error-messages.mts';
+import {
+  Token,
+  isKeyword,
+  isReservedWordStrict,
+  isKeywordRaw,
+} from './tokens.mts';
+import { BaseParser } from './BaseParser.mts';
+import type { ParseNode } from './ParseNode.mts';
+import { type Locatable } from './Lexer.mts';
+
+export abstract class IdentifierParser extends BaseParser {
+  // IdentifierName
+  parseIdentifierName() {
+    const node = this.startNode<ParseNode.IdentifierName>();
+    const p = this.peek();
+    if (p.type === Token.IDENTIFIER
+        || p.type === Token.ESCAPED_KEYWORD
+        || isKeyword(p.type)) {
+      node.name = this.next().valueAsString();
+    } else {
+      this.unexpected();
+    }
+    return this.finishNode(node, 'IdentifierName');
+  }
+
+  // BindingIdentifier :
+  //   Identifier
+  //   `yield`
+  //   `await`
+  parseBindingIdentifier() {
+    const node = this.startNode<ParseNode.BindingIdentifier>();
+    const token = this.next();
+    switch (token.type) {
+      case Token.IDENTIFIER:
+        node.name = token.valueAsString();
+        break;
+      case Token.ESCAPED_KEYWORD:
+        node.name = token.valueAsString();
+        break;
+      case Token.YIELD:
+        node.name = 'yield';
+        break;
+      case Token.AWAIT:
+        node.name = 'await';
+        break;
+      default:
+        this.unexpected(token);
+    }
+    if (node.name === 'await') {
+      for (let i = this.scope.arrowInfoStack.length - 1; i >= 0; i -= 1) {
+        const arrowInfo = this.scope.arrowInfoStack[i];
+        if (!arrowInfo) {
+          break;
+        }
+        if (arrowInfo.isAsync) {
+          arrowInfo.awaitIdentifiers.push(node as ParseNode.BindingIdentifier);
+          break;
+        }
+      }
+    }
+    if (this.isStrictMode() && (node.name === 'eval' || node.name === 'arguments')) {
+      this.addEarlyError(Throw.SyntaxError('$1 cannot be used as an identifier in strict mode', node.name), token);
+    }
+    this.validateIdentifierReference(node.name, token);
+    return this.finishNode(node, 'BindingIdentifier');
+  }
+
+  // IdentifierReference :
+  //   Identifier
+  //   [~Yield] `yield`
+  //   [~Await] `await`
+  parseIdentifierReference() {
+    const node = this.startNode<ParseNode.IdentifierReference>();
+    const token = this.next();
+    node.escaped = token.escaped;
+    switch (token.type) {
+      case Token.IDENTIFIER:
+        node.name = token.valueAsString();
+        break;
+      case Token.ESCAPED_KEYWORD:
+        node.name = token.valueAsString();
+        break;
+      case Token.YIELD:
+        if (this.scope.hasYield()) {
+          this.unexpected(token);
+        }
+        node.name = 'yield';
+        break;
+      case Token.AWAIT:
+        if (this.scope.hasAwait()) {
+          this.unexpected(token);
+        }
+        node.name = 'await';
+        break;
+      default:
+        this.unexpected(token);
+    }
+    if (node.name === 'await') {
+      for (let i = this.scope.arrowInfoStack.length - 1; i >= 0; i -= 1) {
+        const arrowInfo = this.scope.arrowInfoStack[i];
+        if (!arrowInfo) {
+          break;
+        }
+        if (arrowInfo.isAsync) {
+          arrowInfo.awaitIdentifiers.push(node as ParseNode.IdentifierReference);
+          break;
+        }
+      }
+    }
+    this.validateIdentifierReference(node.name, token);
+    return this.finishNode(node, 'IdentifierReference');
+  }
+
+  validateIdentifierReference(name: string, token: Locatable) {
+    if (name === 'yield' && (this.scope.hasYield() || this.scope.isModule())) {
+      this.addEarlyError(Throw.SyntaxError('yield cannot be used as an identifier inside generator functions or modules'), token);
+    }
+    if (name === 'await' && (this.scope.hasAwait() || this.scope.isModule())) {
+      this.addEarlyError(Throw.SyntaxError('await cannot be used as an identifier inside async functions or modules'), token);
+    }
+    if (this.isStrictMode() && isReservedWordStrict(name)) {
+      this.addEarlyError(Throw.SyntaxError('$1 cannot be used as an identifier in strict mode', name), token);
+    }
+    if (this.scope.inClassStaticBlock() && name === 'arguments') {
+      this.addEarlyError(Throw.SyntaxError('"arguments" cannot be used as an identifier in class static block'), token);
+    }
+    if (name !== 'yield' && name !== 'await' && isKeywordRaw(name)) {
+      this.addEarlyError(Throw.SyntaxError('$1 cannot be used as an identifier', name), token);
+    }
+  }
+
+  // LabelIdentifier :
+  //   Identifier
+  //   [~Yield] `yield`
+  //   [~Await] `await`
+  parseLabelIdentifier() {
+    const node = this.parseIdentifierReference();
+    return this.repurpose(node, 'LabelIdentifier');
+  }
+
+  // PrivateIdentifier ::
+  //   `#` IdentifierName
+  parsePrivateIdentifier() {
+    const node = this.startNode<ParseNode.PrivateIdentifier>();
+    node.name = this.expect(Token.PRIVATE_IDENTIFIER).valueAsString();
+    return this.finishNode(node, 'PrivateIdentifier');
+  }
+}

package/src/parser/LanguageParser.mts

@@ -0,0 +1,140 @@
+import type { Mutable } from '../utils/language.mts';
+import { ContainsUsing } from '../static-semantics/ContainsUsing.mts';
+import { ModuleParser } from './ModuleParser.mts';
+import type { ParseNode } from './ParseNode.mts';
+import { Token } from './tokens.mts';
+import { Throw } from '#self';
+
+export abstract class LanguageParser extends ModuleParser {
+  // Script : ScriptBody?
+  parseScript(): ParseNode.Script {
+    this.skipHashbangComment();
+    const node = this.startNode<ParseNode.Script>();
+    if (this.eat(Token.EOS)) {
+      node.ScriptBody = null;
+    } else {
+      node.ScriptBody = this.parseScriptBody();
+      if (ContainsUsing(node.ScriptBody.StatementList)) {
+        this.addEarlyError(Throw.SyntaxError('Using declarations are not allowed at the top level of a Script'), node.ScriptBody);
+      }
+    }
+    Object.defineProperty(node, 'sourceText', {
+      configurable: true,
+      get: () => this.source,
+    });
+    return this.finishNode(node, 'Script');
+  }
+
+  // ScriptBody : StatementList
+  parseScriptBody(): ParseNode.ScriptBody {
+    const node = this.startNode<ParseNode.ScriptBody>();
+    this.scope.with({
+      in: true,
+      lexical: true,
+      variable: true,
+      variableFunctions: true,
+    }, () => {
+      const directives: string[] = [];
+      node.StatementList = this.parseStatementList(Token.EOS, directives);
+      node.strict = directives.includes('use strict');
+    });
+    Object.defineProperty(node, 'sourceText', {
+      configurable: true,
+      get: () => this.source,
+    });
+    return this.finishNode(node, 'ScriptBody');
+  }
+
+  // Module : ModuleBody?
+  parseModule(): ParseNode.Module {
+    this.skipHashbangComment();
+    return this.scope.with({
+      module: true,
+      strict: true,
+      in: true,
+      importMeta: true,
+      await: true,
+      lexical: true,
+      variable: true,
+    }, () => {
+      const node = this.startNode<ParseNode.Module>();
+      if (this.eat(Token.EOS)) {
+        node.ModuleBody = null;
+      } else {
+        node.ModuleBody = this.parseModuleBody();
+      }
+      this.scope.undefinedExports.forEach((importNode, name) => {
+        this.addEarlyError(Throw.SyntaxError('Module undefined export $1', name), importNode);
+      });
+      node.hasTopLevelAwait = this.state.hasTopLevelAwait;
+      Object.defineProperty(node, 'sourceText', {
+        configurable: true,
+        get: () => this.source,
+      });
+      return this.finishNode(node, 'Module');
+    });
+  }
+
+  // ModuleBody :
+  //   ModuleItemList
+  parseModuleBody(): ParseNode.ModuleBody {
+    const node = this.startNode<ParseNode.ModuleBody>();
+    node.ModuleItemList = this.parseModuleItemList();
+    Object.defineProperty(node, 'sourceText', {
+      configurable: true,
+      get: () => this.source,
+    });
+    return this.finishNode(node, 'ModuleBody');
+  }
+
+  // ModuleItemList :
+  //   ModuleItem
+  //   ModuleItemList ModuleItem
+  //
+  // ModuleItem :
+  //   ImportDeclaration
+  //   ExportDeclaration
+  //   StatementListItem
+  parseModuleItemList(): ParseNode.ModuleItemList {
+    const moduleItemList: Mutable<ParseNode.ModuleItemList> = [];
+    while (!this.eat(Token.EOS)) {
+      switch (this.peek().type) {
+        case Token.IMPORT:
+          moduleItemList.push(this.parseImportDeclaration());
+          break;
+        case Token.EXPORT:
+          moduleItemList.push(this.parseExportDeclaration(null));
+          break;
+        case Token.AT: {
+          const decorators = this.parseDecorators();
+          if (this.peek().type === Token.EXPORT) {
+            // ModuleItem: DecoratorList `export` Declaration
+            const exports = this.parseExportDeclaration(decorators);
+            // TODO(decorator):
+            // ExportDeclaration : DecoratorList? `export` Declaration
+            //   It is a Syntax Error if DecoratorList is present and Declaration is not ClassDeclaration.
+            if (!exports.ClassDeclaration) {
+              this.addEarlyError(Throw.SyntaxError('Decorators can only be used to decorate classes'), exports.AssignmentExpression || exports.Declaration || exports.ExportFromClause || exports.FromClause || exports.HoistableDeclaration || exports.VariableStatement || exports.WithClause || exports);
+            }
+            //   It is a Syntax Error if DecoratorList is present, Declaration is a ClassDeclaration, and the DecoratorList of that ClassDeclaration is present.
+            // ExportDeclaration : DecoratorList? export default ClassDeclaration
+            //   It is a Syntax Error if DecoratorList is present and the DecoratorList of ClassDeclaration is present.
+            if (exports.ClassDeclaration && exports.ClassDeclaration.Decorators?.length) {
+              this.addEarlyError(Throw.SyntaxError('Decorators cannot appear on both sides of the export keyword'), exports.ClassDeclaration.Decorators[0]);
+            }
+            moduleItemList.push(exports);
+          } else {
+            // ModuleItem : DecoratorList ClassDeclaration
+            const classDecl = this.parseClassDeclaration(decorators);
+            moduleItemList.push(classDecl);
+          }
+          break;
+        }
+        default:
+          moduleItemList.push(this.parseStatementListItem());
+          break;
+      }
+    }
+    return moduleItemList;
+  }
+}