1023 lines
35 KiB
JavaScript
1023 lines
35 KiB
JavaScript
"use strict";Object.defineProperty(exports, "__esModule", {value: true});/* 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
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var _flow = require('../plugins/flow');
|
|
var _index = require('../plugins/jsx/index');
|
|
var _types = require('../plugins/types');
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var _typescript = require('../plugins/typescript');
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var _index3 = require('../tokenizer/index');
|
|
var _keywords = require('../tokenizer/keywords');
|
|
var _state = require('../tokenizer/state');
|
|
var _types3 = require('../tokenizer/types');
|
|
var _charcodes = require('../util/charcodes');
|
|
var _identifier = require('../util/identifier');
|
|
var _base = require('./base');
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var _lval = require('./lval');
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var _statement = require('./statement');
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var _util = require('./util');
|
|
|
|
class StopState {
|
|
|
|
constructor(stop) {
|
|
this.stop = stop;
|
|
}
|
|
} exports.StopState = StopState;
|
|
|
|
// ### 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.
|
|
function parseExpression(noIn = false) {
|
|
parseMaybeAssign(noIn);
|
|
if (_index3.match.call(void 0, _types3.TokenType.comma)) {
|
|
while (_index3.eat.call(void 0, _types3.TokenType.comma)) {
|
|
parseMaybeAssign(noIn);
|
|
}
|
|
}
|
|
} exports.parseExpression = parseExpression;
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
function parseMaybeAssign(noIn = false, isWithinParens = false) {
|
|
if (_base.isTypeScriptEnabled) {
|
|
return _typescript.tsParseMaybeAssign.call(void 0, noIn, isWithinParens);
|
|
} else if (_base.isFlowEnabled) {
|
|
return _flow.flowParseMaybeAssign.call(void 0, noIn, isWithinParens);
|
|
} else {
|
|
return baseParseMaybeAssign(noIn, isWithinParens);
|
|
}
|
|
} exports.parseMaybeAssign = parseMaybeAssign;
|
|
|
|
// Parse an assignment expression. This includes applications of
|
|
// operators like `+=`.
|
|
// Returns true if the expression was an arrow function.
|
|
function baseParseMaybeAssign(noIn, isWithinParens) {
|
|
if (_index3.match.call(void 0, _types3.TokenType._yield)) {
|
|
parseYield();
|
|
return false;
|
|
}
|
|
|
|
if (_index3.match.call(void 0, _types3.TokenType.parenL) || _index3.match.call(void 0, _types3.TokenType.name) || _index3.match.call(void 0, _types3.TokenType._yield)) {
|
|
_base.state.potentialArrowAt = _base.state.start;
|
|
}
|
|
|
|
const wasArrow = parseMaybeConditional(noIn);
|
|
if (isWithinParens) {
|
|
parseParenItem();
|
|
}
|
|
if (_base.state.type & _types3.TokenType.IS_ASSIGN) {
|
|
_index3.next.call(void 0, );
|
|
parseMaybeAssign(noIn);
|
|
return false;
|
|
}
|
|
return wasArrow;
|
|
} exports.baseParseMaybeAssign = baseParseMaybeAssign;
|
|
|
|
// 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 (_base.isTypeScriptEnabled || _base.isFlowEnabled) {
|
|
_types.typedParseConditional.call(void 0, noIn);
|
|
} else {
|
|
baseParseConditional(noIn);
|
|
}
|
|
}
|
|
|
|
function baseParseConditional(noIn) {
|
|
if (_index3.eat.call(void 0, _types3.TokenType.question)) {
|
|
parseMaybeAssign();
|
|
_util.expect.call(void 0, _types3.TokenType.colon);
|
|
parseMaybeAssign(noIn);
|
|
}
|
|
} exports.baseParseConditional = baseParseConditional;
|
|
|
|
// Start the precedence parser.
|
|
// Returns true if this was an arrow function
|
|
function parseExprOps(noIn) {
|
|
const startTokenIndex = _base.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 (
|
|
_base.isTypeScriptEnabled &&
|
|
(_types3.TokenType._in & _types3.TokenType.PRECEDENCE_MASK) > minPrec &&
|
|
!_util.hasPrecedingLineBreak.call(void 0, ) &&
|
|
(_util.eatContextual.call(void 0, _keywords.ContextualKeyword._as) || _util.eatContextual.call(void 0, _keywords.ContextualKeyword._satisfies))
|
|
) {
|
|
const oldIsType = _index3.pushTypeContext.call(void 0, 1);
|
|
_typescript.tsParseType.call(void 0, );
|
|
_index3.popTypeContext.call(void 0, oldIsType);
|
|
_index3.rescan_gt.call(void 0, );
|
|
parseExprOp(startTokenIndex, minPrec, noIn);
|
|
return;
|
|
}
|
|
|
|
const prec = _base.state.type & _types3.TokenType.PRECEDENCE_MASK;
|
|
if (prec > 0 && (!noIn || !_index3.match.call(void 0, _types3.TokenType._in))) {
|
|
if (prec > minPrec) {
|
|
const op = _base.state.type;
|
|
_index3.next.call(void 0, );
|
|
if (op === _types3.TokenType.nullishCoalescing) {
|
|
_base.state.tokens[_base.state.tokens.length - 1].nullishStartIndex = startTokenIndex;
|
|
}
|
|
|
|
const rhsStartTokenIndex = _base.state.tokens.length;
|
|
parseMaybeUnary();
|
|
// Extend the right operand of this operator if possible.
|
|
parseExprOp(rhsStartTokenIndex, op & _types3.TokenType.IS_RIGHT_ASSOCIATIVE ? prec - 1 : prec, noIn);
|
|
if (op === _types3.TokenType.nullishCoalescing) {
|
|
_base.state.tokens[startTokenIndex].numNullishCoalesceStarts++;
|
|
_base.state.tokens[_base.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.
|
|
function parseMaybeUnary() {
|
|
if (_base.isTypeScriptEnabled && !_base.isJSXEnabled && _index3.eat.call(void 0, _types3.TokenType.lessThan)) {
|
|
_typescript.tsParseTypeAssertion.call(void 0, );
|
|
return false;
|
|
}
|
|
if (
|
|
_util.isContextual.call(void 0, _keywords.ContextualKeyword._module) &&
|
|
_index3.lookaheadCharCode.call(void 0, ) === _charcodes.charCodes.leftCurlyBrace &&
|
|
!_util.hasFollowingLineBreak.call(void 0, )
|
|
) {
|
|
parseModuleExpression();
|
|
return false;
|
|
}
|
|
if (_base.state.type & _types3.TokenType.IS_PREFIX) {
|
|
_index3.next.call(void 0, );
|
|
parseMaybeUnary();
|
|
return false;
|
|
}
|
|
|
|
const wasArrow = parseExprSubscripts();
|
|
if (wasArrow) {
|
|
return true;
|
|
}
|
|
while (_base.state.type & _types3.TokenType.IS_POSTFIX && !_util.canInsertSemicolon.call(void 0, )) {
|
|
// The tokenizer calls everything a preincrement, so make it a postincrement when
|
|
// we see it in that context.
|
|
if (_base.state.type === _types3.TokenType.preIncDec) {
|
|
_base.state.type = _types3.TokenType.postIncDec;
|
|
}
|
|
_index3.next.call(void 0, );
|
|
}
|
|
return false;
|
|
} exports.parseMaybeUnary = parseMaybeUnary;
|
|
|
|
// Parse call, dot, and `[]`-subscript expressions.
|
|
// Returns true if this was an arrow function.
|
|
function parseExprSubscripts() {
|
|
const startTokenIndex = _base.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 (_base.state.tokens.length > startTokenIndex && _base.state.tokens[startTokenIndex].isOptionalChainStart) {
|
|
_base.state.tokens[_base.state.tokens.length - 1].isOptionalChainEnd = true;
|
|
}
|
|
return false;
|
|
} exports.parseExprSubscripts = parseExprSubscripts;
|
|
|
|
function parseSubscripts(startTokenIndex, noCalls = false) {
|
|
if (_base.isFlowEnabled) {
|
|
_flow.flowParseSubscripts.call(void 0, startTokenIndex, noCalls);
|
|
} else {
|
|
baseParseSubscripts(startTokenIndex, noCalls);
|
|
}
|
|
}
|
|
|
|
function baseParseSubscripts(startTokenIndex, noCalls = false) {
|
|
const stopState = new StopState(false);
|
|
do {
|
|
parseSubscript(startTokenIndex, noCalls, stopState);
|
|
} while (!stopState.stop && !_base.state.error);
|
|
} exports.baseParseSubscripts = baseParseSubscripts;
|
|
|
|
function parseSubscript(startTokenIndex, noCalls, stopState) {
|
|
if (_base.isTypeScriptEnabled) {
|
|
_typescript.tsParseSubscript.call(void 0, startTokenIndex, noCalls, stopState);
|
|
} else if (_base.isFlowEnabled) {
|
|
_flow.flowParseSubscript.call(void 0, startTokenIndex, noCalls, stopState);
|
|
} else {
|
|
baseParseSubscript(startTokenIndex, noCalls, stopState);
|
|
}
|
|
}
|
|
|
|
/** Set 'state.stop = true' to indicate that we should stop parsing subscripts. */
|
|
function baseParseSubscript(
|
|
startTokenIndex,
|
|
noCalls,
|
|
stopState,
|
|
) {
|
|
if (!noCalls && _index3.eat.call(void 0, _types3.TokenType.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 (_index3.match.call(void 0, _types3.TokenType.questionDot)) {
|
|
_base.state.tokens[startTokenIndex].isOptionalChainStart = true;
|
|
if (noCalls && _index3.lookaheadType.call(void 0, ) === _types3.TokenType.parenL) {
|
|
stopState.stop = true;
|
|
return;
|
|
}
|
|
_index3.next.call(void 0, );
|
|
_base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
|
|
|
|
if (_index3.eat.call(void 0, _types3.TokenType.bracketL)) {
|
|
parseExpression();
|
|
_util.expect.call(void 0, _types3.TokenType.bracketR);
|
|
} else if (_index3.eat.call(void 0, _types3.TokenType.parenL)) {
|
|
parseCallExpressionArguments();
|
|
} else {
|
|
parseMaybePrivateName();
|
|
}
|
|
} else if (_index3.eat.call(void 0, _types3.TokenType.dot)) {
|
|
_base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
|
|
parseMaybePrivateName();
|
|
} else if (_index3.eat.call(void 0, _types3.TokenType.bracketL)) {
|
|
_base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
|
|
parseExpression();
|
|
_util.expect.call(void 0, _types3.TokenType.bracketR);
|
|
} else if (!noCalls && _index3.match.call(void 0, _types3.TokenType.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 = _base.state.snapshot();
|
|
const asyncStartTokenIndex = _base.state.tokens.length;
|
|
_index3.next.call(void 0, );
|
|
_base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
|
|
|
|
const callContextId = _base.getNextContextId.call(void 0, );
|
|
|
|
_base.state.tokens[_base.state.tokens.length - 1].contextId = callContextId;
|
|
parseCallExpressionArguments();
|
|
_base.state.tokens[_base.state.tokens.length - 1].contextId = callContextId;
|
|
|
|
if (shouldParseAsyncArrow()) {
|
|
// We hit an arrow, so backtrack and start again parsing function parameters.
|
|
_base.state.restoreFromSnapshot(snapshot);
|
|
stopState.stop = true;
|
|
_base.state.scopeDepth++;
|
|
|
|
_statement.parseFunctionParams.call(void 0, );
|
|
parseAsyncArrowFromCallExpression(asyncStartTokenIndex);
|
|
}
|
|
} else {
|
|
_index3.next.call(void 0, );
|
|
_base.state.tokens[_base.state.tokens.length - 1].subscriptStartIndex = startTokenIndex;
|
|
const callContextId = _base.getNextContextId.call(void 0, );
|
|
_base.state.tokens[_base.state.tokens.length - 1].contextId = callContextId;
|
|
parseCallExpressionArguments();
|
|
_base.state.tokens[_base.state.tokens.length - 1].contextId = callContextId;
|
|
}
|
|
} else if (_index3.match.call(void 0, _types3.TokenType.backQuote)) {
|
|
// Tagged template expression.
|
|
parseTemplate();
|
|
} else {
|
|
stopState.stop = true;
|
|
}
|
|
} exports.baseParseSubscript = baseParseSubscript;
|
|
|
|
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 (
|
|
_base.state.tokens[_base.state.tokens.length - 1].contextualKeyword === _keywords.ContextualKeyword._async &&
|
|
!_util.canInsertSemicolon.call(void 0, )
|
|
);
|
|
} exports.atPossibleAsync = atPossibleAsync;
|
|
|
|
function parseCallExpressionArguments() {
|
|
let first = true;
|
|
while (!_index3.eat.call(void 0, _types3.TokenType.parenR) && !_base.state.error) {
|
|
if (first) {
|
|
first = false;
|
|
} else {
|
|
_util.expect.call(void 0, _types3.TokenType.comma);
|
|
if (_index3.eat.call(void 0, _types3.TokenType.parenR)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
parseExprListItem(false);
|
|
}
|
|
} exports.parseCallExpressionArguments = parseCallExpressionArguments;
|
|
|
|
function shouldParseAsyncArrow() {
|
|
return _index3.match.call(void 0, _types3.TokenType.colon) || _index3.match.call(void 0, _types3.TokenType.arrow);
|
|
}
|
|
|
|
function parseAsyncArrowFromCallExpression(startTokenIndex) {
|
|
if (_base.isTypeScriptEnabled) {
|
|
_typescript.tsStartParseAsyncArrowFromCallExpression.call(void 0, );
|
|
} else if (_base.isFlowEnabled) {
|
|
_flow.flowStartParseAsyncArrowFromCallExpression.call(void 0, );
|
|
}
|
|
_util.expect.call(void 0, _types3.TokenType.arrow);
|
|
parseArrowExpression(startTokenIndex);
|
|
}
|
|
|
|
// Parse a no-call expression (like argument of `new` or `::` operators).
|
|
|
|
function parseNoCallExpr() {
|
|
const startTokenIndex = _base.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.
|
|
function parseExprAtom() {
|
|
if (_index3.eat.call(void 0, _types3.TokenType.modulo)) {
|
|
// V8 intrinsic expression. Just parse the identifier, and the function invocation is parsed
|
|
// naturally.
|
|
parseIdentifier();
|
|
return false;
|
|
}
|
|
|
|
if (_index3.match.call(void 0, _types3.TokenType.jsxText) || _index3.match.call(void 0, _types3.TokenType.jsxEmptyText)) {
|
|
parseLiteral();
|
|
return false;
|
|
} else if (_index3.match.call(void 0, _types3.TokenType.lessThan) && _base.isJSXEnabled) {
|
|
_base.state.type = _types3.TokenType.jsxTagStart;
|
|
_index.jsxParseElement.call(void 0, );
|
|
_index3.next.call(void 0, );
|
|
return false;
|
|
}
|
|
|
|
const canBeArrow = _base.state.potentialArrowAt === _base.state.start;
|
|
switch (_base.state.type) {
|
|
case _types3.TokenType.slash:
|
|
case _types3.TokenType.assign:
|
|
_index3.retokenizeSlashAsRegex.call(void 0, );
|
|
// Fall through.
|
|
|
|
case _types3.TokenType._super:
|
|
case _types3.TokenType._this:
|
|
case _types3.TokenType.regexp:
|
|
case _types3.TokenType.num:
|
|
case _types3.TokenType.bigint:
|
|
case _types3.TokenType.decimal:
|
|
case _types3.TokenType.string:
|
|
case _types3.TokenType._null:
|
|
case _types3.TokenType._true:
|
|
case _types3.TokenType._false:
|
|
_index3.next.call(void 0, );
|
|
return false;
|
|
|
|
case _types3.TokenType._import:
|
|
_index3.next.call(void 0, );
|
|
if (_index3.match.call(void 0, _types3.TokenType.dot)) {
|
|
// import.meta
|
|
_base.state.tokens[_base.state.tokens.length - 1].type = _types3.TokenType.name;
|
|
_index3.next.call(void 0, );
|
|
parseIdentifier();
|
|
}
|
|
return false;
|
|
|
|
case _types3.TokenType.name: {
|
|
const startTokenIndex = _base.state.tokens.length;
|
|
const functionStart = _base.state.start;
|
|
const contextualKeyword = _base.state.contextualKeyword;
|
|
parseIdentifier();
|
|
if (contextualKeyword === _keywords.ContextualKeyword._await) {
|
|
parseAwait();
|
|
return false;
|
|
} else if (
|
|
contextualKeyword === _keywords.ContextualKeyword._async &&
|
|
_index3.match.call(void 0, _types3.TokenType._function) &&
|
|
!_util.canInsertSemicolon.call(void 0, )
|
|
) {
|
|
_index3.next.call(void 0, );
|
|
_statement.parseFunction.call(void 0, functionStart, false);
|
|
return false;
|
|
} else if (
|
|
canBeArrow &&
|
|
contextualKeyword === _keywords.ContextualKeyword._async &&
|
|
!_util.canInsertSemicolon.call(void 0, ) &&
|
|
_index3.match.call(void 0, _types3.TokenType.name)
|
|
) {
|
|
_base.state.scopeDepth++;
|
|
_lval.parseBindingIdentifier.call(void 0, false);
|
|
_util.expect.call(void 0, _types3.TokenType.arrow);
|
|
// let foo = async bar => {};
|
|
parseArrowExpression(startTokenIndex);
|
|
return true;
|
|
} else if (_index3.match.call(void 0, _types3.TokenType._do) && !_util.canInsertSemicolon.call(void 0, )) {
|
|
_index3.next.call(void 0, );
|
|
_statement.parseBlock.call(void 0, );
|
|
return false;
|
|
}
|
|
|
|
if (canBeArrow && !_util.canInsertSemicolon.call(void 0, ) && _index3.match.call(void 0, _types3.TokenType.arrow)) {
|
|
_base.state.scopeDepth++;
|
|
_lval.markPriorBindingIdentifier.call(void 0, false);
|
|
_util.expect.call(void 0, _types3.TokenType.arrow);
|
|
parseArrowExpression(startTokenIndex);
|
|
return true;
|
|
}
|
|
|
|
_base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index3.IdentifierRole.Access;
|
|
return false;
|
|
}
|
|
|
|
case _types3.TokenType._do: {
|
|
_index3.next.call(void 0, );
|
|
_statement.parseBlock.call(void 0, );
|
|
return false;
|
|
}
|
|
|
|
case _types3.TokenType.parenL: {
|
|
const wasArrow = parseParenAndDistinguishExpression(canBeArrow);
|
|
return wasArrow;
|
|
}
|
|
|
|
case _types3.TokenType.bracketL:
|
|
_index3.next.call(void 0, );
|
|
parseExprList(_types3.TokenType.bracketR, true);
|
|
return false;
|
|
|
|
case _types3.TokenType.braceL:
|
|
parseObj(false, false);
|
|
return false;
|
|
|
|
case _types3.TokenType._function:
|
|
parseFunctionExpression();
|
|
return false;
|
|
|
|
case _types3.TokenType.at:
|
|
_statement.parseDecorators.call(void 0, );
|
|
// Fall through.
|
|
|
|
case _types3.TokenType._class:
|
|
_statement.parseClass.call(void 0, false);
|
|
return false;
|
|
|
|
case _types3.TokenType._new:
|
|
parseNew();
|
|
return false;
|
|
|
|
case _types3.TokenType.backQuote:
|
|
parseTemplate();
|
|
return false;
|
|
|
|
case _types3.TokenType.doubleColon: {
|
|
_index3.next.call(void 0, );
|
|
parseNoCallExpr();
|
|
return false;
|
|
}
|
|
|
|
case _types3.TokenType.hash: {
|
|
const code = _index3.lookaheadCharCode.call(void 0, );
|
|
if (_identifier.IS_IDENTIFIER_START[code] || code === _charcodes.charCodes.backslash) {
|
|
parseMaybePrivateName();
|
|
} else {
|
|
_index3.next.call(void 0, );
|
|
}
|
|
// Smart pipeline topic reference.
|
|
return false;
|
|
}
|
|
|
|
default:
|
|
_util.unexpected.call(void 0, );
|
|
return false;
|
|
}
|
|
} exports.parseExprAtom = parseExprAtom;
|
|
|
|
function parseMaybePrivateName() {
|
|
_index3.eat.call(void 0, _types3.TokenType.hash);
|
|
parseIdentifier();
|
|
}
|
|
|
|
function parseFunctionExpression() {
|
|
const functionStart = _base.state.start;
|
|
parseIdentifier();
|
|
if (_index3.eat.call(void 0, _types3.TokenType.dot)) {
|
|
// function.sent
|
|
parseIdentifier();
|
|
}
|
|
_statement.parseFunction.call(void 0, functionStart, false);
|
|
}
|
|
|
|
function parseLiteral() {
|
|
_index3.next.call(void 0, );
|
|
} exports.parseLiteral = parseLiteral;
|
|
|
|
function parseParenExpression() {
|
|
_util.expect.call(void 0, _types3.TokenType.parenL);
|
|
parseExpression();
|
|
_util.expect.call(void 0, _types3.TokenType.parenR);
|
|
} exports.parseParenExpression = parseParenExpression;
|
|
|
|
// 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 = _base.state.snapshot();
|
|
|
|
const startTokenIndex = _base.state.tokens.length;
|
|
_util.expect.call(void 0, _types3.TokenType.parenL);
|
|
|
|
let first = true;
|
|
|
|
while (!_index3.match.call(void 0, _types3.TokenType.parenR) && !_base.state.error) {
|
|
if (first) {
|
|
first = false;
|
|
} else {
|
|
_util.expect.call(void 0, _types3.TokenType.comma);
|
|
if (_index3.match.call(void 0, _types3.TokenType.parenR)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (_index3.match.call(void 0, _types3.TokenType.ellipsis)) {
|
|
_lval.parseRest.call(void 0, false /* isBlockScope */);
|
|
parseParenItem();
|
|
break;
|
|
} else {
|
|
parseMaybeAssign(false, true);
|
|
}
|
|
}
|
|
|
|
_util.expect.call(void 0, _types3.TokenType.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.
|
|
_base.state.restoreFromSnapshot(snapshot);
|
|
_base.state.scopeDepth++;
|
|
// Don't specify a context ID because arrow functions don't need a context ID.
|
|
_statement.parseFunctionParams.call(void 0, );
|
|
parseArrow();
|
|
parseArrowExpression(startTokenIndex);
|
|
if (_base.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.
|
|
_base.state.restoreFromSnapshot(snapshot);
|
|
parseParenAndDistinguishExpression(false);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
function shouldParseArrow() {
|
|
return _index3.match.call(void 0, _types3.TokenType.colon) || !_util.canInsertSemicolon.call(void 0, );
|
|
}
|
|
|
|
// Returns whether there was an arrow token.
|
|
function parseArrow() {
|
|
if (_base.isTypeScriptEnabled) {
|
|
return _typescript.tsParseArrow.call(void 0, );
|
|
} else if (_base.isFlowEnabled) {
|
|
return _flow.flowParseArrow.call(void 0, );
|
|
} else {
|
|
return _index3.eat.call(void 0, _types3.TokenType.arrow);
|
|
}
|
|
} exports.parseArrow = parseArrow;
|
|
|
|
function parseParenItem() {
|
|
if (_base.isTypeScriptEnabled || _base.isFlowEnabled) {
|
|
_types.typedParseParenItem.call(void 0, );
|
|
}
|
|
}
|
|
|
|
// 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() {
|
|
_util.expect.call(void 0, _types3.TokenType._new);
|
|
if (_index3.eat.call(void 0, _types3.TokenType.dot)) {
|
|
// new.target
|
|
parseIdentifier();
|
|
return;
|
|
}
|
|
parseNewCallee();
|
|
if (_base.isFlowEnabled) {
|
|
_flow.flowStartParseNewArguments.call(void 0, );
|
|
}
|
|
if (_index3.eat.call(void 0, _types3.TokenType.parenL)) {
|
|
parseExprList(_types3.TokenType.parenR);
|
|
}
|
|
}
|
|
|
|
function parseNewCallee() {
|
|
parseNoCallExpr();
|
|
_index3.eat.call(void 0, _types3.TokenType.questionDot);
|
|
}
|
|
|
|
function parseTemplate() {
|
|
// Finish `, read quasi
|
|
_index3.nextTemplateToken.call(void 0, );
|
|
// Finish quasi, read ${
|
|
_index3.nextTemplateToken.call(void 0, );
|
|
while (!_index3.match.call(void 0, _types3.TokenType.backQuote) && !_base.state.error) {
|
|
_util.expect.call(void 0, _types3.TokenType.dollarBraceL);
|
|
parseExpression();
|
|
// Finish }, read quasi
|
|
_index3.nextTemplateToken.call(void 0, );
|
|
// Finish quasi, read either ${ or `
|
|
_index3.nextTemplateToken.call(void 0, );
|
|
}
|
|
_index3.next.call(void 0, );
|
|
} exports.parseTemplate = parseTemplate;
|
|
|
|
// Parse an object literal or binding pattern.
|
|
function parseObj(isPattern, isBlockScope) {
|
|
// Attach a context ID to the object open and close brace and each object key.
|
|
const contextId = _base.getNextContextId.call(void 0, );
|
|
let first = true;
|
|
|
|
_index3.next.call(void 0, );
|
|
_base.state.tokens[_base.state.tokens.length - 1].contextId = contextId;
|
|
|
|
while (!_index3.eat.call(void 0, _types3.TokenType.braceR) && !_base.state.error) {
|
|
if (first) {
|
|
first = false;
|
|
} else {
|
|
_util.expect.call(void 0, _types3.TokenType.comma);
|
|
if (_index3.eat.call(void 0, _types3.TokenType.braceR)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
let isGenerator = false;
|
|
if (_index3.match.call(void 0, _types3.TokenType.ellipsis)) {
|
|
const previousIndex = _base.state.tokens.length;
|
|
_lval.parseSpread.call(void 0, );
|
|
if (isPattern) {
|
|
// Mark role when the only thing being spread over is an identifier.
|
|
if (_base.state.tokens.length === previousIndex + 2) {
|
|
_lval.markPriorBindingIdentifier.call(void 0, isBlockScope);
|
|
}
|
|
if (_index3.eat.call(void 0, _types3.TokenType.braceR)) {
|
|
break;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (!isPattern) {
|
|
isGenerator = _index3.eat.call(void 0, _types3.TokenType.star);
|
|
}
|
|
|
|
if (!isPattern && _util.isContextual.call(void 0, _keywords.ContextualKeyword._async)) {
|
|
if (isGenerator) _util.unexpected.call(void 0, );
|
|
|
|
parseIdentifier();
|
|
if (
|
|
_index3.match.call(void 0, _types3.TokenType.colon) ||
|
|
_index3.match.call(void 0, _types3.TokenType.parenL) ||
|
|
_index3.match.call(void 0, _types3.TokenType.braceR) ||
|
|
_index3.match.call(void 0, _types3.TokenType.eq) ||
|
|
_index3.match.call(void 0, _types3.TokenType.comma)
|
|
) {
|
|
// This is a key called "async" rather than an async function.
|
|
} else {
|
|
if (_index3.match.call(void 0, _types3.TokenType.star)) {
|
|
_index3.next.call(void 0, );
|
|
isGenerator = true;
|
|
}
|
|
parsePropertyName(contextId);
|
|
}
|
|
} else {
|
|
parsePropertyName(contextId);
|
|
}
|
|
|
|
parseObjPropValue(isPattern, isBlockScope, contextId);
|
|
}
|
|
|
|
_base.state.tokens[_base.state.tokens.length - 1].contextId = contextId;
|
|
} exports.parseObj = parseObj;
|
|
|
|
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 &&
|
|
(_index3.match.call(void 0, _types3.TokenType.string) || // get "string"() {}
|
|
_index3.match.call(void 0, _types3.TokenType.num) || // get 1() {}
|
|
_index3.match.call(void 0, _types3.TokenType.bracketL) || // get ["string"]() {}
|
|
_index3.match.call(void 0, _types3.TokenType.name) || // get foo() {}
|
|
!!(_base.state.type & _types3.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 = _base.state.start;
|
|
if (_index3.match.call(void 0, _types3.TokenType.parenL)) {
|
|
if (isPattern) _util.unexpected.call(void 0, );
|
|
parseMethod(functionStart, /* isConstructor */ false);
|
|
return true;
|
|
}
|
|
|
|
if (isGetterOrSetterMethod(isPattern)) {
|
|
parsePropertyName(objectContextId);
|
|
parseMethod(functionStart, /* isConstructor */ false);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function parseObjectProperty(isPattern, isBlockScope) {
|
|
if (_index3.eat.call(void 0, _types3.TokenType.colon)) {
|
|
if (isPattern) {
|
|
_lval.parseMaybeDefault.call(void 0, 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 (_base.state.scopeDepth === 0) {
|
|
identifierRole = _index3.IdentifierRole.ObjectShorthandTopLevelDeclaration;
|
|
} else if (isBlockScope) {
|
|
identifierRole = _index3.IdentifierRole.ObjectShorthandBlockScopedDeclaration;
|
|
} else {
|
|
identifierRole = _index3.IdentifierRole.ObjectShorthandFunctionScopedDeclaration;
|
|
}
|
|
} else {
|
|
identifierRole = _index3.IdentifierRole.ObjectShorthand;
|
|
}
|
|
_base.state.tokens[_base.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.
|
|
_lval.parseMaybeDefault.call(void 0, isBlockScope, true);
|
|
}
|
|
|
|
function parseObjPropValue(
|
|
isPattern,
|
|
isBlockScope,
|
|
objectContextId,
|
|
) {
|
|
if (_base.isTypeScriptEnabled) {
|
|
_typescript.tsStartParseObjPropValue.call(void 0, );
|
|
} else if (_base.isFlowEnabled) {
|
|
_flow.flowStartParseObjPropValue.call(void 0, );
|
|
}
|
|
const wasMethod = parseObjectMethod(isPattern, objectContextId);
|
|
if (!wasMethod) {
|
|
parseObjectProperty(isPattern, isBlockScope);
|
|
}
|
|
}
|
|
|
|
function parsePropertyName(objectContextId) {
|
|
if (_base.isFlowEnabled) {
|
|
_flow.flowParseVariance.call(void 0, );
|
|
}
|
|
if (_index3.eat.call(void 0, _types3.TokenType.bracketL)) {
|
|
_base.state.tokens[_base.state.tokens.length - 1].contextId = objectContextId;
|
|
parseMaybeAssign();
|
|
_util.expect.call(void 0, _types3.TokenType.bracketR);
|
|
_base.state.tokens[_base.state.tokens.length - 1].contextId = objectContextId;
|
|
} else {
|
|
if (_index3.match.call(void 0, _types3.TokenType.num) || _index3.match.call(void 0, _types3.TokenType.string) || _index3.match.call(void 0, _types3.TokenType.bigint) || _index3.match.call(void 0, _types3.TokenType.decimal)) {
|
|
parseExprAtom();
|
|
} else {
|
|
parseMaybePrivateName();
|
|
}
|
|
|
|
_base.state.tokens[_base.state.tokens.length - 1].identifierRole = _index3.IdentifierRole.ObjectKey;
|
|
_base.state.tokens[_base.state.tokens.length - 1].contextId = objectContextId;
|
|
}
|
|
} exports.parsePropertyName = parsePropertyName;
|
|
|
|
// Parse object or class method.
|
|
function parseMethod(functionStart, isConstructor) {
|
|
const funcContextId = _base.getNextContextId.call(void 0, );
|
|
|
|
_base.state.scopeDepth++;
|
|
const startTokenIndex = _base.state.tokens.length;
|
|
const allowModifiers = isConstructor; // For TypeScript parameter properties
|
|
_statement.parseFunctionParams.call(void 0, allowModifiers, funcContextId);
|
|
parseFunctionBodyAndFinish(functionStart, funcContextId);
|
|
const endTokenIndex = _base.state.tokens.length;
|
|
_base.state.scopes.push(new (0, _state.Scope)(startTokenIndex, endTokenIndex, true));
|
|
_base.state.scopeDepth--;
|
|
} exports.parseMethod = parseMethod;
|
|
|
|
// Parse arrow function expression.
|
|
// If the parameters are provided, they will be converted to an
|
|
// assignable list.
|
|
function parseArrowExpression(startTokenIndex) {
|
|
parseFunctionBody(true);
|
|
const endTokenIndex = _base.state.tokens.length;
|
|
_base.state.scopes.push(new (0, _state.Scope)(startTokenIndex, endTokenIndex, true));
|
|
_base.state.scopeDepth--;
|
|
} exports.parseArrowExpression = parseArrowExpression;
|
|
|
|
function parseFunctionBodyAndFinish(functionStart, funcContextId = 0) {
|
|
if (_base.isTypeScriptEnabled) {
|
|
_typescript.tsParseFunctionBodyAndFinish.call(void 0, functionStart, funcContextId);
|
|
} else if (_base.isFlowEnabled) {
|
|
_flow.flowParseFunctionBodyAndFinish.call(void 0, funcContextId);
|
|
} else {
|
|
parseFunctionBody(false, funcContextId);
|
|
}
|
|
} exports.parseFunctionBodyAndFinish = parseFunctionBodyAndFinish;
|
|
|
|
function parseFunctionBody(allowExpression, funcContextId = 0) {
|
|
const isExpression = allowExpression && !_index3.match.call(void 0, _types3.TokenType.braceL);
|
|
|
|
if (isExpression) {
|
|
parseMaybeAssign();
|
|
} else {
|
|
_statement.parseBlock.call(void 0, true /* isFunctionScope */, funcContextId);
|
|
}
|
|
} exports.parseFunctionBody = parseFunctionBody;
|
|
|
|
// 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 (!_index3.eat.call(void 0, close) && !_base.state.error) {
|
|
if (first) {
|
|
first = false;
|
|
} else {
|
|
_util.expect.call(void 0, _types3.TokenType.comma);
|
|
if (_index3.eat.call(void 0, close)) break;
|
|
}
|
|
parseExprListItem(allowEmpty);
|
|
}
|
|
}
|
|
|
|
function parseExprListItem(allowEmpty) {
|
|
if (allowEmpty && _index3.match.call(void 0, _types3.TokenType.comma)) {
|
|
// Empty item; nothing more to parse for this item.
|
|
} else if (_index3.match.call(void 0, _types3.TokenType.ellipsis)) {
|
|
_lval.parseSpread.call(void 0, );
|
|
parseParenItem();
|
|
} else if (_index3.match.call(void 0, _types3.TokenType.question)) {
|
|
// Partial function application proposal.
|
|
_index3.next.call(void 0, );
|
|
} else {
|
|
parseMaybeAssign(false, true);
|
|
}
|
|
}
|
|
|
|
// Parse the next token as an identifier.
|
|
function parseIdentifier() {
|
|
_index3.next.call(void 0, );
|
|
_base.state.tokens[_base.state.tokens.length - 1].type = _types3.TokenType.name;
|
|
} exports.parseIdentifier = parseIdentifier;
|
|
|
|
// Parses await expression inside async function.
|
|
function parseAwait() {
|
|
parseMaybeUnary();
|
|
}
|
|
|
|
// Parses yield expression inside generator.
|
|
function parseYield() {
|
|
_index3.next.call(void 0, );
|
|
if (!_index3.match.call(void 0, _types3.TokenType.semi) && !_util.canInsertSemicolon.call(void 0, )) {
|
|
_index3.eat.call(void 0, _types3.TokenType.star);
|
|
parseMaybeAssign();
|
|
}
|
|
}
|
|
|
|
// https://github.com/tc39/proposal-js-module-blocks
|
|
function parseModuleExpression() {
|
|
_util.expectContextual.call(void 0, _keywords.ContextualKeyword._module);
|
|
_util.expect.call(void 0, _types3.TokenType.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.
|
|
_statement.parseBlockBody.call(void 0, _types3.TokenType.braceR);
|
|
}
|