// @flow

import * as N from "../types";

import { types as tt, type TokenType } from "../tokenizer/types";

import ExpressionParser from "./expression";

import { lineBreak } from "../util/whitespace";

// Reused empty array added for node fields that are always empty.

const empty = [];

const loopLabel = { kind: "loop" },

switchLabel = { kind: "switch" };

export default class StatementParser extends ExpressionParser {

// ### Statement parsing

// Parse a program. Initializes the parser, reads any number of

// statements, and wraps them in a Program node. Optionally takes a

// `program` argument. If present, the statements will be appended

// to its body instead of creating a new node.

parseTopLevel(file: N.File, program: N.Program): N.File {

program.sourceType = this.options.sourceType;

program.interpreter = this.parseInterpreterDirective();

this.parseBlockBody(program, true, true, tt.eof);

file.program = this.finishNode(program, "Program");

file.comments = this.state.comments;

if (this.options.tokens) file.tokens = this.state.tokens;

return this.finishNode(file, "File");

}

// TODO

stmtToDirective(stmt: N.Statement): N.Directive {

const expr = stmt.expression;

const directiveLiteral = this.startNodeAt(expr.start, expr.loc.start);

const directive = this.startNodeAt(stmt.start, stmt.loc.start);

const raw = this.input.slice(expr.start, expr.end);

const val = (directiveLiteral.value = raw.slice(1, -1)); // remove quotes

this.addExtra(directiveLiteral, "raw", raw);

this.addExtra(directiveLiteral, "rawValue", val);

directive.value = this.finishNodeAt(

directiveLiteral,

"DirectiveLiteral",

expr.end,

expr.loc.end,

);

return this.finishNodeAt(directive, "Directive", stmt.end, stmt.loc.end);

}

parseInterpreterDirective(): N.InterpreterDirective | null {

if (!this.match(tt.interpreterDirective)) {

return null;

}

const node = this.startNode();

node.value = this.state.value;

this.next();

return this.finishNode(node, "InterpreterDirective");

}

// Parse a single statement.

//

// If expecting a statement and finding a slash operator, parse a

// regular expression literal. This is to handle cases like

// `if (foo) /blah/.exec(foo)`, where looking at the previous token

// does not help.

parseStatement(declaration: boolean, topLevel?: boolean): N.Statement {

if (this.match(tt.at)) {

this.parseDecorators(true);

}

return this.parseStatementContent(declaration, topLevel);

}

parseStatementContent(declaration: boolean, topLevel: ?boolean): N.Statement {

const starttype = this.state.type;

const node = this.startNode();

// Most types of statements are recognized by the keyword they

// start with. Many are trivial to parse, some require a bit of

// complexity.

switch (starttype) {

case tt._break:

case tt._continue:

// $FlowFixMe

return this.parseBreakContinueStatement(node, starttype.keyword);

case tt._debugger:

return this.parseDebuggerStatement(node);

case tt._do:

return this.parseDoStatement(node);

case tt._for:

return this.parseForStatement(node);

case tt._function:

if (this.lookahead().type === tt.dot) break;

if (!declaration) this.unexpected();

return this.parseFunctionStatement(node);

case tt._class:

if (!declaration) this.unexpected();

return this.parseClass(node, true);

case tt._if:

return this.parseIfStatement(node);

case tt._return:

return this.parseReturnStatement(node);

case tt._switch:

return this.parseSwitchStatement(node);

case tt._throw:

return this.parseThrowStatement(node);

case tt._try:

return this.parseTryStatement(node);

case tt._let:

case tt._const:

if (!declaration) this.unexpected(); // NOTE: falls through to _var

case tt._var:

return this.parseVarStatement(node, starttype);

case tt._while:

return this.parseWhileStatement(node);

case tt._with:

return this.parseWithStatement(node);

case tt.braceL:

return this.parseBlock();

case tt.semi:

return this.parseEmptyStatement(node);

case tt._export:

case tt._import: {

const nextToken = this.lookahead();

if (nextToken.type === tt.parenL || nextToken.type === tt.dot) {

break;

}

if (!this.options.allowImportExportEverywhere && !topLevel) {

this.raise(

this.state.start,

"'import' and 'export' may only appear at the top level",

);

}

this.next();

let result;

if (starttype == tt._import) {

result = this.parseImport(node);

if (

result.type === "ImportDeclaration" &&

(!result.importKind || result.importKind === "value")

) {

this.sawUnambiguousESM = true;

}

} else {

result = this.parseExport(node);

if (

(result.type === "ExportNamedDeclaration" &&

(!result.exportKind || result.exportKind === "value")) ||

(result.type === "ExportAllDeclaration" &&

(!result.exportKind || result.exportKind === "value")) ||

result.type === "ExportDefaultDeclaration"

) {

this.sawUnambiguousESM = true;

}

}

this.assertModuleNodeAllowed(node);

return result;

}

case tt.name:

if (this.isContextual("async")) {

// peek ahead and see if next token is a function

const state = this.state.clone();

this.next();

if (this.match(tt._function) && !this.canInsertSemicolon()) {

this.expect(tt._function);

return this.parseFunction(node, true, false, true);

} else {

this.state = state;

}

}

}

// If the statement does not start with a statement keyword or a

// brace, it's an ExpressionStatement or LabeledStatement. We

// simply start parsing an expression, and afterwards, if the

// next token is a colon and the expression was a simple

// Identifier node, we switch to interpreting it as a label.

const maybeName = this.state.value;

const expr = this.parseStatement_parseExpression(); // XXX: LSC

// LSC: Defer eating the `:` token until `parseLabeledStatement`

if (

starttype === tt.name &&

expr.type === "Identifier" &&

this.match(tt.colon)

) {

return this.parseLabeledStatement(node, maybeName, expr);

} else {

return this.parseExpressionStatement(node, expr);

}

}

// XXX: LSC extension point

parseStatement_parseExpression(): N.Expression {

return this.parseExpression();

}

assertModuleNodeAllowed(node: N.Node): void {

if (!this.options.allowImportExportEverywhere && !this.inModule) {

this.raise(

node.start,

`'import' and 'export' may appear only with 'sourceType: "module"'`,

{

code: "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED",

},

);

}

}

takeDecorators(node: N.HasDecorators): void {

const decorators = this.state.decoratorStack[

this.state.decoratorStack.length - 1

];

if (decorators.length) {

node.decorators = decorators;

this.resetStartLocationFromNode(node, decorators[0]);

this.state.decoratorStack[this.state.decoratorStack.length - 1] = [];

}

}

canHaveLeadingDecorator(): boolean {

return this.match(tt._class);

}

parseDecorators(allowExport?: boolean): void {

const currentContextDecorators = this.state.decoratorStack[

this.state.decoratorStack.length - 1

];

while (this.match(tt.at)) {

const decorator = this.parseDecorator();

currentContextDecorators.push(decorator);

}

if (this.match(tt._export)) {

if (!allowExport) {

this.unexpected();

}

if (

this.hasPlugin("decorators") &&

!this.getPluginOption("decorators", "decoratorsBeforeExport")

) {

this.raise(

this.state.start,

"Using the export keyword between a decorator and a class is not allowed. " +

"Please use `export @dec class` instead.",

);

}

} else if (!this.canHaveLeadingDecorator()) {

this.raise(

this.state.start,

"Leading decorators must be attached to a class declaration",

);

}

}

parseDecorator(): N.Decorator {

this.expectOnePlugin(["decorators-legacy", "decorators"]);

const node = this.startNode();

this.next();

if (this.hasPlugin("decorators")) {

// Every time a decorator class expression is evaluated, a new empty array is pushed onto the stack

// So that the decorators of any nested class expressions will be dealt with separately

this.state.decoratorStack.push([]);

const startPos = this.state.start;

const startLoc = this.state.startLoc;

let expr: N.Expression;

if (this.eat(tt.parenL)) {

expr = this.parseExpression();

this.expect(tt.parenR);

} else {

expr = this.parseIdentifier(false);

while (this.eat(tt.dot)) {

const node = this.startNodeAt(startPos, startLoc);

node.object = expr;

node.property = this.parseIdentifier(true);

node.computed = false;

expr = this.finishNode(node, "MemberExpression");

}

}

if (this.eat(tt.parenL)) {

const node = this.startNodeAt(startPos, startLoc);

node.callee = expr;

node.arguments = this.parseCallExpressionArguments(tt.parenR, false);

this.toReferencedList(node.arguments);

expr = this.finishNode(node, "CallExpression");

}

node.expression = expr;

this.state.decoratorStack.pop();

} else {

node.expression = this.parseMaybeAssign();

}

return this.finishNode(node, "Decorator");

}

parseBreakContinueStatement(

node: N.BreakStatement | N.ContinueStatement,

keyword: string,

): N.BreakStatement | N.ContinueStatement {

const isBreak = keyword === "break";

this.next();

if (this.isLineTerminator()) {

node.label = null;

} else if (!this.match(tt.name)) {

this.unexpected();

} else {

node.label = this.parseIdentifier();

this.semicolon();

}

// Verify that there is an actual destination to break or

// continue to.

let i;

for (i = 0; i < this.state.labels.length; ++i) {

const lab = this.state.labels[i];

if (node.label == null || lab.name === node.label.name) {

if (lab.kind != null && (isBreak || lab.kind === "loop")) break;

if (node.label && isBreak) break;

}

}

if (i === this.state.labels.length) {

this.raise(node.start, "Unsyntactic " + keyword);

}

return this.finishNode(

node,

isBreak ? "BreakStatement" : "ContinueStatement",

);

}

parseDebuggerStatement(node: N.DebuggerStatement): N.DebuggerStatement {

this.next();

this.semicolon();

return this.finishNode(node, "DebuggerStatement");

}

parseDoStatement(node: N.DoWhileStatement): N.DoWhileStatement {

this.next();

// LSC: whiteblock do/while

let isWhiteBlock, indentLevel, oldWhiteBlockTerminalTokens;

if (this.hasPlugin("lscCoreSyntax")) {

// Capture indent level of do block

if (this.match(tt.colon)) {

isWhiteBlock = true;

indentLevel = this.state.indentLevel;

}

// Enable object-block ambiguity parsing for the body

this.state.nextBraceIsBlock = true;

// Enable early whiteblock termination on `while`

oldWhiteBlockTerminalTokens = this.state.whiteBlockTerminalTokens;

this.state.whiteBlockTerminalTokens = oldWhiteBlockTerminalTokens.concat([tt._while]);

}

this.state.labels.push(loopLabel);

node.body = this.parseStatement(false);

this.state.labels.pop();

if (this.hasPlugin("lscCoreSyntax")) {

this.state.whiteBlockTerminalTokens = oldWhiteBlockTerminalTokens;

if (isWhiteBlock && this.state.indentLevel !== indentLevel) {

this.unexpected(null, "Mismatched indent.");

}

}

this.expect(tt._while);

if (this.hasPlugin("lscCoreSyntax")) {

// allow parens; enforce semicolon or newline whether they're used or not.

node.test = this.parseExpression();

if (node.test.extra && node.test.extra.parenthesized) {

delete node.test.extra.parenthesized;

delete node.test.extra.parenStart;

if (Object.keys(node.test.extra).length === 0) {

delete node.test.extra;

}

this.addExtra(node, "hasParens", true);

}

this.semicolon();

} else {

node.test = this.parseParenExpression();

this.eat(tt.semi);

}

return this.finishNode(node, "DoWhileStatement");

}

// Disambiguating between a `for` and a `for`/`in` or `for`/`of`

// loop is non-trivial. Basically, we have to parse the init `var`

// statement or expression, disallowing the `in` operator (see

// the second parameter to `parseExpression`), and then check

// whether the next token is `in` or `of`. When there is no init

// part (semicolon immediately after the opening parenthesis), it

// is a regular `for` loop.

parseForStatement(node: N.Node): N.ForLike {

this.next();

this.state.labels.push(loopLabel);

let forAwait = false;

if (this.state.inAsync && this.isContextual("await")) {

this.expectPlugin("asyncGenerators");

forAwait = true;

this.next();

}

// XXX: LSC

if (this.hasPlugin("lscCoreSyntax")) {

if (this.eat(tt.parenL)) {

this.addExtra(node, "hasParens", true);

}

} else {

this.expect(tt.parenL);

}

if (this.match(tt.semi)) {

if (forAwait) {

this.unexpected();

}

return this.parseFor(node, null);

}

// LSC: for-in

if ((!forAwait) && this.hasPlugin("lscForIn")) {

const result = this.lscForIn_tryParseEnhancedForIn(node);

if (result) return result;

}

if (this.match(tt._var) || this.match(tt._let) || this.match(tt._const)) {

const init = this.startNode();

const varKind = this.state.type;

this.next();

this.parseVar(init, true, varKind);

this.finishNode(init, "VariableDeclaration");

if (this.match(tt._in) || this.isContextual("of")) {

if (init.declarations.length === 1) {

const declaration = init.declarations[0];

const isForInInitializer =

varKind === tt._var &&

declaration.init &&

declaration.id.type != "ObjectPattern" &&

declaration.id.type != "ArrayPattern" &&

!this.isContextual("of");

if (this.state.strict && isForInInitializer) {

this.raise(this.state.start, "for-in initializer in strict mode");

} else if (isForInInitializer || !declaration.init) {

return this.parseForIn(node, init, forAwait);

}

}

}

if (forAwait) {

this.unexpected();

}

return this.parseFor(node, init);

}

const refShorthandDefaultPos = { start: 0 };

const init = this.parseExpression(true, refShorthandDefaultPos);

if (this.match(tt._in) || this.isContextual("of")) {

const description = this.isContextual("of")

? "for-of statement"

: "for-in statement";

this.toAssignable(init, undefined, description);

this.checkLVal(init, undefined, undefined, description);

return this.parseForIn(node, init, forAwait);

} else if (refShorthandDefaultPos.start) {

this.unexpected(refShorthandDefaultPos.start);

}

if (forAwait) {

this.unexpected();

}

return this.parseFor(node, init);

}

parseFunctionStatement(node: N.FunctionDeclaration): N.FunctionDeclaration {

this.next();

return this.parseFunction(node, true);

}

parseIfStatement(node: N.IfStatement): N.IfStatement {

this.next();

node.test = this.parseParenExpression();

node.consequent = this.parseStatement(false);

node.alternate = this.eat(tt._else) ? this.parseStatement(false) : null;

return this.finishNode(node, "IfStatement");

}

parseReturnStatement(node: N.ReturnStatement): N.ReturnStatement {

if (!this.state.inFunction && !this.options.allowReturnOutsideFunction) {

this.raise(this.state.start, "'return' outside of function");

}

this.next();

// In `return` (and `break`/`continue`), the keywords with

// optional arguments, we eagerly look for a semicolon or the

// possibility to insert one.

if (

this.isLineTerminator() ||

(this.hasPlugin("lscCoreSyntax") && !this.tokenStartsExpression()) // XXX: LSC

) {

node.argument = null;

} else {

node.argument = this.parseExpression();

this.semicolon();

}

return this.finishNode(node, "ReturnStatement");

}

parseSwitchStatement(node: N.SwitchStatement): N.SwitchStatement {

this.next();

node.discriminant = this.parseParenExpression();

const cases = (node.cases = []);

this.expect(tt.braceL);

this.state.labels.push(switchLabel);

// Statements under must be grouped (by label) in SwitchCase

// nodes. `cur` is used to keep the node that we are currently

// adding statements to.

let cur;

for (let sawDefault; !this.match(tt.braceR); ) {

if (this.match(tt._case) || this.match(tt._default)) {

const isCase = this.match(tt._case);

if (cur) this.finishNode(cur, "SwitchCase");

cases.push((cur = this.startNode()));

cur.consequent = [];

this.next();

if (isCase) {

cur.test = this.parseExpression();

} else {

if (sawDefault) {

this.raise(this.state.lastTokStart, "Multiple default clauses");

}

sawDefault = true;

cur.test = null;

}

this.expect(tt.colon);

} else {

if (cur) {

cur.consequent.push(this.parseStatement(true));

} else {

this.unexpected();

}

}

}

if (cur) this.finishNode(cur, "SwitchCase");

this.next(); // Closing brace

this.state.labels.pop();

return this.finishNode(node, "SwitchStatement");

}

parseThrowStatement(node: N.ThrowStatement): N.ThrowStatement {

this.next();

if (

lineBreak.test(this.input.slice(this.state.lastTokEnd, this.state.start))

) {

this.raise(this.state.lastTokEnd, "Illegal newline after throw");

}

node.argument = this.parseExpression();

this.semicolon();

return this.finishNode(node, "ThrowStatement");

}

parseTryStatement(node: N.TryStatement): N.TryStatement {

this.next();

node.block = this.parseBlock();

node.handler = null;

if (this.match(tt._catch)) {

const clause = this.startNode();

this.next();

if (this.match(tt.parenL)) {

this.expect(tt.parenL);

clause.param = this.parseBindingAtom();

const clashes: any = Object.create(null);

this.checkLVal(clause.param, true, clashes, "catch clause");

this.expect(tt.parenR);

} else {

this.expectPlugin("optionalCatchBinding");

clause.param = null;

}

clause.body = this.parseBlock();

node.handler = this.finishNode(clause, "CatchClause");

}

node.guardedHandlers = empty;

node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null;

if (!node.handler && !node.finalizer) {

this.raise(node.start, "Missing catch or finally clause");

}

return this.finishNode(node, "TryStatement");

}

parseVarStatement(

node: N.VariableDeclaration,

kind: TokenType,

): N.VariableDeclaration {

this.next();

this.parseVar(node, false, kind);

this.semicolon();

return this.finishNode(node, "VariableDeclaration");

}

parseWhileStatement(node: N.WhileStatement): N.WhileStatement {

this.next();

node.test = this.parseParenExpression();

this.state.labels.push(loopLabel);

this.state.nextBraceIsBlock = true; // XXX: LSC

node.body = this.parseStatement(false);

this.state.labels.pop();

return this.finishNode(node, "WhileStatement");

}

parseWithStatement(node: N.WithStatement): N.WithStatement {

if (this.state.strict) {

this.raise(this.state.start, "'with' in strict mode");

}

this.next();

node.object = this.parseParenExpression();

node.body = this.parseStatement(false);

return this.finishNode(node, "WithStatement");

}

parseEmptyStatement(node: N.EmptyStatement): N.EmptyStatement {

this.next();

return this.finishNode(node, "EmptyStatement");

}

parseLabeledStatement(

node: N.LabeledStatement,

maybeName: string,

expr: N.Identifier,

): N.LabeledStatement {

// LSC: eating the `:` token is deferred from `parseStatement`

this.next();

for (const label of this.state.labels) {

if (label.name === maybeName) {

this.raise(expr.start, `Label '${maybeName}' is already declared`);

}

}

const kind = this.state.type.isLoop

? "loop"

: this.match(tt._switch)

? "switch"

: null;

for (let i = this.state.labels.length - 1; i >= 0; i--) {

const label = this.state.labels[i];

if (label.statementStart === node.start) {

label.statementStart = this.state.start;

label.kind = kind;

} else {

break;

}

}

this.state.labels.push({

name: maybeName,

kind: kind,

statementStart: this.state.start,

});

node.body = this.parseStatement(true);

if (

node.body.type == "ClassDeclaration" ||

(node.body.type == "VariableDeclaration" && node.body.kind !== "var") ||

(node.body.type == "FunctionDeclaration" &&

(this.state.strict || node.body.generator || node.body.async))

) {

this.raise(node.body.start, "Invalid labeled declaration");

}

this.state.labels.pop();

node.label = expr;

return this.finishNode(node, "LabeledStatement");

}

parseExpressionStatement(

node: N.ExpressionStatement,

expr: N.Expression,

): N.ExpressionStatement {

node.expression = expr;

this.semicolon();

return this.finishNode(node, "ExpressionStatement");

}

// Parse a semicolon-enclosed block of statements, handling `"use

// strict"` declarations when `allowStrict` is true (used for

// function bodies).

parseBlock(allowDirectives?: boolean): N.BlockStatement {

const node = this.startNode();

this.expect(tt.braceL);

this.parseBlockBody(node, allowDirectives, false, tt.braceR);

return this.finishNode(node, "BlockStatement");

}

isValidDirective(stmt: N.Statement): boolean {

return (

stmt.type === "ExpressionStatement" &&

stmt.expression.type === "StringLiteral" &&

!stmt.expression.extra.parenthesized

);

}

parseBlockBody(

node: N.BlockStatementLike,

allowDirectives: ?boolean,

topLevel: boolean,

end: TokenType,

): void {

const body = (node.body = []);

const directives = (node.directives = []);

this.parseBlockOrModuleBlockBody(

body,

allowDirectives ? directives : undefined,

topLevel,

end,

);

}

// Undefined directives means that directives are not allowed.

parseBlockOrModuleBlockBody(

body: N.Statement[],

directives: ?(N.Directive[]),

topLevel: boolean,

end: TokenType,

): void {

let parsedNonDirective = false;

let oldStrict;

let octalPosition;

while (!this.eat(end)) {

if (!parsedNonDirective && this.state.containsOctal && !octalPosition) {

octalPosition = this.state.octalPosition;

}

const stmt = this.parseStatement(true, topLevel);

if (directives && !parsedNonDirective && this.isValidDirective(stmt)) {

const directive = this.stmtToDirective(stmt);

directives.push(directive);

if (oldStrict === undefined && directive.value.value === "use strict") {

oldStrict = this.state.strict;

this.setStrict(true);

if (octalPosition) {

this.raise(octalPosition, "Octal literal in strict mode");

}

}

continue;

}

parsedNonDirective = true;

body.push(stmt);

}

if (oldStrict === false) {

this.setStrict(false);

}

}

// Parse a regular `for` loop. The disambiguation code in

// `parseStatement` will already have parsed the init statement or

// expression.

parseFor(

node: N.ForStatement,

init: ?(N.VariableDeclaration | N.Expression),

): N.ForStatement {

node.init = init;

this.expect(tt.semi);

node.test = this.match(tt.semi) ? null : this.parseExpression();

this.expect(tt.semi);

node.update = this.match(tt.parenR) ? null : this.parseExpression();

// XXX: pluginize?

if (this.hasPlugin("lscCoreSyntax")) {

this.expectParenFreeBlockStart(node);

this.state.nextBraceIsBlock = true;

} else {

this.expect(tt.parenR);

}

node.body = this.parseStatement(false);

this.state.labels.pop();

return this.finishNode(node, "ForStatement");

}

// Parse a `for`/`in` and `for`/`of` loop, which are almost

// same from parser's perspective.

parseForIn(

node: N.ForInOf,

init: N.VariableDeclaration,

forAwait: boolean,

): N.ForInOf {

const type = this.match(tt._in) ? "ForInStatement" : "ForOfStatement";

if (forAwait) {

this.eatContextual("of");

} else {

this.next();

}

if (type === "ForOfStatement") {

node.await = !!forAwait;

}

node.left = init;

// LSC: ban ambiguous arrows here

if (this.hasPlugin("lscCoreSyntax")) {

const oldBanAmbiguousArrows = this.state.banAmbiguousArrows

this.state.banAmbiguousArrows = true

node.right = this.parseExpression();

this.state.banAmbiguousArrows = oldBanAmbiguousArrows

} else {

node.right = this.parseExpression();

}

// LSC: paren-free

if (this.hasPlugin("lscCoreSyntax")) {

this.expectParenFreeBlockStart(node);

this.state.nextBraceIsBlock = true;

} else {

this.expect(tt.parenR);

}

node.body = this.parseStatement(false);

this.state.labels.pop();

return this.finishNode(node, type);

}

// Parse a list of variable declarations.

parseVar(

node: N.VariableDeclaration,

isFor: boolean,

kind: TokenType,

): N.VariableDeclaration {

const declarations = (node.declarations = []);

// $FlowFixMe

node.kind = kind.keyword;

for (;;) {

const decl = this.startNode();

this.parseVarHead(decl);

this.parseVarInit(decl, isFor, kind); // LSC

declarations.push(this.finishNode(decl, "VariableDeclarator"));

if (!this.eat(tt.comma)) break;

}

return node;

}

parseVarHead(decl: N.VariableDeclarator): void {

decl.id = this.parseBindingAtom();

this.checkLVal(decl.id, true, undefined, "variable declaration");

}

// LSC: Extension point

// XXX: possible Babylon upstream change

parseVarInit(decl: N.VariableDeclarator, isFor, kind): void {

if (this.eat(tt.eq)) {

decl.init = this.parseMaybeAssign(isFor);

} else {

if (

kind === tt._const &&

!(this.match(tt._in) || this.isContextual("of"))

) {

// `const` with no initializer is allowed in TypeScript.

// It could be a declaration like `const x: number;`.

if (!this.hasPlugin("typescript")) {

this.unexpected();

}

} else if (

decl.id.type !== "Identifier" &&

!(isFor && (this.match(tt._in) || this.isContextual("of")))

) {

this.raise(

this.state.lastTokEnd,

"Complex binding patterns require an initialization value",

);

}

decl.init = null;

}

}

// Parse a function declaration or literal (depending on the

// `isStatement` parameter).

parseFunction<T: N.NormalFunction>(

node: T,

isStatement: boolean,

allowExpressionBody?: boolean,

isAsync?: boolean,

optionalId?: boolean,

): T {

const oldInFunc = this.state.inFunction;

const oldInMethod = this.state.inMethod;

const oldInGenerator = this.state.inGenerator;

const oldInClassProperty = this.state.inClassProperty;

this.state.inFunction = true;

this.state.inMethod = false;

this.state.inClassProperty = false;

this.initFunction(node, isAsync);

if (this.match(tt.star)) {

if (node.async) {

this.expectPlugin("asyncGenerators");

}

node.generator = true;

this.next();

}

if (

isStatement &&

!optionalId &&

!this.match(tt.name) &&

!this.match(tt._yield)

) {

this.unexpected();

}

// When parsing function expression, the binding identifier is parsed

// according to the rules inside the function.

// e.g. (function* yield() {}) is invalid because "yield" is disallowed in

// generators.

// This isn't the case with function declarations: function* yield() {} is

// valid because yield is parsed as if it was outside the generator.

// Therefore, this.state.inGenerator is set before or after parsing the

// function id according to the "isStatement" parameter.

if (!isStatement) this.state.inGenerator = node.generator;

if (this.match(tt.name) || this.match(tt._yield)) {

node.id = this.parseBindingIdentifier();

}

if (isStatement) this.state.inGenerator = node.generator;

this.parseFunctionParams(node);

this.parseFunctionBodyAndFinish(

node,

isStatement ? "FunctionDeclaration" : "FunctionExpression",

allowExpressionBody,

);

this.state.inFunction = oldInFunc;

this.state.inMethod = oldInMethod;

this.state.inGenerator = oldInGenerator;

this.state.inClassProperty = oldInClassProperty;

return node;

}

parseFunctionParams(node: N.Function, allowModifiers?: boolean): void {

const oldInParameters = this.state.inParameters;

this.state.inParameters = true;

this.expect(tt.parenL);

node.params = this.parseBindingList(

tt.parenR,

/* allowEmpty */ false,