devsite/node_modules/sucrase/dist/esm/parser/traverser/expression.js

1023 lines
28 KiB
JavaScript
Raw Normal View History

2024-07-08 01:49:38 +00:00
/* eslint max-len: 0 */
// A recursive descent parser operates by defining functions for all
// syntactic elements, and recursively calling those, each function
// advancing the input stream and returning an AST node. Precedence
// of constructs (for example, the fact that `!x[1]` means `!(x[1])`
// instead of `(!x)[1]` is handled by the fact that the parser
// function that parses unary prefix operators is called first, and
// in turn calls the function that parses `[]` subscripts — that
// way, it'll receive the node for `x[1]` already parsed, and wraps
// *that* in the unary operator node.
//
// Acorn uses an [operator precedence parser][opp] to handle binary
// operator precedence, because it is much more compact than using
// the technique outlined above, which uses different, nesting
// functions to specify precedence, for all of the ten binary
// precedence levels that JavaScript defines.
//
// [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser
import {
flowParseArrow,
flowParseFunctionBodyAndFinish,
flowParseMaybeAssign,
flowParseSubscript,
flowParseSubscripts,
flowParseVariance,
flowStartParseAsyncArrowFromCallExpression,
flowStartParseNewArguments,
flowStartParseObjPropValue,
} from "../plugins/flow";
import {jsxParseElement} from "../plugins/jsx/index";
import {typedParseConditional, typedParseParenItem} from "../plugins/types";
import {
tsParseArrow,
tsParseFunctionBodyAndFinish,
tsParseMaybeAssign,
tsParseSubscript,
tsParseType,
tsParseTypeAssertion,
tsStartParseAsyncArrowFromCallExpression,
tsStartParseObjPropValue,
} from "../plugins/typescript";
import {
eat,
IdentifierRole,
lookaheadCharCode,
lookaheadType,
match,
next,
nextTemplateToken,
popTypeContext,
pushTypeContext,
rescan_gt,
retokenizeSlashAsRegex,
} from "../tokenizer/index";
import {ContextualKeyword} from "../tokenizer/keywords";
import {Scope} from "../tokenizer/state";
import {TokenType, TokenType as tt} from "../tokenizer/types";
import {charCodes} from "../util/charcodes";
import {IS_IDENTIFIER_START} from "../util/identifier";
import {getNextContextId, isFlowEnabled, isJSXEnabled, isTypeScriptEnabled, state} from "./base";
import {
markPriorBindingIdentifier,
parseBindingIdentifier,
parseMaybeDefault,
parseRest,
parseSpread,
} from "./lval";
import {
parseBlock,
parseBlockBody,
parseClass,
parseDecorators,
parseFunction,
parseFunctionParams,
} from "./statement";
import {
canInsertSemicolon,
eatContextual,
expect,
expectContextual,
hasFollowingLineBreak,
hasPrecedingLineBreak,
isContextual,
unexpected,
} from "./util";
export class StopState {
constructor(stop) {
this.stop = stop;
}
}
// ### Expression parsing
// These nest, from the most general expression type at the top to
// 'atomic', nondivisible expression types at the bottom. Most of
// the functions will simply let the function (s) below them parse,
// and, *if* the syntactic construct they handle is present, wrap
// the AST node that the inner parser gave them in another node.
export function parseExpression(noIn = false) {
parseMaybeAssign(noIn);
if (match(tt.comma)) {
while (eat(tt.comma)) {
parseMaybeAssign(noIn);
}
}
}
/**
* noIn is used when parsing a for loop so that we don't interpret a following "in" as the binary
* operatior.
* isWithinParens is used to indicate that we're parsing something that might be a comma expression
* or might be an arrow function or might be a Flow type assertion (which requires explicit parens).
* In these cases, we should allow : and ?: after the initial "left" part.
*/
export function parseMaybeAssign(noIn = false, isWithinParens = false) {
if (isTypeScriptEnabled) {
return tsParseMaybeAssign(noIn, isWithinParens);
} else if (isFlowEnabled) {
return flowParseMaybeAssign(noIn, isWithinParens);
} else {
return baseParseMaybeAssign(noIn, isWithinParens);
}
}
// Parse an assignment expression. This includes applications of
// operators like `+=`.
// Returns true if the expression was an arrow function.
export function baseParseMaybeAssign(noIn, isWithinParens) {
if (match(tt._yield)) {
parseYield();
return false;
}
if (match(tt.parenL) || match(tt.name) || match(tt._yield)) {
state.potentialArrowAt = state.start;
}
const wasArrow = parseMaybeConditional(noIn);
if (isWithinParens) {
parseParenItem();
}
if (state.type & TokenType.IS_ASSIGN) {
next();
parseMaybeAssign(noIn);
return false;
}
return wasArrow;
}
// Parse a ternary conditional (`?:`) operator.
// Returns true if the expression was an arrow function.
function parseMaybeConditional(noIn) {
const wasArrow = parseExprOps(noIn);
if (wasArrow) {
return true;
}
parseConditional(noIn);
return false;
}
function parseConditional(noIn) {
if (isTypeScriptEnabled || isFlowEnabled) {
typedParseConditional(noIn);
} else {
baseParseConditional(noIn);
}
}
export function baseParseConditional(noIn) {
if (eat(tt.question)) {
parseMaybeAssign();
expect(tt.colon);
parseMaybeAssign(noIn);
}
}
// Start the precedence parser.
// Returns true if this was an arrow function
function parseExprOps(noIn) {
const startTokenIndex = state.tokens.length;
const wasArrow = parseMaybeUnary();
if (wasArrow) {
return true;
}
parseExprOp(startTokenIndex, -1, noIn);
return false;
}
// Parse binary operators with the operator precedence parsing
// algorithm. `left` is the left-hand side of the operator.
// `minPrec` provides context that allows the function to stop and
// defer further parser to one of its callers when it encounters an
// operator that has a lower precedence than the set it is parsing.
function parseExprOp(startTokenIndex, minPrec, noIn) {
if (
isTypeScriptEnabled &&
(tt._in & TokenType.PRECEDENCE_MASK) > minPrec &&
!hasPrecedingLineBreak() &&
(eatContextual(ContextualKeyword._as) || eatContextual(ContextualKeyword._satisfies))
) {
const oldIsType = pushTypeContext(1);
tsParseType();
popTypeContext(oldIsType);
rescan_gt();
parseExprOp(startTokenIndex, minPrec, noIn);
return;
}
const prec = state.type & TokenType.PRECEDENCE_MASK;
if (prec > 0 && (!noIn || !match(tt._in))) {
if (prec > minPrec) {
const op = state.type;
next();
if (op === tt.nullishCoalescing) {
state.tokens[state.tokens.length - 1].nullishStartIndex = startTokenIndex;
}
const rhsStartTokenIndex = state.tokens.length;
parseMaybeUnary();
// Extend the right operand of this operator if possible.
parseExprOp(rhsStartTokenIndex, op & TokenType.IS_RIGHT_ASSOCIATIVE ? prec - 1 : prec, noIn);
if (op === tt.nullishCoalescing) {
state.tokens[startTokenIndex].numNullishCoalesceStarts++;
state.tokens[state.tokens.length - 1].numNullishCoalesceEnds++;
}
// Continue with any future operator holding this expression as the left operand.
parseExprOp(startTokenIndex, minPrec, noIn);
}
}
}
// Parse unary operators, both prefix and postfix.
// Returns true if this was an arrow function.
export function parseMaybeUnary() {
if (isTypeScriptEnabled && !isJSXEnabled && eat(tt.lessThan)) {
tsParseTypeAssertion();
return false;
}
if (
isContextual(ContextualKeyword._module) &&
lookaheadCharCode() === charCodes.leftCurlyBrace &&
!hasFollowingLineBreak()
) {
parseModuleExpression();
return false;
}
if (state.type & TokenType.IS_PREFIX) {
next();
parseMaybeUnary();
return false;
}
const wasArrow = parseExprSubscripts();
if (wasArrow) {
return true;
}
while (state.type & TokenType.IS_POSTFIX && !canInsertSemicolon()) {
// The tokenizer calls everything a preincrement, so make it a postincrement when
// we see it in that context.
if (state.type === tt.preIncDec) {
state.type = tt.postIncDec;
}
next();
}
return false;
}
// Parse call, dot, and `[]`-subscript expressions.
// Returns true if this was an arrow function.
export function parseExprSubscripts() {
const startTokenIndex = state.tokens.length;
const wasArrow = parseExprAtom();
if (wasArrow) {
return true;
}
parseSubscripts(startTokenIndex);
// If there was any optional chain operation, the start token would be marked
// as such, so also mark the end now.
if (state.tokens.length > startTokenIndex && state.tokens[startTokenIndex].isOptionalChainStart) {
state.tokens[state.tokens.length - 1].isOptionalChainEnd = true;
}
return false;
}
function parseSubscripts(startTokenIndex, noCalls = false) {
if (isFlowEnabled) {
flowParseSubscripts(startTokenIndex, noCalls);
} else {
baseParseSubscripts(startTokenIndex, noCalls);
}
}
export function baseParseSubscripts(startTokenIndex, noCalls = false) {
const stopState = new StopState(false);
do {
parseSubscript(startTokenIndex, noCalls, stopState);
} while (!stopState.stop && !state.error);
}
function parseSubscript(startTokenIndex, noCalls, stopState) {
if (isTypeScriptEnabled) {
tsParseSubscript(startTokenIndex, noCalls, stopState);
} else if (isFlowEnabled) {
flowParseSubscript(startTokenIndex, noCalls, stopState);
} else {
baseParseSubscript(startTokenIndex, noCalls, stopState);
}
}
/** Set 'state.stop = true' to indicate that we should stop parsing subscripts. */
export function baseParseSubscript(
startTokenIndex,
noCalls,
stopState,
) {
if (!noCalls && eat(tt.doubleColon)) {
parseNoCallExpr();
stopState.stop = true;
// Propagate startTokenIndex so that `a::b?.()` will keep `a` as the first token. We may want
// to revisit this in the future when fully supporting bind syntax.
parseSubscripts(startTokenIndex, noCalls);
} else if (match(tt.questionDot)) {
state.tokens[startTokenIndex].isOptionalChainStart = true;
if (noCalls && lookaheadType() === tt.parenL) {
stopState.stop = true;
return;
}
next();
state.tokens[state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
if (eat(tt.bracketL)) {
parseExpression();
expect(tt.bracketR);
} else if (eat(tt.parenL)) {
parseCallExpressionArguments();
} else {
parseMaybePrivateName();
}
} else if (eat(tt.dot)) {
state.tokens[state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
parseMaybePrivateName();
} else if (eat(tt.bracketL)) {
state.tokens[state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
parseExpression();
expect(tt.bracketR);
} else if (!noCalls && match(tt.parenL)) {
if (atPossibleAsync()) {
// We see "async", but it's possible it's a usage of the name "async". Parse as if it's a
// function call, and if we see an arrow later, backtrack and re-parse as a parameter list.
const snapshot = state.snapshot();
const asyncStartTokenIndex = state.tokens.length;
next();
state.tokens[state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
const callContextId = getNextContextId();
state.tokens[state.tokens.length - 1].contextId = callContextId;
parseCallExpressionArguments();
state.tokens[state.tokens.length - 1].contextId = callContextId;
if (shouldParseAsyncArrow()) {
// We hit an arrow, so backtrack and start again parsing function parameters.
state.restoreFromSnapshot(snapshot);
stopState.stop = true;
state.scopeDepth++;
parseFunctionParams();
parseAsyncArrowFromCallExpression(asyncStartTokenIndex);
}
} else {
next();
state.tokens[state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
const callContextId = getNextContextId();
state.tokens[state.tokens.length - 1].contextId = callContextId;
parseCallExpressionArguments();
state.tokens[state.tokens.length - 1].contextId = callContextId;
}
} else if (match(tt.backQuote)) {
// Tagged template expression.
parseTemplate();
} else {
stopState.stop = true;
}
}
export function atPossibleAsync() {
// This was made less strict than the original version to avoid passing around nodes, but it
// should be safe to have rare false positives here.
return (
state.tokens[state.tokens.length - 1].contextualKeyword === ContextualKeyword._async &&
!canInsertSemicolon()
);
}
export function parseCallExpressionArguments() {
let first = true;
while (!eat(tt.parenR) && !state.error) {
if (first) {
first = false;
} else {
expect(tt.comma);
if (eat(tt.parenR)) {
break;
}
}
parseExprListItem(false);
}
}
function shouldParseAsyncArrow() {
return match(tt.colon) || match(tt.arrow);
}
function parseAsyncArrowFromCallExpression(startTokenIndex) {
if (isTypeScriptEnabled) {
tsStartParseAsyncArrowFromCallExpression();
} else if (isFlowEnabled) {
flowStartParseAsyncArrowFromCallExpression();
}
expect(tt.arrow);
parseArrowExpression(startTokenIndex);
}
// Parse a no-call expression (like argument of `new` or `::` operators).
function parseNoCallExpr() {
const startTokenIndex = state.tokens.length;
parseExprAtom();
parseSubscripts(startTokenIndex, true);
}
// Parse an atomic expression — either a single token that is an
// expression, an expression started by a keyword like `function` or
// `new`, or an expression wrapped in punctuation like `()`, `[]`,
// or `{}`.
// Returns true if the parsed expression was an arrow function.
export function parseExprAtom() {
if (eat(tt.modulo)) {
// V8 intrinsic expression. Just parse the identifier, and the function invocation is parsed
// naturally.
parseIdentifier();
return false;
}
if (match(tt.jsxText) || match(tt.jsxEmptyText)) {
parseLiteral();
return false;
} else if (match(tt.lessThan) && isJSXEnabled) {
state.type = tt.jsxTagStart;
jsxParseElement();
next();
return false;
}
const canBeArrow = state.potentialArrowAt === state.start;
switch (state.type) {
case tt.slash:
case tt.assign:
retokenizeSlashAsRegex();
// Fall through.
case tt._super:
case tt._this:
case tt.regexp:
case tt.num:
case tt.bigint:
case tt.decimal:
case tt.string:
case tt._null:
case tt._true:
case tt._false:
next();
return false;
case tt._import:
next();
if (match(tt.dot)) {
// import.meta
state.tokens[state.tokens.length - 1].type = tt.name;
next();
parseIdentifier();
}
return false;
case tt.name: {
const startTokenIndex = state.tokens.length;
const functionStart = state.start;
const contextualKeyword = state.contextualKeyword;
parseIdentifier();
if (contextualKeyword === ContextualKeyword._await) {
parseAwait();
return false;
} else if (
contextualKeyword === ContextualKeyword._async &&
match(tt._function) &&
!canInsertSemicolon()
) {
next();
parseFunction(functionStart, false);
return false;
} else if (
canBeArrow &&
contextualKeyword === ContextualKeyword._async &&
!canInsertSemicolon() &&
match(tt.name)
) {
state.scopeDepth++;
parseBindingIdentifier(false);
expect(tt.arrow);
// let foo = async bar => {};
parseArrowExpression(startTokenIndex);
return true;
} else if (match(tt._do) && !canInsertSemicolon()) {
next();
parseBlock();
return false;
}
if (canBeArrow && !canInsertSemicolon() && match(tt.arrow)) {
state.scopeDepth++;
markPriorBindingIdentifier(false);
expect(tt.arrow);
parseArrowExpression(startTokenIndex);
return true;
}
state.tokens[state.tokens.length - 1].identifierRole = IdentifierRole.Access;
return false;
}
case tt._do: {
next();
parseBlock();
return false;
}
case tt.parenL: {
const wasArrow = parseParenAndDistinguishExpression(canBeArrow);
return wasArrow;
}
case tt.bracketL:
next();
parseExprList(tt.bracketR, true);
return false;
case tt.braceL:
parseObj(false, false);
return false;
case tt._function:
parseFunctionExpression();
return false;
case tt.at:
parseDecorators();
// Fall through.
case tt._class:
parseClass(false);
return false;
case tt._new:
parseNew();
return false;
case tt.backQuote:
parseTemplate();
return false;
case tt.doubleColon: {
next();
parseNoCallExpr();
return false;
}
case tt.hash: {
const code = lookaheadCharCode();
if (IS_IDENTIFIER_START[code] || code === charCodes.backslash) {
parseMaybePrivateName();
} else {
next();
}
// Smart pipeline topic reference.
return false;
}
default:
unexpected();
return false;
}
}
function parseMaybePrivateName() {
eat(tt.hash);
parseIdentifier();
}
function parseFunctionExpression() {
const functionStart = state.start;
parseIdentifier();
if (eat(tt.dot)) {
// function.sent
parseIdentifier();
}
parseFunction(functionStart, false);
}
export function parseLiteral() {
next();
}
export function parseParenExpression() {
expect(tt.parenL);
parseExpression();
expect(tt.parenR);
}
// Returns true if this was an arrow expression.
function parseParenAndDistinguishExpression(canBeArrow) {
// Assume this is a normal parenthesized expression, but if we see an arrow, we'll bail and
// start over as a parameter list.
const snapshot = state.snapshot();
const startTokenIndex = state.tokens.length;
expect(tt.parenL);
let first = true;
while (!match(tt.parenR) && !state.error) {
if (first) {
first = false;
} else {
expect(tt.comma);
if (match(tt.parenR)) {
break;
}
}
if (match(tt.ellipsis)) {
parseRest(false /* isBlockScope */);
parseParenItem();
break;
} else {
parseMaybeAssign(false, true);
}
}
expect(tt.parenR);
if (canBeArrow && shouldParseArrow()) {
const wasArrow = parseArrow();
if (wasArrow) {
// It was an arrow function this whole time, so start over and parse it as params so that we
// get proper token annotations.
state.restoreFromSnapshot(snapshot);
state.scopeDepth++;
// Don't specify a context ID because arrow functions don't need a context ID.
parseFunctionParams();
parseArrow();
parseArrowExpression(startTokenIndex);
if (state.error) {
// Nevermind! This must have been something that looks very much like an
// arrow function but where its "parameter list" isn't actually a valid
// parameter list. Force non-arrow parsing.
// See https://github.com/alangpierce/sucrase/issues/666 for an example.
state.restoreFromSnapshot(snapshot);
parseParenAndDistinguishExpression(false);
return false;
}
return true;
}
}
return false;
}
function shouldParseArrow() {
return match(tt.colon) || !canInsertSemicolon();
}
// Returns whether there was an arrow token.
export function parseArrow() {
if (isTypeScriptEnabled) {
return tsParseArrow();
} else if (isFlowEnabled) {
return flowParseArrow();
} else {
return eat(tt.arrow);
}
}
function parseParenItem() {
if (isTypeScriptEnabled || isFlowEnabled) {
typedParseParenItem();
}
}
// New's precedence is slightly tricky. It must allow its argument to
// be a `[]` or dot subscript expression, but not a call — at least,
// not without wrapping it in parentheses. Thus, it uses the noCalls
// argument to parseSubscripts to prevent it from consuming the
// argument list.
function parseNew() {
expect(tt._new);
if (eat(tt.dot)) {
// new.target
parseIdentifier();
return;
}
parseNewCallee();
if (isFlowEnabled) {
flowStartParseNewArguments();
}
if (eat(tt.parenL)) {
parseExprList(tt.parenR);
}
}
function parseNewCallee() {
parseNoCallExpr();
eat(tt.questionDot);
}
export function parseTemplate() {
// Finish `, read quasi
nextTemplateToken();
// Finish quasi, read ${
nextTemplateToken();
while (!match(tt.backQuote) && !state.error) {
expect(tt.dollarBraceL);
parseExpression();
// Finish }, read quasi
nextTemplateToken();
// Finish quasi, read either ${ or `
nextTemplateToken();
}
next();
}
// Parse an object literal or binding pattern.
export function parseObj(isPattern, isBlockScope) {
// Attach a context ID to the object open and close brace and each object key.
const contextId = getNextContextId();
let first = true;
next();
state.tokens[state.tokens.length - 1].contextId = contextId;
while (!eat(tt.braceR) && !state.error) {
if (first) {
first = false;
} else {
expect(tt.comma);
if (eat(tt.braceR)) {
break;
}
}
let isGenerator = false;
if (match(tt.ellipsis)) {
const previousIndex = state.tokens.length;
parseSpread();
if (isPattern) {
// Mark role when the only thing being spread over is an identifier.
if (state.tokens.length === previousIndex + 2) {
markPriorBindingIdentifier(isBlockScope);
}
if (eat(tt.braceR)) {
break;
}
}
continue;
}
if (!isPattern) {
isGenerator = eat(tt.star);
}
if (!isPattern && isContextual(ContextualKeyword._async)) {
if (isGenerator) unexpected();
parseIdentifier();
if (
match(tt.colon) ||
match(tt.parenL) ||
match(tt.braceR) ||
match(tt.eq) ||
match(tt.comma)
) {
// This is a key called "async" rather than an async function.
} else {
if (match(tt.star)) {
next();
isGenerator = true;
}
parsePropertyName(contextId);
}
} else {
parsePropertyName(contextId);
}
parseObjPropValue(isPattern, isBlockScope, contextId);
}
state.tokens[state.tokens.length - 1].contextId = contextId;
}
function isGetterOrSetterMethod(isPattern) {
// We go off of the next and don't bother checking if the node key is actually "get" or "set".
// This lets us avoid generating a node, and should only make the validation worse.
return (
!isPattern &&
(match(tt.string) || // get "string"() {}
match(tt.num) || // get 1() {}
match(tt.bracketL) || // get ["string"]() {}
match(tt.name) || // get foo() {}
!!(state.type & TokenType.IS_KEYWORD)) // get debugger() {}
);
}
// Returns true if this was a method.
function parseObjectMethod(isPattern, objectContextId) {
// We don't need to worry about modifiers because object methods can't have optional bodies, so
// the start will never be used.
const functionStart = state.start;
if (match(tt.parenL)) {
if (isPattern) unexpected();
parseMethod(functionStart, /* isConstructor */ false);
return true;
}
if (isGetterOrSetterMethod(isPattern)) {
parsePropertyName(objectContextId);
parseMethod(functionStart, /* isConstructor */ false);
return true;
}
return false;
}
function parseObjectProperty(isPattern, isBlockScope) {
if (eat(tt.colon)) {
if (isPattern) {
parseMaybeDefault(isBlockScope);
} else {
parseMaybeAssign(false);
}
return;
}
// Since there's no colon, we assume this is an object shorthand.
// If we're in a destructuring, we've now discovered that the key was actually an assignee, so
// we need to tag it as a declaration with the appropriate scope. Otherwise, we might need to
// transform it on access, so mark it as a normal object shorthand.
let identifierRole;
if (isPattern) {
if (state.scopeDepth === 0) {
identifierRole = IdentifierRole.ObjectShorthandTopLevelDeclaration;
} else if (isBlockScope) {
identifierRole = IdentifierRole.ObjectShorthandBlockScopedDeclaration;
} else {
identifierRole = IdentifierRole.ObjectShorthandFunctionScopedDeclaration;
}
} else {
identifierRole = IdentifierRole.ObjectShorthand;
}
state.tokens[state.tokens.length - 1].identifierRole = identifierRole;
// Regardless of whether we know this to be a pattern or if we're in an ambiguous context, allow
// parsing as if there's a default value.
parseMaybeDefault(isBlockScope, true);
}
function parseObjPropValue(
isPattern,
isBlockScope,
objectContextId,
) {
if (isTypeScriptEnabled) {
tsStartParseObjPropValue();
} else if (isFlowEnabled) {
flowStartParseObjPropValue();
}
const wasMethod = parseObjectMethod(isPattern, objectContextId);
if (!wasMethod) {
parseObjectProperty(isPattern, isBlockScope);
}
}
export function parsePropertyName(objectContextId) {
if (isFlowEnabled) {
flowParseVariance();
}
if (eat(tt.bracketL)) {
state.tokens[state.tokens.length - 1].contextId = objectContextId;
parseMaybeAssign();
expect(tt.bracketR);
state.tokens[state.tokens.length - 1].contextId = objectContextId;
} else {
if (match(tt.num) || match(tt.string) || match(tt.bigint) || match(tt.decimal)) {
parseExprAtom();
} else {
parseMaybePrivateName();
}
state.tokens[state.tokens.length - 1].identifierRole = IdentifierRole.ObjectKey;
state.tokens[state.tokens.length - 1].contextId = objectContextId;
}
}
// Parse object or class method.
export function parseMethod(functionStart, isConstructor) {
const funcContextId = getNextContextId();
state.scopeDepth++;
const startTokenIndex = state.tokens.length;
const allowModifiers = isConstructor; // For TypeScript parameter properties
parseFunctionParams(allowModifiers, funcContextId);
parseFunctionBodyAndFinish(functionStart, funcContextId);
const endTokenIndex = state.tokens.length;
state.scopes.push(new Scope(startTokenIndex, endTokenIndex, true));
state.scopeDepth--;
}
// Parse arrow function expression.
// If the parameters are provided, they will be converted to an
// assignable list.
export function parseArrowExpression(startTokenIndex) {
parseFunctionBody(true);
const endTokenIndex = state.tokens.length;
state.scopes.push(new Scope(startTokenIndex, endTokenIndex, true));
state.scopeDepth--;
}
export function parseFunctionBodyAndFinish(functionStart, funcContextId = 0) {
if (isTypeScriptEnabled) {
tsParseFunctionBodyAndFinish(functionStart, funcContextId);
} else if (isFlowEnabled) {
flowParseFunctionBodyAndFinish(funcContextId);
} else {
parseFunctionBody(false, funcContextId);
}
}
export function parseFunctionBody(allowExpression, funcContextId = 0) {
const isExpression = allowExpression && !match(tt.braceL);
if (isExpression) {
parseMaybeAssign();
} else {
parseBlock(true /* isFunctionScope */, funcContextId);
}
}
// Parses a comma-separated list of expressions, and returns them as
// an array. `close` is the token type that ends the list, and
// `allowEmpty` can be turned on to allow subsequent commas with
// nothing in between them to be parsed as `null` (which is needed
// for array literals).
function parseExprList(close, allowEmpty = false) {
let first = true;
while (!eat(close) && !state.error) {
if (first) {
first = false;
} else {
expect(tt.comma);
if (eat(close)) break;
}
parseExprListItem(allowEmpty);
}
}
function parseExprListItem(allowEmpty) {
if (allowEmpty && match(tt.comma)) {
// Empty item; nothing more to parse for this item.
} else if (match(tt.ellipsis)) {
parseSpread();
parseParenItem();
} else if (match(tt.question)) {
// Partial function application proposal.
next();
} else {
parseMaybeAssign(false, true);
}
}
// Parse the next token as an identifier.
export function parseIdentifier() {
next();
state.tokens[state.tokens.length - 1].type = tt.name;
}
// Parses await expression inside async function.
function parseAwait() {
parseMaybeUnary();
}
// Parses yield expression inside generator.
function parseYield() {
next();
if (!match(tt.semi) && !canInsertSemicolon()) {
eat(tt.star);
parseMaybeAssign();
}
}
// https://github.com/tc39/proposal-js-module-blocks
function parseModuleExpression() {
expectContextual(ContextualKeyword._module);
expect(tt.braceL);
// For now, just call parseBlockBody to parse the block. In the future when we
// implement full support, we'll want to emit scopes and possibly other
// information.
parseBlockBody(tt.braceR);
}