Alex Hochheiden
d0470670a1
`third_party/node/node_modules` is generated by `./mach vendor node`. Differential Revision: https://phabricator.services.mozilla.com/D320322
4381 lines
138 KiB
JavaScript
4381 lines
138 KiB
JavaScript
/*
|
|
MIT License http://www.opensource.org/licenses/mit-license.php
|
|
Author Alexander Akait @alexander-akait
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
// cspell:ignore yuku binop prec Prec
|
|
|
|
const { Parser: BaseParser, tokTypes } = require("acorn");
|
|
|
|
// acorn exports its token-context table but leaves it out of its public types
|
|
const tokContexts =
|
|
/** @type {Record<string, unknown>} */
|
|
(
|
|
/** @type {{ tokContexts: Record<string, unknown> }} */
|
|
(/** @type {unknown} */ (require("acorn"))).tokContexts
|
|
);
|
|
|
|
/** @typedef {{ token: string, isExpr: boolean, preserveSpace?: boolean, override?: unknown }} TokContextShim acorn TokContext fields read by the owned tokenizer */
|
|
|
|
// acorn's token contexts used by the inlined finishToken context updates
|
|
const CTX_B_STAT = /** @type {TokContextShim} */ (tokContexts.b_stat);
|
|
const CTX_B_EXPR = /** @type {TokContextShim} */ (tokContexts.b_expr);
|
|
const CTX_P_STAT = /** @type {TokContextShim} */ (tokContexts.p_stat);
|
|
const CTX_P_EXPR = /** @type {TokContextShim} */ (tokContexts.p_expr);
|
|
const CTX_F_STAT = /** @type {TokContextShim} */ (tokContexts.f_stat);
|
|
const CTX_F_EXPR = /** @type {TokContextShim} */ (tokContexts.f_expr);
|
|
|
|
// acorn exports its keyword→TokenType map but leaves it out of its public
|
|
// types; used by the word-classification lookups below.
|
|
const keywordTypes =
|
|
/** @type {Record<string, TokenType>} */
|
|
(
|
|
/** @type {{ keywordTypes: Record<string, TokenType> }} */
|
|
(/** @type {unknown} */ (require("acorn"))).keywordTypes
|
|
);
|
|
|
|
/** @typedef {import("acorn").Options} Options */
|
|
/** @typedef {import("acorn").Position} Position */
|
|
/** @typedef {import("acorn").Node} Node */
|
|
/** @typedef {import("acorn").Identifier} Identifier */
|
|
/** @typedef {import("acorn").ImportAttribute} ImportAttribute */
|
|
/** @typedef {import("acorn").ImportDefaultSpecifier} ImportDefaultSpecifier */
|
|
/** @typedef {import("acorn").ImportExpression} ImportExpression */
|
|
/** @typedef {import("acorn").Expression} Expression */
|
|
/** @typedef {import("acorn").ImportSpecifier | import("acorn").ImportDefaultSpecifier | import("acorn").ImportNamespaceSpecifier} AnyImportSpecifier */
|
|
/** @typedef {import("acorn").TokenType} TokenType */
|
|
/** @typedef {TokenType & { beforeExpr: boolean, isAssign?: boolean, prefix?: boolean, postfix?: boolean, binop: number | null, updateContext?: (prevType: TokenType) => void }} TokenTypeInternal acorn's internal TokenType fields, absent from its public types */
|
|
/** @typedef {import("estree").SourceLocation} SourceLocation */
|
|
/** @typedef {[number, number]} Range */
|
|
/** @typedef {"defer" | "source"} ImportPhase */
|
|
/** @typedef {import("estree").Comment & { start: number, end: number }} CollectedComment comment as JavascriptParser exposes it */
|
|
|
|
// Symbol-keyed so they stay out of for-in, Object.keys and JSON.stringify
|
|
// over AST nodes.
|
|
const kSource = Symbol("source");
|
|
const kRange = Symbol("range");
|
|
const kText = Symbol("text");
|
|
const kTextStart = Symbol("text start");
|
|
|
|
// Marks import attributes parsed from the legacy `assert {...}` syntax.
|
|
const LEGACY_ASSERT_ATTRIBUTES = Symbol("assert");
|
|
|
|
// acorn's binding types and scope flags, stable across acorn 8
|
|
const BIND_VAR = 1;
|
|
const BIND_LEXICAL = 2;
|
|
const SCOPE_TOP = 1;
|
|
const SCOPE_SIMPLE_CATCH = 32;
|
|
// SCOPE_TOP | SCOPE_FUNCTION | SCOPE_CLASS_STATIC_BLOCK
|
|
const SCOPE_VAR = 0b100000011;
|
|
|
|
// ASCII identifier-continuation chars ($ 0-9 A-Z _ a-z); css/html-style
|
|
// Uint8Array table so the tokenizer fast path is one load per char
|
|
const IDENT_CHAR = new Uint8Array(128);
|
|
IDENT_CHAR[36] = 1;
|
|
IDENT_CHAR[95] = 1;
|
|
for (let i = 48; i <= 57; i++) IDENT_CHAR[i] = 1;
|
|
for (let i = 65; i <= 90; i++) IDENT_CHAR[i] = 1;
|
|
for (let i = 97; i <= 122; i++) IDENT_CHAR[i] = 1;
|
|
|
|
// ASCII identifier-start chars (IDENT_CHAR minus 0-9), for token dispatch in
|
|
// the owned `nextToken` loop.
|
|
const IDENT_START = new Uint8Array(128);
|
|
IDENT_START[36] = 1;
|
|
IDENT_START[95] = 1;
|
|
for (let i = 65; i <= 90; i++) IDENT_START[i] = 1;
|
|
for (let i = 97; i <= 122; i++) IDENT_START[i] = 1;
|
|
|
|
// Single-char punctuators that acorn's `getTokenFromCode` reads as just
|
|
// `++pos; finishToken(type)` (no value, no operator state machine). Dispatching
|
|
// them from `nextToken`'s char table skips the extra `getTokenFromCode` call and
|
|
// its switch for the commonest tokens in JS ( ) { } [ ] ; , : — `0` is "not a
|
|
// simple punctuator" since token types are truthy objects.
|
|
const SIMPLE_PUNCT = Array.from({ length: 128 });
|
|
SIMPLE_PUNCT[40] = tokTypes.parenL;
|
|
SIMPLE_PUNCT[41] = tokTypes.parenR;
|
|
SIMPLE_PUNCT[59] = tokTypes.semi;
|
|
SIMPLE_PUNCT[44] = tokTypes.comma;
|
|
SIMPLE_PUNCT[91] = tokTypes.bracketL;
|
|
SIMPLE_PUNCT[93] = tokTypes.bracketR;
|
|
SIMPLE_PUNCT[123] = tokTypes.braceL;
|
|
SIMPLE_PUNCT[125] = tokTypes.braceR;
|
|
SIMPLE_PUNCT[58] = tokTypes.colon;
|
|
|
|
// Char classification for the owned `nextToken` (yuku's ws_class): one table
|
|
// load steers both the whitespace skip loop and the token dispatch. Token
|
|
// classes sort below CLS_SPACE so the skip loop exits on a single compare.
|
|
const CLS_OTHER = 0;
|
|
const CLS_IDENT = 1;
|
|
const CLS_PUNCT = 2;
|
|
const CLS_DOT = 3;
|
|
const CLS_EQ = 4;
|
|
const CLS_UNICODE = 5;
|
|
const CLS_SPACE = 6;
|
|
const CLS_NEWLINE = 7;
|
|
const CLS_SLASH = 8;
|
|
// Full `charCodeAt` range so the scan loop needs no `code > 127` branch per
|
|
// character: every non-ASCII code unit classifies as CLS_UNICODE (which sorts
|
|
// below CLS_SPACE, so the loop exits on the same single compare) and the
|
|
// dispatch delegates it to acorn's unicode-aware paths.
|
|
const CHAR_CLASS = new Uint8Array(0x10000).fill(CLS_UNICODE, 128);
|
|
for (let i = 0; i < 128; i++) {
|
|
if (IDENT_START[i] === 1 || i === 92) CHAR_CLASS[i] = CLS_IDENT;
|
|
else if (SIMPLE_PUNCT[i] !== undefined) CHAR_CLASS[i] = CLS_PUNCT;
|
|
}
|
|
CHAR_CLASS[46] = CLS_DOT;
|
|
CHAR_CLASS[61] = CLS_EQ;
|
|
CHAR_CLASS[32] = CLS_SPACE;
|
|
CHAR_CLASS[9] = CLS_SPACE;
|
|
CHAR_CLASS[11] = CLS_SPACE;
|
|
CHAR_CLASS[12] = CLS_SPACE;
|
|
CHAR_CLASS[10] = CLS_NEWLINE;
|
|
CHAR_CLASS[13] = CLS_NEWLINE;
|
|
CHAR_CLASS[47] = CLS_SLASH;
|
|
|
|
/**
|
|
* Drop-in replacement for acorn's `Node` that materializes `loc` and `range`
|
|
* on first access instead of allocating them during parsing. Most nodes never
|
|
* get either read, which saves three objects and an array per node.
|
|
*/
|
|
class LazyLocNode {
|
|
/**
|
|
* @param {number} pos start offset
|
|
*/
|
|
constructor(pos) {
|
|
this.type = "";
|
|
this.start = pos;
|
|
this.end = 0;
|
|
}
|
|
|
|
/**
|
|
* Memoized in a symbol slot — a plain store is far cheaper than making the
|
|
* property own via defineProperty, and the slot stays invisible to for-in,
|
|
* Object.keys and JSON.stringify. No `loc` is served at all — locations
|
|
* are derived from offsets via `JavascriptParser#getLocation`.
|
|
* @returns {Range} source range
|
|
*/
|
|
get range() {
|
|
const cached = this[kRange];
|
|
if (cached !== undefined) return cached;
|
|
/** @type {Range} */
|
|
const range = [this.start, this.end];
|
|
if (this.end > 0) this[kRange] = range;
|
|
return range;
|
|
}
|
|
|
|
/**
|
|
* @param {Range} value source range
|
|
*/
|
|
set range(value) {
|
|
this[kRange] = value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `Identifier`, the most common node: all fields are assigned in
|
|
* one constructor, so every instance is born on its final hidden class instead
|
|
* of transitioning through acorn's start-empty-then-mutate construction.
|
|
*/
|
|
class IdentifierNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {string} name identifier name
|
|
*/
|
|
constructor(start, end, name) {
|
|
this.type = "Identifier";
|
|
this.start = start;
|
|
this.end = end;
|
|
this.name = name;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `Literal`; `bigint` and `regex` stay post-construction
|
|
* additions since both are rare.
|
|
*/
|
|
class LiteralNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {unknown} value literal value
|
|
* @param {string} raw literal source text
|
|
*/
|
|
constructor(start, end, value, raw) {
|
|
this.type = "Literal";
|
|
this.start = start;
|
|
this.end = end;
|
|
this.value = value;
|
|
this.raw = raw;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `MemberExpression`. `optional` is a real field on every
|
|
* instance since webpack always parses with `ecmaVersion >= 11`.
|
|
*/
|
|
class MemberExpressionNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {Expression} object object expression
|
|
* @param {Node} property property node
|
|
* @param {boolean} computed whether the access is computed (`a[b]`)
|
|
* @param {boolean} optional whether the access is optional (`a?.b`)
|
|
*/
|
|
constructor(start, end, object, property, computed, optional) {
|
|
this.type = "MemberExpression";
|
|
this.start = start;
|
|
this.end = end;
|
|
this.object = object;
|
|
this.property = property;
|
|
this.computed = computed;
|
|
this.optional = optional;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `CallExpression`; `optional` as in `MemberExpressionNode`.
|
|
*/
|
|
class CallExpressionNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {Expression} callee callee expression
|
|
* @param {Node[]} args call arguments
|
|
* @param {boolean} optional whether the call is optional (`a?.()`)
|
|
*/
|
|
constructor(start, end, callee, args, optional) {
|
|
this.type = "CallExpression";
|
|
this.start = start;
|
|
this.end = end;
|
|
this.callee = callee;
|
|
this.arguments = args;
|
|
this.optional = optional;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `ThisExpression`.
|
|
*/
|
|
class ThisNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
*/
|
|
constructor(start, end) {
|
|
this.type = "ThisExpression";
|
|
this.start = start;
|
|
this.end = end;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `BinaryExpression`/`LogicalExpression` — identical field sets,
|
|
* so both node types share one hidden class.
|
|
*/
|
|
class BinaryNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {"BinaryExpression" | "LogicalExpression"} type node type
|
|
* @param {Expression} left left operand
|
|
* @param {string} operator operator text
|
|
* @param {Expression} right right operand
|
|
*/
|
|
constructor(start, end, type, left, operator, right) {
|
|
this.type = type;
|
|
this.start = start;
|
|
this.end = end;
|
|
this.left = left;
|
|
this.operator = operator;
|
|
this.right = right;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `AssignmentExpression`.
|
|
*/
|
|
class AssignmentNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {string} operator assignment operator text
|
|
* @param {Node} left assignment target
|
|
* @param {Expression} right assigned value
|
|
*/
|
|
constructor(start, end, operator, left, right) {
|
|
this.type = "AssignmentExpression";
|
|
this.start = start;
|
|
this.end = end;
|
|
this.operator = operator;
|
|
this.left = left;
|
|
this.right = right;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `UnaryExpression`/`UpdateExpression` — identical field sets,
|
|
* so both node types share one hidden class.
|
|
*/
|
|
class UnaryNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {"UnaryExpression" | "UpdateExpression"} type node type
|
|
* @param {string} operator operator text
|
|
* @param {boolean} prefix whether the operator is prefixed
|
|
* @param {Expression} argument operand
|
|
*/
|
|
constructor(start, end, type, operator, prefix, argument) {
|
|
this.type = type;
|
|
this.start = start;
|
|
this.end = end;
|
|
this.operator = operator;
|
|
this.prefix = prefix;
|
|
this.argument = argument;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `VariableDeclaration` (statement position; `for` heads keep the
|
|
* generic node since their caller finishes them).
|
|
*/
|
|
class VariableDeclarationNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {Node[]} declarations declarators
|
|
* @param {string} kind declaration kind (`var`/`let`/`const`/`using`)
|
|
*/
|
|
constructor(start, end, declarations, kind) {
|
|
this.type = "VariableDeclaration";
|
|
this.start = start;
|
|
this.end = end;
|
|
this.declarations = declarations;
|
|
this.kind = kind;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `VariableDeclarator`.
|
|
*/
|
|
class VariableDeclaratorNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {Node} id binding target
|
|
* @param {Expression | null} init initializer
|
|
*/
|
|
constructor(start, end, id, init) {
|
|
this.type = "VariableDeclarator";
|
|
this.start = start;
|
|
this.end = end;
|
|
this.id = id;
|
|
this.init = init;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `ExpressionStatement`.
|
|
*/
|
|
class ExpressionStatementNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {Expression} expression the statement's expression
|
|
*/
|
|
constructor(start, end, expression) {
|
|
this.type = "ExpressionStatement";
|
|
this.start = start;
|
|
this.end = end;
|
|
this.expression = expression;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `BlockStatement`.
|
|
*/
|
|
class BlockStatementNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {Node[]} body statements
|
|
*/
|
|
constructor(start, end, body) {
|
|
this.type = "BlockStatement";
|
|
this.start = start;
|
|
this.end = end;
|
|
this.body = body;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `IfStatement`.
|
|
*/
|
|
class IfStatementNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {Expression} test condition
|
|
* @param {Node} consequent then-branch
|
|
* @param {Node | null} alternate else-branch
|
|
*/
|
|
constructor(start, end, test, consequent, alternate) {
|
|
this.type = "IfStatement";
|
|
this.start = start;
|
|
this.end = end;
|
|
this.test = test;
|
|
this.consequent = consequent;
|
|
this.alternate = alternate;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `ReturnStatement`.
|
|
*/
|
|
class ReturnStatementNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {Expression | null} argument returned expression
|
|
*/
|
|
constructor(start, end, argument) {
|
|
this.type = "ReturnStatement";
|
|
this.start = start;
|
|
this.end = end;
|
|
this.argument = argument;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `ConditionalExpression`.
|
|
*/
|
|
class ConditionalExpressionNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {Expression} test condition
|
|
* @param {Expression} consequent then-value
|
|
* @param {Expression} alternate else-value
|
|
*/
|
|
constructor(start, end, test, consequent, alternate) {
|
|
this.type = "ConditionalExpression";
|
|
this.start = start;
|
|
this.end = end;
|
|
this.test = test;
|
|
this.consequent = consequent;
|
|
this.alternate = alternate;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `NewExpression`.
|
|
*/
|
|
class NewExpressionNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {Expression} callee constructed expression
|
|
* @param {Expression[]} args constructor arguments
|
|
*/
|
|
constructor(start, end, callee, args) {
|
|
this.type = "NewExpression";
|
|
this.start = start;
|
|
this.end = end;
|
|
this.callee = callee;
|
|
this.arguments = args;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `ArrayExpression`.
|
|
*/
|
|
class ArrayExpressionNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {(Expression | null)[]} elements array elements (`null` for holes)
|
|
*/
|
|
constructor(start, end, elements) {
|
|
this.type = "ArrayExpression";
|
|
this.start = start;
|
|
this.end = end;
|
|
this.elements = elements;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `TemplateLiteral`.
|
|
*/
|
|
class TemplateLiteralNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {Expression[]} expressions substitution expressions
|
|
* @param {Node[]} quasis template chunks
|
|
*/
|
|
constructor(start, end, expressions, quasis) {
|
|
this.type = "TemplateLiteral";
|
|
this.start = start;
|
|
this.end = end;
|
|
this.expressions = expressions;
|
|
this.quasis = quasis;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `TemplateElement`.
|
|
*/
|
|
class TemplateElementNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {{ raw: string, cooked: string | null }} value chunk text
|
|
* @param {boolean} tail whether this is the closing chunk
|
|
*/
|
|
constructor(start, end, value, tail) {
|
|
this.type = "TemplateElement";
|
|
this.start = start;
|
|
this.end = end;
|
|
this.value = value;
|
|
this.tail = tail;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `ObjectExpression`/`ObjectPattern` — identical field sets, so
|
|
* both node types share one hidden class.
|
|
*/
|
|
class ObjectNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {"ObjectExpression" | "ObjectPattern"} type node type
|
|
* @param {Node[]} properties properties
|
|
*/
|
|
constructor(start, end, type, properties) {
|
|
this.type = type;
|
|
this.start = start;
|
|
this.end = end;
|
|
this.properties = properties;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Pre-shaped `Property`: acorn fills property nodes through shared
|
|
* subroutines (`parsePropertyName`/`parsePropertyValue`), so instead of
|
|
* rebuilding that flow the fields are all declared up-front and acorn's
|
|
* writes land in existing slots — one hidden class, no transitions (yuku's
|
|
* decoder emits `Property` with this fixed shape). Every non-throwing acorn
|
|
* branch assigns `computed`, `key`, `value` and `kind`; `finishNode` sets
|
|
* `type` and `end`.
|
|
*/
|
|
class PropertyNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
*/
|
|
constructor(start) {
|
|
this.type = "";
|
|
this.start = start;
|
|
this.end = 0;
|
|
this.method = false;
|
|
this.shorthand = false;
|
|
this.computed = false;
|
|
/** @type {Node | null} */
|
|
this.key = null;
|
|
/** @type {Node | null} */
|
|
this.value = null;
|
|
this.kind = "";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Single-shape `SpreadElement`/`RestElement` — identical field sets, so both
|
|
* node types share one hidden class.
|
|
*/
|
|
class RestSpreadNode {
|
|
/**
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {"SpreadElement" | "RestElement"} type node type
|
|
* @param {Node} argument spread/rest argument
|
|
*/
|
|
constructor(start, end, type, argument) {
|
|
this.type = type;
|
|
this.start = start;
|
|
this.end = end;
|
|
this.argument = argument;
|
|
}
|
|
}
|
|
|
|
// Shared zero-length arguments array for `new X` without parens, mirroring
|
|
// acorn's module-level `empty`.
|
|
/** @type {Expression[]} */
|
|
const EMPTY_NEW_ARGS = [];
|
|
|
|
/**
|
|
* Mirror of acorn's module-level `isLocalVariableAccess`.
|
|
* @param {Node} node checked node
|
|
* @returns {boolean} whether the node reads a local variable
|
|
*/
|
|
const isLocalVariableAccess = (node) =>
|
|
node.type === "Identifier" ||
|
|
(node.type === "ParenthesizedExpression" &&
|
|
isLocalVariableAccess(
|
|
/** @type {Node} */ (
|
|
/** @type {Node & { expression?: Node }} */ (node).expression
|
|
)
|
|
));
|
|
|
|
/**
|
|
* Mirror of acorn's module-level `isPrivateFieldAccess`.
|
|
* @param {Node} node checked node
|
|
* @returns {boolean} whether the node accesses a private field
|
|
*/
|
|
const isPrivateFieldAccess = (node) =>
|
|
(node.type === "MemberExpression" &&
|
|
/** @type {Node} */ (
|
|
/** @type {Node & { property?: Node }} */ (node).property
|
|
).type === "PrivateIdentifier") ||
|
|
(node.type === "ChainExpression" &&
|
|
isPrivateFieldAccess(
|
|
/** @type {Node} */ (
|
|
/** @type {Node & { expression?: Node }} */ (node).expression
|
|
)
|
|
)) ||
|
|
(node.type === "ParenthesizedExpression" &&
|
|
isPrivateFieldAccess(
|
|
/** @type {Node} */ (
|
|
/** @type {Node & { expression?: Node }} */ (node).expression
|
|
)
|
|
));
|
|
|
|
// the dedicated node classes serve `range` exactly like LazyLocNode
|
|
for (const NodeClass of [
|
|
IdentifierNode,
|
|
LiteralNode,
|
|
MemberExpressionNode,
|
|
CallExpressionNode,
|
|
ThisNode,
|
|
BinaryNode,
|
|
AssignmentNode,
|
|
UnaryNode,
|
|
VariableDeclarationNode,
|
|
VariableDeclaratorNode,
|
|
ExpressionStatementNode,
|
|
BlockStatementNode,
|
|
IfStatementNode,
|
|
ReturnStatementNode,
|
|
ConditionalExpressionNode,
|
|
NewExpressionNode,
|
|
ArrayExpressionNode,
|
|
TemplateLiteralNode,
|
|
TemplateElementNode,
|
|
ObjectNode,
|
|
PropertyNode,
|
|
RestSpreadNode
|
|
]) {
|
|
for (const key of ["range"]) {
|
|
Object.defineProperty(
|
|
NodeClass.prototype,
|
|
key,
|
|
/** @type {PropertyDescriptor} */
|
|
(Object.getOwnPropertyDescriptor(LazyLocNode.prototype, key))
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Comment collected without slicing its text out of the source: only magic
|
|
* comments and pure annotations ever get their text read, so the slice is
|
|
* deferred to the first `value` access and memoized like `loc`.
|
|
*/
|
|
class LazyComment {
|
|
/**
|
|
* @param {boolean} block whether this is a block comment
|
|
* @param {number} textStart offset right after the comment opener
|
|
* @param {number} start start offset
|
|
* @param {number} end end offset
|
|
* @param {string} source full source text for the lazy `value` slice
|
|
*/
|
|
constructor(block, textStart, start, end, source) {
|
|
/** @type {"Block" | "Line"} */
|
|
this.type = block ? "Block" : "Line";
|
|
this.start = start;
|
|
this.end = end;
|
|
/** @type {Range} */
|
|
this.range = [start, end];
|
|
this[kSource] = source;
|
|
this[kTextStart] = textStart;
|
|
}
|
|
|
|
/**
|
|
* @returns {string} comment text without the delimiters
|
|
*/
|
|
get value() {
|
|
const cached = this[kText];
|
|
if (cached !== undefined) return cached;
|
|
return (this[kText] = this[kSource].slice(
|
|
this[kTextStart],
|
|
this.type === "Block" ? this.end - 2 : this.end
|
|
));
|
|
}
|
|
|
|
/**
|
|
* @param {string} value comment text
|
|
*/
|
|
set value(value) {
|
|
this[kText] = value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Replaces acorn's array-backed `Scope`: membership checks in `declareName`
|
|
* are `indexOf` there, which goes quadratic on files with thousands of
|
|
* bindings per scope (bundled or minified inputs). The three Sets are
|
|
* allocated lazily — most scopes declare into only one (module `functions` is
|
|
* always empty), so ~⅔ of the Sets are never needed.
|
|
*/
|
|
class Scope {
|
|
/**
|
|
* @param {number} flags scope flags
|
|
*/
|
|
constructor(flags) {
|
|
this.flags = flags;
|
|
/** @type {Set<string> | undefined} */
|
|
this.var = undefined;
|
|
/** @type {Set<string> | undefined} */
|
|
this.lexical = undefined;
|
|
/** @type {Set<string> | undefined} */
|
|
this.functions = undefined;
|
|
// first lexically-declared name; stands in for acorn's `lexical[0]`
|
|
// (the catch parameter of a simple catch scope)
|
|
/** @type {string | undefined} */
|
|
this.firstLexical = undefined;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Acorn's methods and state used by `WebpackParser` but missing from its
|
|
* public types, plus `WebpackParser`'s own fields, so overridden methods can
|
|
* declare `this` precisely.
|
|
* @typedef {import("acorn").Parser & {
|
|
* type: TokenType,
|
|
* value: unknown,
|
|
* start: number,
|
|
* startLoc?: Position,
|
|
* containsEsc: boolean,
|
|
* exprAllowed: boolean,
|
|
* options: Options,
|
|
* end: number,
|
|
* lastTokEnd: number,
|
|
* canInsertSemicolon: () => boolean,
|
|
* nextToken: () => void,
|
|
* next: (ignoreEscapeSequenceInKeyword?: boolean) => void,
|
|
* eat: (type: TokenType) => boolean,
|
|
* expect: (type: TokenType) => void,
|
|
* afterTrailingComma: (type: TokenType, notNext?: boolean) => boolean,
|
|
* unexpected: (pos?: number) => never,
|
|
* raise: (pos: number, message: string) => never,
|
|
* raiseRecoverable: (pos: number, message: string) => void,
|
|
* isContextual: (name: string) => boolean,
|
|
* parseIdent: (liberal?: boolean) => Identifier,
|
|
* parseLiteral: (value: unknown) => Node,
|
|
* awaitIdentPos: number,
|
|
* lastTokStart: number,
|
|
* yieldPos: number,
|
|
* awaitPos: number,
|
|
* parseExpression: () => Expression,
|
|
* parseSpread: (refDestructuringErrors?: DestructuringErrorsShim | null) => Node,
|
|
* braceIsBlock: (prevType: TokenType) => boolean,
|
|
* _gapHasNewline: () => boolean,
|
|
* parseExprList: (close: TokenType, allowTrailingComma: boolean, allowEmpty: boolean, refDestructuringErrors?: DestructuringErrorsShim | null) => Expression[],
|
|
* parsePrivateIdent: () => Node,
|
|
* parseTemplate: (opts: { isTagged: boolean }) => Node,
|
|
* shouldParseAsyncArrow: () => boolean,
|
|
* parseSubscriptAsyncArrow: (startPos: number, startLoc: Position | undefined, exprList: Expression[], forInit: boolean | string) => Expression,
|
|
* checkPatternErrors: (refDestructuringErrors: DestructuringErrorsShim, isAssign: boolean) => void,
|
|
* checkYieldAwaitInDefaultParams: () => void,
|
|
* checkExpressionErrors: (refDestructuringErrors?: DestructuringErrorsShim | null, andThrow?: boolean) => boolean,
|
|
* parseSubscript: (base: Expression, startPos: number, startLoc: Position | undefined, noCalls: boolean | undefined, maybeAsyncArrow: boolean, optionalChained: boolean, forInit: boolean | string) => Expression,
|
|
* parseExprAtom: (refDestructuringErrors?: DestructuringErrorsShim | null, forInit?: boolean | string, forNew?: boolean) => Expression,
|
|
* buildBinary: (startPos: number, startLoc: Position | undefined, left: Expression, right: Expression, op: string, logical: boolean) => Expression,
|
|
* parseMaybeAssign: (forInit?: boolean | string, refDestructuringErrors?: DestructuringErrorsShim | null, afterLeftParse?: (this: unknown, left: Expression, startPos: number, startLoc?: Position) => Expression) => Expression,
|
|
* parseMaybeConditional: (forInit?: boolean | string, refDestructuringErrors?: DestructuringErrorsShim | null) => Expression,
|
|
* parseMaybeUnary: (refDestructuringErrors: DestructuringErrorsShim | null, sawUnary: boolean, incDec: boolean, forInit?: boolean | string) => Expression,
|
|
* parseExprSubscripts: (refDestructuringErrors?: DestructuringErrorsShim | null, forInit?: boolean | string) => Expression,
|
|
* parseAwait: (forInit?: boolean | string) => Expression,
|
|
* canAwait: boolean,
|
|
* privateNameStack: unknown[],
|
|
* semicolon: () => void,
|
|
* exitScope: () => void,
|
|
* parseStatement: (context: string | null, topLevel?: boolean, exports?: unknown) => Node,
|
|
* parseBindingAtom: () => Node,
|
|
* parseVarStatement: (node: Node, kind: string, allowMissingInitializer?: boolean) => Node,
|
|
* parseVar: (node: Node, isFor: boolean, kind: string, allowMissingInitializer?: boolean) => Node,
|
|
* parseExpressionStatement: (node: Node, expr: Expression) => Node,
|
|
* parseParenExpression: () => Expression,
|
|
* parseIfStatement: (node: Node) => Node,
|
|
* parseReturnStatement: (node: Node) => Node,
|
|
* insertSemicolon: () => boolean,
|
|
* allowReturn: boolean,
|
|
* allowNewDotTarget: boolean,
|
|
* parseExprOps: (forInit?: boolean | string, refDestructuringErrors?: DestructuringErrorsShim | null) => Expression,
|
|
* parseExprOp: (left: Expression, leftStartPos: number, leftStartLoc: Position | undefined, minPrec: number, forInit?: boolean | string) => Expression,
|
|
* _deStack: DestructuringErrorsShim[],
|
|
* _deDepth: number,
|
|
* _ecmaVersion: number,
|
|
* _noLocations: boolean,
|
|
* _validRegexpFlags: string,
|
|
* _propHashFastPath: boolean,
|
|
* _propHashStack: { proto: boolean }[],
|
|
* _propHashDepth: number,
|
|
* _acquireDestructuringErrors: () => DestructuringErrorsShim,
|
|
* _releaseDestructuringErrors: () => void,
|
|
* parseSubscripts: (base: Expression, startPos: number, startLoc: Position | undefined, noCalls?: boolean, forInit?: boolean | string) => Expression,
|
|
* parseNew: () => Expression,
|
|
* parseTemplateElement: (opts: { isTagged: boolean }) => Node,
|
|
* parseBlock: (createNewLexicalScope?: boolean, node?: Node, exitStrict?: boolean) => Node,
|
|
* parseYield: (forInit?: boolean | string) => Expression,
|
|
* toAssignable: (node: Node, isBinding?: boolean, refDestructuringErrors?: DestructuringErrorsShim | null) => Node,
|
|
* checkLValPattern: (expr: Node, bindingType?: number, checkClashes?: unknown) => void,
|
|
* checkUnreserved: (ref: Identifier) => void,
|
|
* enterScope: (flags: number) => void,
|
|
* readRegexp: () => void,
|
|
* potentialArrowAt: number,
|
|
* potentialArrowInForAwait: boolean,
|
|
* overrideContext: (tokenCtx: unknown) => void,
|
|
* parseFunction: (node: Node, statement: number, allowExpressionBody?: boolean, isAsync?: boolean, forInit?: boolean | string) => Expression,
|
|
* parseArrowExpression: (node: Node, params: Node[], isAsync: boolean, forInit?: boolean | string) => Expression,
|
|
* _subscriptFastPath: boolean,
|
|
* checkLValSimple: (expr: Node, bindingType?: number) => void,
|
|
* startNode: () => Node,
|
|
* startNodeAt: (pos: number, loc?: Position) => Node,
|
|
* finishNode: (node: Node, type: string) => Node,
|
|
* readWord1: () => string,
|
|
* readWord: () => void,
|
|
* readToken: (code: number) => void,
|
|
* getTokenFromCode: (code: number) => void,
|
|
* fullCharCodeAtPos: () => number,
|
|
* skipSpace: () => void,
|
|
* skipLineComment: (startSkip: number) => void,
|
|
* skipBlockComment: () => void,
|
|
* readString: (quote: number) => void,
|
|
* readNumber: (startsWithDot: boolean) => void,
|
|
* readRadixNumber: (radix: number) => void,
|
|
* readTmplToken: () => void,
|
|
* finishToken: (type: TokenType, value?: unknown) => void,
|
|
* context: TokContextShim[],
|
|
* pos: number,
|
|
* input: string,
|
|
* scopeStack: Scope[],
|
|
* currentScope: () => Scope,
|
|
* currentThisScope: () => Scope,
|
|
* currentVarScope: () => Scope,
|
|
* keywords: RegExp,
|
|
* reservedWords: RegExp,
|
|
* reservedWordsStrict: RegExp,
|
|
* reservedWordsStrictBind: RegExp,
|
|
* strict: boolean,
|
|
* inGenerator: boolean,
|
|
* inGeneratorContext: () => boolean,
|
|
* inAsync: boolean,
|
|
* inClassStaticBlock: boolean,
|
|
* _wordLookups: WordLookups,
|
|
* treatFunctionsAsVar: boolean,
|
|
* treatFunctionsAsVarInScope: (scope: Scope) => boolean,
|
|
* inModule: boolean,
|
|
* undefinedExports: Record<string, Node>,
|
|
* parseObj: (isPattern: boolean, refDestructuringErrors?: DestructuringErrorsShim | null) => Node,
|
|
* parseProperty: (isPattern: boolean, refDestructuringErrors?: DestructuringErrorsShim | null) => Node,
|
|
* parsePropertyName: (prop: Node) => Node,
|
|
* parsePropertyValue: (prop: Node, isPattern: boolean, isGenerator: boolean, isAsync: boolean, startPos: number | undefined, startLoc: Position | undefined, refDestructuringErrors: DestructuringErrorsShim | null | undefined, containsEsc: boolean) => void,
|
|
* isAsyncProp: (prop: Node) => boolean,
|
|
* checkPropClash: (prop: Node, propHash: Record<string, unknown>, refDestructuringErrors?: DestructuringErrorsShim | null) => void,
|
|
* parseImport: (node: Node) => Node,
|
|
* parseExport: (node: Node, exports: unknown) => Node,
|
|
* parseImportSpecifiers: () => AnyImportSpecifier[],
|
|
* parseImportAttribute: () => ImportAttribute,
|
|
* parseExprImport: (forNew: boolean) => Expression,
|
|
* parseImportMeta: (node: Node) => Expression,
|
|
* parseDynamicImport: (node: Node) => Expression,
|
|
* _lazy: boolean,
|
|
* _importPhase: ImportPhase | null,
|
|
* _importPhasesEnabled: boolean,
|
|
* _lazyComments: CollectedComment[] | undefined,
|
|
* _newlineBefore: 0 | 1 | 2,
|
|
* _fullTokenFastPath: boolean,
|
|
* _stmtFastPath: boolean,
|
|
* isLet: (context?: string | null) => boolean,
|
|
* parseLabeledStatement: (node: Node, maybeName: string, expr: Identifier, context: string | null) => Node,
|
|
* _parseVarInto: (declarations: Node[], isFor: boolean, kind: string, allowMissingInitializer?: boolean) => void,
|
|
* _parseVarStatementAt: (start: number, kind: string, allowMissingInitializer?: boolean) => Node,
|
|
* _parseIfStatementAt: (start: number) => Node,
|
|
* _parseReturnStatementAt: (start: number) => Node,
|
|
* _parseExpressionStatementAt: (start: number, expr: Expression) => Node,
|
|
* _moduleFallback: boolean,
|
|
* _moduleSyntaxSeen: boolean,
|
|
* _tryModuleFallback: () => boolean,
|
|
* }} ParserInternals
|
|
*/
|
|
|
|
// internal methods are absent from acorn's types, so super calls do not
|
|
// type-check; call through a typed view of the base prototype instead
|
|
const base = /** @type {ParserInternals} */ (
|
|
/** @type {unknown} */ (BaseParser.prototype)
|
|
);
|
|
|
|
/**
|
|
* Acorn's internal destructuring-errors record; the class itself is not
|
|
* exported. Owned methods must create records with the same hidden class the
|
|
* rest of the expression parser reads, or every record field access there
|
|
* turns polymorphic.
|
|
* @typedef {{ shorthandAssign: number, trailingComma: number, parenthesizedAssign: number, parenthesizedBind: number, doubleProto: number }} DestructuringErrorsShim
|
|
*/
|
|
|
|
// Capture the class at module load: parse one expression through a probe
|
|
// whose `checkExpressionErrors` sees the record the base parser created.
|
|
/** @type {{ new (): DestructuringErrorsShim } | null} */
|
|
const DestructuringErrorsClass = (() => {
|
|
/** @type {{ new (): DestructuringErrorsShim } | null} */
|
|
let captured = null;
|
|
class Probe extends BaseParser {
|
|
/**
|
|
* @param {DestructuringErrorsShim | null} refDestructuringErrors record to inspect
|
|
* @param {boolean=} andThrow whether to throw on error
|
|
* @returns {boolean} whether an error position was set
|
|
*/
|
|
checkExpressionErrors(refDestructuringErrors, andThrow) {
|
|
if (refDestructuringErrors) {
|
|
captured =
|
|
/** @type {{ new (): DestructuringErrorsShim }} */
|
|
(refDestructuringErrors.constructor);
|
|
}
|
|
return /** @type {ParserInternals} */ (
|
|
/** @type {unknown} */ (base)
|
|
).checkExpressionErrors.call(this, refDestructuringErrors, andThrow);
|
|
}
|
|
}
|
|
Probe.parse("a", { ecmaVersion: 2020 });
|
|
// cast: the closure assignment above is invisible to control-flow analysis
|
|
return /** @type {{ new (): DestructuringErrorsShim } | null} */ (captured);
|
|
})();
|
|
|
|
/**
|
|
* @returns {DestructuringErrorsShim} fresh destructuring-errors record on acorn's own class (plain-object fallback if the capture ever fails)
|
|
*/
|
|
const createDestructuringErrors = () => {
|
|
const DestructuringErrors = DestructuringErrorsClass;
|
|
return DestructuringErrors !== null
|
|
? new DestructuringErrors()
|
|
: {
|
|
shorthandAssign: -1,
|
|
trailingComma: -1,
|
|
parenthesizedAssign: -1,
|
|
parenthesizedBind: -1,
|
|
doubleProto: -1
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Reserved-word classification for `checkUnreserved`'s single lookup:
|
|
* `1` keyword, `2` reserved in sloppy and strict mode, `3` reserved in strict
|
|
* mode only.
|
|
* @typedef {1 | 2 | 3} ReservedKind
|
|
*/
|
|
|
|
/**
|
|
* @typedef {object} WordLookups
|
|
* @property {Map<string, TokenType>} keywords keyword name → token type
|
|
* @property {Map<string, ReservedKind>} reservedKinds identifier name → reserved kind
|
|
* @property {number} reservedMaxLen longest key in `reservedKinds`
|
|
* @property {{ test: (name: string) => boolean }} reservedBindTest strict-mode binding check, a Set-backed stand-in for acorn's `reservedWordsStrictBind` regexp
|
|
*/
|
|
|
|
// One entry per distinct keyword/reserved-word set; webpack parses with a
|
|
// single option set, making this effectively a one-time build shared across
|
|
// every parse.
|
|
/** @type {Map<string, WordLookups>} */
|
|
const wordLookupsCache = new Map();
|
|
|
|
/**
|
|
* @param {string} word interned candidate
|
|
* @param {string} input source code
|
|
* @param {number} start word start offset
|
|
* @param {number} len word length (already known equal to `word.length`)
|
|
* @returns {boolean} whether the source span spells `word`
|
|
*/
|
|
const sameWord = (word, input, start, len) => {
|
|
for (let i = 0; i < len; i++) {
|
|
if (word.charCodeAt(i) !== input.charCodeAt(start + i)) return false;
|
|
}
|
|
return true;
|
|
};
|
|
|
|
// Direct-mapped identifier cache for `readWord1`: one slot per hash, verified
|
|
// by char compare, overwritten on collision. Shared across parses — hits are
|
|
// content-checked, so a stale entry is merely a miss. Only words short enough
|
|
// to be flat V8 strings (never slices retaining their whole source) are stored.
|
|
const WORD_CACHE_MASK = 0x1fff;
|
|
/** @type {(string | null)[]} */
|
|
const WORD_CACHE = Array.from({ length: WORD_CACHE_MASK + 1 }, () => null);
|
|
const WORD_CACHE_MAX_LEN = 12;
|
|
|
|
// Multi-char operator strings for `finishOp` (`=>`, `===`, `&&=`, …), keyed by
|
|
// their char codes packed 7 bits apart — collision-free for ASCII operators up
|
|
// to acorn's maximum of 4 chars (`>>>=`), so the set stays ~40 entries.
|
|
/** @type {Map<number, string>} */
|
|
const OP_CACHE = new Map();
|
|
|
|
// Sticky mirrors of acorn's `skipWhiteSpace` / string-literal / `lineBreak`
|
|
// regexes for the owned `strictDirective` (they scan at an offset, no slice).
|
|
const STRICT_SKIP_WS = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
|
|
const STRICT_LITERAL = /(?:'((?:\\[^]|[^'\\])*?)'|"((?:\\[^]|[^"\\])*?)")/y;
|
|
const STRICT_LINE_BREAK = /\r\n?|\n|\u2028|\u2029/;
|
|
|
|
/**
|
|
* @param {RegExp} re acorn `wordsRegexp` output (`^(?:a|b|c)$`)
|
|
* @returns {Set<string>} the alternation's words
|
|
*/
|
|
const wordsRegexpToSet = (re) => {
|
|
const match = /^\^\(\?:(.*)\)\$$/.exec(re.source);
|
|
const body = match ? match[1] : "";
|
|
return new Set(body ? body.split("|") : []);
|
|
};
|
|
|
|
// One-entry identity memo in front of the string-keyed cache: acorn's
|
|
// `wordsRegexp` interns its regexps, so identity captures the whole word set,
|
|
// and builds construct thousands of parsers with one option set — this makes
|
|
// the per-construction lookup three compares instead of a long key concat.
|
|
/** @type {RegExp | undefined} */
|
|
let lastKeywordsRe;
|
|
/** @type {RegExp | undefined} */
|
|
let lastReservedRe;
|
|
/** @type {RegExp | undefined} */
|
|
let lastReservedStrictRe;
|
|
/** @type {WordLookups | undefined} */
|
|
let lastWordLookups;
|
|
|
|
/**
|
|
* Mirrors acorn's `keywords` / `reservedWords` / `reservedWordsStrict` regexps
|
|
* as Map/Set lookups. Membership is the hot per-word test in `readWord` and
|
|
* `checkUnreserved`, and a hash lookup beats an anchored alternation regexp.
|
|
* @param {ParserInternals} parser parser instance
|
|
* @returns {WordLookups} lookups for this parser's keyword set
|
|
*/
|
|
const getWordLookups = (parser) => {
|
|
if (
|
|
parser.keywords === lastKeywordsRe &&
|
|
parser.reservedWords === lastReservedRe &&
|
|
parser.reservedWordsStrict === lastReservedStrictRe
|
|
) {
|
|
return /** @type {WordLookups} */ (lastWordLookups);
|
|
}
|
|
// module vs script share a keyword set but differ in reserved words, so the
|
|
// key must cover all three regexps
|
|
const key = `${parser.keywords.source}\n${parser.reservedWords.source}\n${parser.reservedWordsStrict.source}`;
|
|
lastKeywordsRe = parser.keywords;
|
|
lastReservedRe = parser.reservedWords;
|
|
lastReservedStrictRe = parser.reservedWordsStrict;
|
|
const cached = wordLookupsCache.get(key);
|
|
if (cached !== undefined) {
|
|
lastWordLookups = cached;
|
|
return cached;
|
|
}
|
|
/** @type {Map<string, TokenType>} */
|
|
const keywords = new Map();
|
|
// acorn's keyword regexp is a subset of keywordTypes for the ecmaVersion
|
|
for (const name of Object.keys(keywordTypes)) {
|
|
if (parser.keywords.test(name)) keywords.set(name, keywordTypes[name]);
|
|
}
|
|
const reserved = wordsRegexpToSet(parser.reservedWords);
|
|
/** @type {Map<string, ReservedKind>} */
|
|
const reservedKinds = new Map();
|
|
for (const name of reserved) reservedKinds.set(name, 2);
|
|
for (const name of wordsRegexpToSet(parser.reservedWordsStrict)) {
|
|
if (!reserved.has(name)) reservedKinds.set(name, 3);
|
|
}
|
|
// keyword classification wins, matching acorn's keyword-first check
|
|
for (const name of keywords.keys()) reservedKinds.set(name, 1);
|
|
const reservedBind = wordsRegexpToSet(parser.reservedWordsStrictBind);
|
|
let reservedMaxLen = 0;
|
|
for (const name of reservedKinds.keys()) {
|
|
if (name.length > reservedMaxLen) reservedMaxLen = name.length;
|
|
}
|
|
/** @type {WordLookups} */
|
|
const lookups = {
|
|
keywords,
|
|
reservedKinds,
|
|
reservedMaxLen,
|
|
reservedBindTest: { test: (name) => reservedBind.has(name) }
|
|
};
|
|
wordLookupsCache.set(key, lookups);
|
|
lastWordLookups = lookups;
|
|
return lookups;
|
|
};
|
|
|
|
/**
|
|
* webpack's parser: acorn plus lazy `range` (no `loc` at all), Set-based scopes,
|
|
* tokenizer fast paths, import attributes and import phases (with acorn's
|
|
* `!forNew` guard, unlike the former `acorn-import-phases` package).
|
|
*/
|
|
class WebpackParser extends BaseParser {
|
|
/**
|
|
* @param {Options & { lazyNodes?: boolean, lazyComments?: CollectedComment[], importPhases?: boolean, moduleFallback?: boolean }} options options
|
|
* @param {string} input source code
|
|
* @param {number=} startPos start position
|
|
*/
|
|
constructor(options, input, startPos) {
|
|
const lazy = options.lazyNodes === true;
|
|
// JavascriptParser._parse pre-disables acorn's tracking, so the
|
|
// defensive copy only runs for direct callers
|
|
if (lazy && (options.locations || options.ranges)) {
|
|
options = { ...options, locations: false, ranges: false };
|
|
}
|
|
super(options, input, startPos);
|
|
// acorn sets this.keywords/reservedWords in its constructor; parsing
|
|
// (and thus readWord) only starts later in parse(), so this is ready
|
|
this._wordLookups = getWordLookups(
|
|
/** @type {ParserInternals} */ (/** @type {unknown} */ (this))
|
|
);
|
|
// acorn only calls `.test()` on reservedWordsStrictBind (in
|
|
// checkLValSimple); swap its regexp for the Set-backed check
|
|
/** @type {{ reservedWordsStrictBind: { test: (name: string) => boolean } }} */
|
|
(/** @type {unknown} */ (this)).reservedWordsStrictBind =
|
|
this._wordLookups.reservedBindTest;
|
|
// per-token option probes cached once: acorn normalizes options in
|
|
// `getOptions` before the constructor body runs and never mutates them
|
|
const normalizedOptions = /** @type {ParserInternals} */ (
|
|
/** @type {unknown} */ (this)
|
|
).options;
|
|
this._ecmaVersion = /** @type {number} */ (normalizedOptions.ecmaVersion);
|
|
this._noLocations = !normalizedOptions.locations;
|
|
// lazy mode: nodes get only offsets, gating the owned tokenizer and
|
|
// statement fast paths
|
|
this._lazy = lazy;
|
|
// lazy comment collection must not race a user-provided onComment
|
|
/** @type {CollectedComment[] | undefined} */
|
|
this._lazyComments =
|
|
lazy && !options.onComment ? options.lazyComments : undefined;
|
|
// acorn skips a hashbang inside its constructor, before `_lazyComments`
|
|
// above exists — reconstruct the comment the override missed
|
|
if (
|
|
this._lazyComments !== undefined &&
|
|
!startPos &&
|
|
this.options.allowHashBang &&
|
|
input.startsWith("#!")
|
|
) {
|
|
this._lazyComments.push(
|
|
new LazyComment(
|
|
false,
|
|
2,
|
|
0,
|
|
/** @type {ParserInternals} */ (/** @type {unknown} */ (this)).pos,
|
|
input
|
|
)
|
|
);
|
|
}
|
|
/** @type {ImportPhase | null} */
|
|
this._importPhase = null;
|
|
this._importPhasesEnabled = options.importPhases === true;
|
|
// auto source type: parse as module first, downgrade to script in place
|
|
// (instead of a second full parse) when script-only syntax is hit
|
|
this._moduleFallback = options.moduleFallback === true;
|
|
// set once a module-only construct is parsed; blocks the downgrade
|
|
this._moduleSyntaxSeen = false;
|
|
// the owned parseSubscript assumes optional chaining exists (it bakes
|
|
// `optional` into the node shape), so gate it on the normalized version
|
|
this._subscriptFastPath = lazy && this._ecmaVersion >= 11;
|
|
// the owned getTokenFromCode bakes in every ES2021 operator (?., ??=,
|
|
// &&=, ...), so it needs at least that version
|
|
this._fullTokenFastPath = lazy && this._ecmaVersion >= 12;
|
|
// whether the gap before the current token holds a line terminator:
|
|
// 0 no, 1 yes, 2 unknown (canInsertSemicolon then scans the gap)
|
|
/** @type {0 | 1 | 2} */
|
|
this._newlineBefore = 2;
|
|
// LIFO pool for call-scoped destructuring-errors records; depth resets
|
|
// implicitly since a raise aborts the whole parse
|
|
/** @type {DestructuringErrorsShim[]} */
|
|
this._deStack = [];
|
|
this._deDepth = 0;
|
|
// LIFO pool for `parseObj`'s prop-clash records: acorn's ES6+
|
|
// `checkPropClash` only ever touches `.proto`, so one record per nesting
|
|
// depth suffices; an overriding subclass gets the fresh `{}` acorn expects
|
|
this._propHashFastPath =
|
|
/** @type {ParserInternals} */ (/** @type {unknown} */ (this))
|
|
.checkPropClash === base.checkPropClash;
|
|
/** @type {{ proto: boolean }[]} */
|
|
this._propHashStack = [];
|
|
this._propHashDepth = 0;
|
|
// `readRegexp`'s flag whitelist depends only on the ecmaVersion
|
|
this._validRegexpFlags = `gim${this._ecmaVersion >= 6 ? "uy" : ""}${
|
|
this._ecmaVersion >= 9 ? "s" : ""
|
|
}${this._ecmaVersion >= 13 ? "d" : ""}${this._ecmaVersion >= 15 ? "v" : ""}`;
|
|
// the owned parseStatement inlines these methods, so a parser plugin
|
|
// overriding any of them turns the statement fast path off
|
|
const proto = WebpackParser.prototype;
|
|
this._stmtFastPath =
|
|
lazy &&
|
|
this.parseVarStatement === proto.parseVarStatement &&
|
|
this.parseVar === proto.parseVar &&
|
|
this.parseIfStatement === proto.parseIfStatement &&
|
|
this.parseReturnStatement === proto.parseReturnStatement &&
|
|
this.parseExpressionStatement === proto.parseExpressionStatement;
|
|
}
|
|
|
|
/**
|
|
* Fetches a destructuring-errors record from the pool: acorn allocates one
|
|
* per expression parse and drops it at the end of the call, so strictly
|
|
* call-scoped users can reuse records instead. Pair every acquire with a
|
|
* `_releaseDestructuringErrors` on each non-throwing exit.
|
|
* @returns {DestructuringErrorsShim} reset record
|
|
* @this {ParserInternals}
|
|
*/
|
|
_acquireDestructuringErrors() {
|
|
const stack = this._deStack;
|
|
const depth = this._deDepth++;
|
|
const cached = stack[depth];
|
|
if (cached !== undefined) {
|
|
cached.shorthandAssign =
|
|
cached.trailingComma =
|
|
cached.parenthesizedAssign =
|
|
cached.parenthesizedBind =
|
|
cached.doubleProto =
|
|
-1;
|
|
return cached;
|
|
}
|
|
return (stack[depth] = createDestructuringErrors());
|
|
}
|
|
|
|
/**
|
|
* @returns {void}
|
|
* @this {ParserInternals}
|
|
*/
|
|
_releaseDestructuringErrors() {
|
|
this._deDepth--;
|
|
}
|
|
|
|
// ----- tokenizer fast paths -----
|
|
|
|
/**
|
|
* Owned per-token loop: acorn's `nextToken` chains `skipSpace` →
|
|
* `fullCharCodeAtPos` → `readToken` → `isIdentifierStart` with a dead
|
|
* `locations` check at each step. For the common lazy, non-template context
|
|
* this folds whitespace and comment skipping and the ASCII token dispatch
|
|
* into one function so nothing re-enters acorn's per-step option checks.
|
|
* Template/`preserveSpace` contexts and non-lazy mode use acorn's tokenizer.
|
|
* @returns {void}
|
|
* @this {ParserInternals}
|
|
*/
|
|
nextToken() {
|
|
const context = this.context;
|
|
const curContext = context[context.length - 1];
|
|
if (
|
|
!this._lazy ||
|
|
!curContext ||
|
|
curContext.preserveSpace ||
|
|
curContext.override
|
|
) {
|
|
this._newlineBefore = 2;
|
|
return base.nextToken.call(this);
|
|
}
|
|
const input = this.input;
|
|
const len = input.length;
|
|
let pos = this.pos;
|
|
// line terminators are flagged while skipping (yuku's
|
|
// `line_terminator_before`), so ASI checks need no gap re-scan. A
|
|
// delegated path (acorn's html-comment handling) may have consumed part
|
|
// of the gap before re-entering — start at "unknown" then.
|
|
/** @type {0 | 1 | 2} */
|
|
let newline = pos === this.lastTokEnd ? 0 : 2;
|
|
// one CHAR_CLASS load classifies each char for both the skip loop and
|
|
// the token dispatch below (yuku's ws_class/ident/punct tables in one)
|
|
let code = 0;
|
|
let cls = CLS_OTHER;
|
|
while (pos < len) {
|
|
code = input.charCodeAt(pos);
|
|
cls = CHAR_CLASS[code];
|
|
if (cls < CLS_SPACE) {
|
|
if (cls === CLS_UNICODE) {
|
|
// unicode whitespace / line terminators: acorn consumes the rest
|
|
this.pos = pos;
|
|
base.skipSpace.call(this);
|
|
pos = this.pos;
|
|
if (newline === 0) newline = 2;
|
|
code = pos < len ? input.charCodeAt(pos) : 0;
|
|
cls = CHAR_CLASS[code];
|
|
}
|
|
break;
|
|
}
|
|
if (cls === CLS_SPACE) {
|
|
// space, tab, VT, FF (no CRLF/line bookkeeping in lazy mode)
|
|
pos++;
|
|
} else if (cls === CLS_NEWLINE) {
|
|
newline = 1;
|
|
pos++;
|
|
} else {
|
|
const next = input.charCodeAt(pos + 1);
|
|
if (next === 42) {
|
|
this.pos = pos;
|
|
this.skipBlockComment();
|
|
pos = this.pos;
|
|
// the comment body may hold a line terminator
|
|
if (newline === 0) newline = 2;
|
|
} else if (next === 47) {
|
|
this.pos = pos;
|
|
this.skipLineComment(2);
|
|
pos = this.pos;
|
|
} else {
|
|
// a division/regexp token, not a comment
|
|
cls = CLS_OTHER;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
this._newlineBefore = newline;
|
|
this.pos = pos;
|
|
this.start = pos;
|
|
if (pos >= len) return this.finishToken(tokTypes.eof);
|
|
switch (cls) {
|
|
case CLS_IDENT:
|
|
return this.readWord();
|
|
case CLS_PUNCT:
|
|
this.pos = pos + 1;
|
|
return this.finishToken(/** @type {TokenType} */ (SIMPLE_PUNCT[code]));
|
|
case CLS_DOT: {
|
|
// `.` not starting `.5` or `...`: skip readToken_dot's re-dispatch
|
|
const next = input.charCodeAt(pos + 1);
|
|
if ((next < 48 || next > 57) && next !== 46) {
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.dot);
|
|
}
|
|
return this.getTokenFromCode(code);
|
|
}
|
|
case CLS_EQ: {
|
|
// `=` not starting `==` or `=>`: skip readToken_eq_excl + finishOp slice
|
|
const next = input.charCodeAt(pos + 1);
|
|
if (next !== 61 && next !== 62) {
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.eq, "=");
|
|
}
|
|
return this.getTokenFromCode(code);
|
|
}
|
|
case CLS_UNICODE:
|
|
return this.readToken(this.fullCharCodeAtPos());
|
|
default:
|
|
return this.getTokenFromCode(code);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Lazy-mode `finishToken`: acorn probes `options.locations` for a dead
|
|
* `endLoc` write on every token and reaches `updateContext` through an extra
|
|
* method call. Skip the probe and inline acorn's `updateContext` body — this
|
|
* runs once per token. Other modes use acorn's.
|
|
* @param {TokenType} type token type
|
|
* @param {unknown=} value token value
|
|
* @returns {void}
|
|
* @this {ParserInternals}
|
|
*/
|
|
finishToken(type, value) {
|
|
if (!this._lazy) {
|
|
return base.finishToken.call(this, type, value);
|
|
}
|
|
this.end = this.pos;
|
|
const prevType = this.type;
|
|
this.type = type;
|
|
this.value = value;
|
|
const internal = /** @type {TokenTypeInternal} */ (type);
|
|
// acorn's updateContext, inlined: keyword-after-dot forbids an expression,
|
|
// else the token type's own context hook runs, else `exprAllowed` follows
|
|
// the type's `beforeExpr` (the branch that makes `/` after a value divide)
|
|
if (type === tokTypes.name) {
|
|
// name.updateContext, inlined for the commonest token: only `of` /
|
|
// `yield` (outside a `.` access, ES6+) can re-allow an expression
|
|
this.exprAllowed =
|
|
((value === "of" && !this.exprAllowed) ||
|
|
(value === "yield" && this.inGeneratorContext())) &&
|
|
prevType !== tokTypes.dot &&
|
|
this._ecmaVersion >= 6;
|
|
} else if (type.keyword && prevType === tokTypes.dot) {
|
|
this.exprAllowed = false;
|
|
} else if (type === tokTypes.parenR || type === tokTypes.braceR) {
|
|
// parenR/braceR.updateContext, inlined
|
|
const context = this.context;
|
|
if (context.length === 1) {
|
|
this.exprAllowed = true;
|
|
} else {
|
|
let out = /** @type {TokContextShim} */ (context.pop());
|
|
if (
|
|
out === CTX_B_STAT &&
|
|
/** @type {TokContextShim} */ (context[context.length - 1]).token ===
|
|
"function"
|
|
) {
|
|
out = /** @type {TokContextShim} */ (context.pop());
|
|
}
|
|
this.exprAllowed = !out.isExpr;
|
|
}
|
|
} else if (type === tokTypes.braceL) {
|
|
// braceL.updateContext, inlined
|
|
this.context.push(this.braceIsBlock(prevType) ? CTX_B_STAT : CTX_B_EXPR);
|
|
this.exprAllowed = true;
|
|
} else if (type === tokTypes.parenL) {
|
|
// parenL.updateContext, inlined
|
|
const statementParens =
|
|
prevType === tokTypes._if ||
|
|
prevType === tokTypes._for ||
|
|
prevType === tokTypes._with ||
|
|
prevType === tokTypes._while;
|
|
this.context.push(statementParens ? CTX_P_STAT : CTX_P_EXPR);
|
|
this.exprAllowed = true;
|
|
} else if (internal.updateContext) {
|
|
internal.updateContext.call(this, prevType);
|
|
} else {
|
|
this.exprAllowed = internal.beforeExpr;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Owned `braceIsBlock`, acorn's verbatim except the line-terminator probe:
|
|
* acorn slices the inter-token gap and runs a regexp; `_gapHasNewline`
|
|
* answers from the tokenizer's newline flag (scanning only when unknown).
|
|
* @param {TokenType} prevType type of the previous token
|
|
* @returns {boolean} whether a `{` opens a block in this context
|
|
* @this {ParserInternals}
|
|
*/
|
|
braceIsBlock(prevType) {
|
|
const context = this.context;
|
|
const parent = /** @type {TokContextShim} */ (context[context.length - 1]);
|
|
if (parent === CTX_F_EXPR || parent === CTX_F_STAT) return true;
|
|
if (
|
|
prevType === tokTypes.colon &&
|
|
(parent === CTX_B_STAT || parent === CTX_B_EXPR)
|
|
) {
|
|
return !parent.isExpr;
|
|
}
|
|
// after `return`, or after `yield`/`of` (name with exprAllowed), a line
|
|
// terminator decides between block and expression
|
|
if (
|
|
prevType === tokTypes._return ||
|
|
(prevType === tokTypes.name && this.exprAllowed)
|
|
) {
|
|
return this._gapHasNewline();
|
|
}
|
|
if (
|
|
prevType === tokTypes._else ||
|
|
prevType === tokTypes.semi ||
|
|
prevType === tokTypes.eof ||
|
|
prevType === tokTypes.parenR ||
|
|
prevType === tokTypes.arrow
|
|
) {
|
|
return true;
|
|
}
|
|
if (prevType === tokTypes.braceL) return parent === CTX_B_STAT;
|
|
if (
|
|
prevType === tokTypes._var ||
|
|
prevType === tokTypes._const ||
|
|
prevType === tokTypes.name
|
|
) {
|
|
return false;
|
|
}
|
|
return !this.exprAllowed;
|
|
}
|
|
|
|
/**
|
|
* Whether the gap before the current token holds a line terminator, served
|
|
* from the owned tokenizer's flag when known.
|
|
* @returns {boolean} whether a line terminator precedes the current token
|
|
* @this {ParserInternals}
|
|
*/
|
|
_gapHasNewline() {
|
|
const newlineBefore = this._newlineBefore;
|
|
if (newlineBefore !== 2) return newlineBefore === 1;
|
|
const input = this.input;
|
|
const end = this.start;
|
|
for (let i = this.lastTokEnd; i < end; i++) {
|
|
const ch = input.charCodeAt(i);
|
|
// LF, CR, LS, PS — acorn's `lineBreak` alternation
|
|
if (ch === 10 || ch === 13 || ch === 0x2028 || ch === 0x2029) {
|
|
// memoize: the gap is fixed until the next token is read, and
|
|
// `nextToken` rewrites the flag — ASI probes often repeat per token
|
|
// (e.g. name atoms behind a /*#__PURE__*/ comment)
|
|
this._newlineBefore = 1;
|
|
return true;
|
|
}
|
|
}
|
|
this._newlineBefore = 0;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Owned per-token advance: acorn's `next` writes `lastTokEndLoc`/
|
|
* `lastTokStartLoc` and probes `options.onToken` on every token, both dead in
|
|
* lazy mode (locations off, no token stream), leaving only the two offset
|
|
* writes and the keyword-escape guard. Other modes use acorn's.
|
|
* @param {boolean=} ignoreEscapeSequenceInKeyword whether an escape in a keyword is allowed here
|
|
* @returns {void}
|
|
* @this {ParserInternals}
|
|
*/
|
|
next(ignoreEscapeSequenceInKeyword) {
|
|
if (!this._lazy) {
|
|
return base.next.call(this, ignoreEscapeSequenceInKeyword);
|
|
}
|
|
const type = this.type;
|
|
if (!ignoreEscapeSequenceInKeyword && type.keyword && this.containsEsc) {
|
|
this.raiseRecoverable(
|
|
this.start,
|
|
`Escape sequence in keyword ${type.keyword}`
|
|
);
|
|
}
|
|
this.lastTokEnd = this.end;
|
|
this.lastTokStart = this.start;
|
|
this.nextToken();
|
|
}
|
|
|
|
/**
|
|
* Owned `finishOp`: acorn slices the operator text out of the source for
|
|
* every operator token, allocating a fresh 2-4 char string per `=>`, `===`,
|
|
* `&&` etc. Serve those from `OP_CACHE` instead; single-char operators keep
|
|
* the direct slice, which V8 serves from its single-character table.
|
|
* @param {TokenType} type token type
|
|
* @param {number} size operator length
|
|
* @returns {void}
|
|
* @this {ParserInternals}
|
|
*/
|
|
finishOp(type, size) {
|
|
const pos = this.pos;
|
|
const input = this.input;
|
|
if (size === 1) {
|
|
this.pos = pos + 1;
|
|
return this.finishToken(type, input.slice(pos, pos + 1));
|
|
}
|
|
let key = input.charCodeAt(pos) | (input.charCodeAt(pos + 1) << 7);
|
|
if (size > 2) {
|
|
key |= input.charCodeAt(pos + 2) << 14;
|
|
if (size > 3) key |= input.charCodeAt(pos + 3) << 21;
|
|
}
|
|
let str = OP_CACHE.get(key);
|
|
if (str === undefined) {
|
|
str = input.slice(pos, pos + size);
|
|
OP_CACHE.set(key, str);
|
|
}
|
|
this.pos = pos + size;
|
|
return this.finishToken(type, str);
|
|
}
|
|
|
|
/**
|
|
* Owned `getTokenFromCode`: acorn dispatches operators through per-family
|
|
* `readToken_*` methods that each end in `finishOp`'s source slice. Resolve
|
|
* every operator by direct char peeks to a static string instead (yuku's
|
|
* `scanPunctuation`) — no method chain, no slice, no `OP_CACHE` probe. The
|
|
* HTML-comment forms (`<!--`, `-->`), `#`, and unknown chars delegate.
|
|
* @param {number} code current char code
|
|
* @returns {void}
|
|
* @this {ParserInternals}
|
|
*/
|
|
getTokenFromCode(code) {
|
|
if (!this._fullTokenFastPath) {
|
|
return base.getTokenFromCode.call(this, code);
|
|
}
|
|
const input = this.input;
|
|
const pos = this.pos;
|
|
switch (code) {
|
|
case 46: {
|
|
// '.': number, ellipsis or plain dot
|
|
const next = input.charCodeAt(pos + 1);
|
|
if (next >= 48 && next <= 57) return this.readNumber(true);
|
|
if (next === 46 && input.charCodeAt(pos + 2) === 46) {
|
|
this.pos = pos + 3;
|
|
return this.finishToken(tokTypes.ellipsis);
|
|
}
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.dot);
|
|
}
|
|
case 47: {
|
|
// '/': regexp in expression position, otherwise /= or /
|
|
if (this.exprAllowed) {
|
|
this.pos = pos + 1;
|
|
return this.readRegexp();
|
|
}
|
|
if (input.charCodeAt(pos + 1) === 61) {
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.assign, "/=");
|
|
}
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.slash, "/");
|
|
}
|
|
case 37: {
|
|
// '%': %= or %
|
|
if (input.charCodeAt(pos + 1) === 61) {
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.assign, "%=");
|
|
}
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.modulo, "%");
|
|
}
|
|
case 42: {
|
|
// '*': **=, **, *= or *
|
|
const next = input.charCodeAt(pos + 1);
|
|
if (next === 42) {
|
|
if (input.charCodeAt(pos + 2) === 61) {
|
|
this.pos = pos + 3;
|
|
return this.finishToken(tokTypes.assign, "**=");
|
|
}
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.starstar, "**");
|
|
}
|
|
if (next === 61) {
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.assign, "*=");
|
|
}
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.star, "*");
|
|
}
|
|
case 124: {
|
|
// '|': ||=, ||, |= or |
|
|
const next = input.charCodeAt(pos + 1);
|
|
if (next === 124) {
|
|
if (input.charCodeAt(pos + 2) === 61) {
|
|
this.pos = pos + 3;
|
|
return this.finishToken(tokTypes.assign, "||=");
|
|
}
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.logicalOR, "||");
|
|
}
|
|
if (next === 61) {
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.assign, "|=");
|
|
}
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.bitwiseOR, "|");
|
|
}
|
|
case 38: {
|
|
// '&': &&=, &&, &= or &
|
|
const next = input.charCodeAt(pos + 1);
|
|
if (next === 38) {
|
|
if (input.charCodeAt(pos + 2) === 61) {
|
|
this.pos = pos + 3;
|
|
return this.finishToken(tokTypes.assign, "&&=");
|
|
}
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.logicalAND, "&&");
|
|
}
|
|
if (next === 61) {
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.assign, "&=");
|
|
}
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.bitwiseAND, "&");
|
|
}
|
|
case 94: {
|
|
// '^': ^= or ^
|
|
if (input.charCodeAt(pos + 1) === 61) {
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.assign, "^=");
|
|
}
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.bitwiseXOR, "^");
|
|
}
|
|
case 43: {
|
|
// '+': ++, += or +
|
|
const next = input.charCodeAt(pos + 1);
|
|
if (next === 43) {
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.incDec, "++");
|
|
}
|
|
if (next === 61) {
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.assign, "+=");
|
|
}
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.plusMin, "+");
|
|
}
|
|
case 45: {
|
|
// '-': --, -= or -; `-->` may open an HTML line comment
|
|
const next = input.charCodeAt(pos + 1);
|
|
if (next === 45) {
|
|
if (input.charCodeAt(pos + 2) === 62 && !this.inModule) {
|
|
return base.getTokenFromCode.call(this, code);
|
|
}
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.incDec, "--");
|
|
}
|
|
if (next === 61) {
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.assign, "-=");
|
|
}
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.plusMin, "-");
|
|
}
|
|
case 60: {
|
|
// '<': <<=, <<, <= or <; `<!--` opens an HTML line comment
|
|
const next = input.charCodeAt(pos + 1);
|
|
if (next === 60) {
|
|
if (input.charCodeAt(pos + 2) === 61) {
|
|
this.pos = pos + 3;
|
|
return this.finishToken(tokTypes.assign, "<<=");
|
|
}
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.bitShift, "<<");
|
|
}
|
|
if (
|
|
next === 33 &&
|
|
!this.inModule &&
|
|
input.charCodeAt(pos + 2) === 45 &&
|
|
input.charCodeAt(pos + 3) === 45
|
|
) {
|
|
return base.getTokenFromCode.call(this, code);
|
|
}
|
|
if (next === 61) {
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.relational, "<=");
|
|
}
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.relational, "<");
|
|
}
|
|
case 62: {
|
|
// '>': >>>=, >>>, >>=, >>, >= or >
|
|
const next = input.charCodeAt(pos + 1);
|
|
if (next === 62) {
|
|
if (input.charCodeAt(pos + 2) === 62) {
|
|
if (input.charCodeAt(pos + 3) === 61) {
|
|
this.pos = pos + 4;
|
|
return this.finishToken(tokTypes.assign, ">>>=");
|
|
}
|
|
this.pos = pos + 3;
|
|
return this.finishToken(tokTypes.bitShift, ">>>");
|
|
}
|
|
if (input.charCodeAt(pos + 2) === 61) {
|
|
this.pos = pos + 3;
|
|
return this.finishToken(tokTypes.assign, ">>=");
|
|
}
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.bitShift, ">>");
|
|
}
|
|
if (next === 61) {
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.relational, ">=");
|
|
}
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.relational, ">");
|
|
}
|
|
case 61: {
|
|
// '=': ===, ==, => or =
|
|
const next = input.charCodeAt(pos + 1);
|
|
if (next === 61) {
|
|
if (input.charCodeAt(pos + 2) === 61) {
|
|
this.pos = pos + 3;
|
|
return this.finishToken(tokTypes.equality, "===");
|
|
}
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.equality, "==");
|
|
}
|
|
if (next === 62) {
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.arrow);
|
|
}
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.eq, "=");
|
|
}
|
|
case 33: {
|
|
// '!': !==, != or !
|
|
const next = input.charCodeAt(pos + 1);
|
|
if (next === 61) {
|
|
if (input.charCodeAt(pos + 2) === 61) {
|
|
this.pos = pos + 3;
|
|
return this.finishToken(tokTypes.equality, "!==");
|
|
}
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.equality, "!=");
|
|
}
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.prefix, "!");
|
|
}
|
|
case 63: {
|
|
// '?': ?. (not before a digit), ??=, ?? or ?
|
|
const next = input.charCodeAt(pos + 1);
|
|
if (next === 46) {
|
|
const next2 = input.charCodeAt(pos + 2);
|
|
if (next2 < 48 || next2 > 57) {
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.questionDot, "?.");
|
|
}
|
|
}
|
|
if (next === 63) {
|
|
if (input.charCodeAt(pos + 2) === 61) {
|
|
this.pos = pos + 3;
|
|
return this.finishToken(tokTypes.assign, "??=");
|
|
}
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.coalesce, "??");
|
|
}
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.question, "?");
|
|
}
|
|
case 126: {
|
|
// '~'
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.prefix, "~");
|
|
}
|
|
case 96: {
|
|
// '`'
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.backQuote);
|
|
}
|
|
case 48: {
|
|
// '0': radix literals split off before the decimal reader
|
|
const next = input.charCodeAt(pos + 1);
|
|
if (next === 120 || next === 88) return this.readRadixNumber(16);
|
|
if (next === 111 || next === 79) return this.readRadixNumber(8);
|
|
if (next === 98 || next === 66) return this.readRadixNumber(2);
|
|
return this.readNumber(false);
|
|
}
|
|
case 49:
|
|
case 50:
|
|
case 51:
|
|
case 52:
|
|
case 53:
|
|
case 54:
|
|
case 55:
|
|
case 56:
|
|
case 57:
|
|
return this.readNumber(false);
|
|
case 34:
|
|
case 39:
|
|
return this.readString(code);
|
|
default:
|
|
return base.getTokenFromCode.call(this, code);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ASCII fast path for acorn's `readWord1`, which pays a surrogate-aware
|
|
* method call and a range-check helper per character. Escapes, non-ASCII
|
|
* and astral input restart the base implementation from the word start.
|
|
* Words are deduplicated through `WORD_CACHE` so repeated identifiers —
|
|
* which dominate real code — reuse one string instead of slicing a fresh
|
|
* one per occurrence; sharing also keeps their cached string hashes warm
|
|
* for the keyword/scope Map lookups downstream.
|
|
* @this {ParserInternals}
|
|
* @returns {string} the word
|
|
*/
|
|
readWord1() {
|
|
const input = this.input;
|
|
const start = this.pos;
|
|
const len = input.length;
|
|
// djb2-style hash folded into the scan loop (yuku scans each lexeme in
|
|
// one pass); computing it for the rare over-long words is cheaper than
|
|
// re-walking every word in a second pass
|
|
let hash = 0;
|
|
let pos = start;
|
|
while (pos < len) {
|
|
const ch = input.charCodeAt(pos);
|
|
if (ch < 128) {
|
|
if (IDENT_CHAR[ch] === 0) {
|
|
// backslash escape: restart cold so escape rules see the word
|
|
if (ch === 92) return base.readWord1.call(this);
|
|
break;
|
|
}
|
|
hash = (Math.imul(hash, 33) + ch) | 0;
|
|
pos++;
|
|
} else {
|
|
return base.readWord1.call(this);
|
|
}
|
|
}
|
|
this.containsEsc = false;
|
|
this.pos = pos;
|
|
const wordLen = pos - start;
|
|
// Single-char words skip the cache (V8 serves those slices from its
|
|
// single-character table without allocating); long words skip it too.
|
|
if (wordLen >= 2 && wordLen <= WORD_CACHE_MAX_LEN) {
|
|
const slot = hash & WORD_CACHE_MASK;
|
|
const cached = WORD_CACHE[slot];
|
|
if (
|
|
cached !== null &&
|
|
cached.length === wordLen &&
|
|
sameWord(cached, input, start, wordLen)
|
|
) {
|
|
return cached;
|
|
}
|
|
const word = input.slice(start, pos);
|
|
WORD_CACHE[slot] = word;
|
|
return word;
|
|
}
|
|
return input.slice(start, pos);
|
|
}
|
|
|
|
/**
|
|
* String fast path: one scan that both finds the closing quote and vets the
|
|
* span (the former `indexOf` + verify-loop pair read every string twice).
|
|
* Escapes, newlines in the span, old ecmaVersions (LS/PS terminate strings
|
|
* there) and location tracking restart acorn's implementation, which also
|
|
* produces its exact errors.
|
|
* @this {ParserInternals}
|
|
* @param {number} quote quote char code
|
|
* @returns {void}
|
|
*/
|
|
readString(quote) {
|
|
if (!this._noLocations || this._ecmaVersion < 10) {
|
|
return base.readString.call(this, quote);
|
|
}
|
|
const input = this.input;
|
|
const len = input.length;
|
|
const start = this.pos + 1;
|
|
let pos = start;
|
|
for (;;) {
|
|
if (pos >= len) this.raise(this.start, "Unterminated string constant");
|
|
const ch = input.charCodeAt(pos);
|
|
if (ch === quote) break;
|
|
// backslash, LF, CR
|
|
if (ch === 92 || ch === 10 || ch === 13) {
|
|
return base.readString.call(this, quote);
|
|
}
|
|
pos++;
|
|
}
|
|
this.pos = pos + 1;
|
|
this.finishToken(tokTypes.string, input.slice(start, pos));
|
|
}
|
|
|
|
/**
|
|
* Number fast path: plain integer literals (no leading zero, up to 15
|
|
* digits so the float is exact) are accumulated numerically — no slice,
|
|
* no parseFloat, no separator handling. Everything else (dots, exponents,
|
|
* bigints, separators, octal forms) restarts acorn's implementation.
|
|
* @this {ParserInternals}
|
|
* @param {boolean} startsWithDot whether the number started with a dot
|
|
* @returns {void}
|
|
*/
|
|
readNumber(startsWithDot) {
|
|
if (startsWithDot) return base.readNumber.call(this, startsWithDot);
|
|
const input = this.input;
|
|
const start = this.pos;
|
|
const len = input.length;
|
|
const first = input.charCodeAt(start);
|
|
let pos;
|
|
if (first === 48) {
|
|
const c1 = start + 1 < len ? input.charCodeAt(start + 1) : 0;
|
|
if (c1 === 46) {
|
|
// `0.<digits>`
|
|
pos = start + 1;
|
|
} else if (c1 > 127 || IDENT_CHAR[c1] === 1) {
|
|
// 0x/0o/0b, 0e…, 0n, 0_, legacy `0NN`, or `0`+identifier: acorn
|
|
return base.readNumber.call(this, startsWithDot);
|
|
} else {
|
|
// bare `0` before punctuation/operator/whitespace/EOF
|
|
this.pos = start + 1;
|
|
return this.finishToken(tokTypes.num, 0);
|
|
}
|
|
} else if (first > 48 && first <= 57) {
|
|
// integer digits, accumulated numerically for the integer-only case
|
|
let value = first - 48;
|
|
pos = start + 1;
|
|
while (pos < len) {
|
|
const ch = input.charCodeAt(pos);
|
|
if (ch >= 48 && ch <= 57) {
|
|
value = value * 10 + (ch - 48);
|
|
pos++;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
const after = pos < len ? input.charCodeAt(pos) : 0;
|
|
if (after !== 46) {
|
|
// no fraction: exponent, separator, bigint suffix or a trailing
|
|
// identifier char all need acorn's full handling and exact errors
|
|
if (
|
|
after === 101 ||
|
|
after === 69 ||
|
|
after === 95 ||
|
|
after === 110 ||
|
|
after > 127 ||
|
|
IDENT_CHAR[after] === 1
|
|
) {
|
|
return base.readNumber.call(this, startsWithDot);
|
|
}
|
|
// 15 digits always fit exactly into a double
|
|
if (pos - start > 15) {
|
|
return base.readNumber.call(this, startsWithDot);
|
|
}
|
|
this.pos = pos;
|
|
return this.finishToken(tokTypes.num, value);
|
|
}
|
|
// a fraction follows the integer part
|
|
} else {
|
|
return base.readNumber.call(this, startsWithDot);
|
|
}
|
|
// decimal fraction: `pos` is at the '.'
|
|
pos++;
|
|
while (pos < len) {
|
|
const ch = input.charCodeAt(pos);
|
|
if (ch >= 48 && ch <= 57) pos++;
|
|
else break;
|
|
}
|
|
const after = pos < len ? input.charCodeAt(pos) : 0;
|
|
// exponent, a second dot, separator, bigint suffix or trailing identifier
|
|
if (
|
|
after === 46 ||
|
|
after === 101 ||
|
|
after === 69 ||
|
|
after === 95 ||
|
|
after === 110 ||
|
|
after > 127 ||
|
|
IDENT_CHAR[after] === 1
|
|
) {
|
|
return base.readNumber.call(this, startsWithDot);
|
|
}
|
|
this.pos = pos;
|
|
this.finishToken(tokTypes.num, Number.parseFloat(input.slice(start, pos)));
|
|
}
|
|
|
|
/**
|
|
* Owned `strictDirective`: acorn's runs an anchored literal regex over
|
|
* `this.input.slice(start)` — a fresh sliced string per (sloppy-mode)
|
|
* function body. Sticky regexes at the offset scan the same grammar with no
|
|
* slice. Same directive-prologue semantics, including the ASI tail checks.
|
|
* @param {number} start offset of the function body's first statement
|
|
* @returns {boolean} true when a 'use strict' directive leads the prologue
|
|
* @this {ParserInternals & { input: string, options: { ecmaVersion: number } }}
|
|
*/
|
|
strictDirective(start) {
|
|
if (/** @type {number} */ (this.options.ecmaVersion) < 5) return false;
|
|
const input = this.input;
|
|
for (;;) {
|
|
// Skip whitespace and comments (acorn's `skipWhiteSpace`, sticky).
|
|
STRICT_SKIP_WS.lastIndex = start;
|
|
start += /** @type {RegExpExecArray} */ (STRICT_SKIP_WS.exec(input))[0]
|
|
.length;
|
|
STRICT_LITERAL.lastIndex = start;
|
|
const match = STRICT_LITERAL.exec(input);
|
|
if (!match) return false;
|
|
if ((match[1] || match[2]) === "use strict") {
|
|
STRICT_SKIP_WS.lastIndex = start + match[0].length;
|
|
const spaceAfter = /** @type {RegExpExecArray} */ (
|
|
STRICT_SKIP_WS.exec(input)
|
|
);
|
|
const end = spaceAfter.index + spaceAfter[0].length;
|
|
const next = input.charAt(end);
|
|
return (
|
|
next === ";" ||
|
|
next === "}" ||
|
|
(STRICT_LINE_BREAK.test(spaceAfter[0]) &&
|
|
!(
|
|
/[(`.[+\-/*%<>=,?^&]/.test(next) ||
|
|
(next === "!" && input.charAt(end + 1) === "=")
|
|
))
|
|
);
|
|
}
|
|
start += match[0].length;
|
|
|
|
// Skip semicolon, if any.
|
|
STRICT_SKIP_WS.lastIndex = start;
|
|
start += /** @type {RegExpExecArray} */ (STRICT_SKIP_WS.exec(input))[0]
|
|
.length;
|
|
if (input[start] === ";") start++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Template fast path: when the chunk contains no backslash and no CR, the
|
|
* cooked value is one slice (LF/LS/PS cook to themselves). Escapes, CR
|
|
* normalization and location tracking restart acorn's implementation,
|
|
* which also produces its exact errors.
|
|
* @this {ParserInternals}
|
|
* @returns {void}
|
|
*/
|
|
readTmplToken() {
|
|
if (!this._noLocations) return base.readTmplToken.call(this);
|
|
const input = this.input;
|
|
const start = this.pos;
|
|
const len = input.length;
|
|
let pos = start;
|
|
while (pos < len) {
|
|
const ch = input.charCodeAt(pos);
|
|
if (ch === 96 || (ch === 36 && input.charCodeAt(pos + 1) === 123)) {
|
|
if (
|
|
pos === this.start &&
|
|
(this.type === tokTypes.template ||
|
|
this.type === tokTypes.invalidTemplate)
|
|
) {
|
|
if (ch === 36) {
|
|
this.pos = pos + 2;
|
|
return this.finishToken(tokTypes.dollarBraceL);
|
|
}
|
|
this.pos = pos + 1;
|
|
return this.finishToken(tokTypes.backQuote);
|
|
}
|
|
this.pos = pos;
|
|
return this.finishToken(tokTypes.template, input.slice(start, pos));
|
|
}
|
|
// backslash and CR need acorn's cooked-string building
|
|
if (ch === 92 || ch === 13) {
|
|
return base.readTmplToken.call(this);
|
|
}
|
|
pos++;
|
|
}
|
|
this.raise(this.start, "Unterminated template");
|
|
}
|
|
|
|
/**
|
|
* Fast path for the common run of plain ASCII whitespace; comments,
|
|
* unicode whitespace and location tracking delegate to acorn.
|
|
* @this {ParserInternals & { pos: number }}
|
|
* @returns {void}
|
|
*/
|
|
skipSpace() {
|
|
if (!this._noLocations) return base.skipSpace.call(this);
|
|
const input = this.input;
|
|
const len = input.length;
|
|
let pos = this.pos;
|
|
while (pos < len) {
|
|
const ch = input.charCodeAt(pos);
|
|
// 9-13 and 32 cover tab, LF, VT, FF, CR and space
|
|
if (ch === 32 || (ch > 8 && ch < 14)) {
|
|
pos++;
|
|
} else if (ch === 47 || ch > 127) {
|
|
// comments or unicode whitespace: let acorn handle the rest
|
|
this.pos = pos;
|
|
return base.skipSpace.call(this);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
this.pos = pos;
|
|
}
|
|
|
|
// ----- word classification (Map/Set lookups, replaces acorn's regexps) -----
|
|
|
|
/**
|
|
* Replaces acorn's `readWord`, whose `this.keywords.test(word)` runs an
|
|
* anchored alternation regexp for every identifier and keyword token; a
|
|
* Map lookup on the same keyword set is cheaper.
|
|
* @this {ParserInternals}
|
|
* @returns {void}
|
|
*/
|
|
readWord() {
|
|
const word = this.readWord1();
|
|
let type = tokTypes.name;
|
|
const len = word.length;
|
|
// every acorn keyword is 2-10 lowercase ASCII chars (`do`…`instanceof`),
|
|
// so most identifiers skip the Map probe entirely (yuku gates its keyword
|
|
// switch the same way)
|
|
if (len >= 2 && len <= 10) {
|
|
const first = word.charCodeAt(0);
|
|
if (first >= 97 && first <= 122) {
|
|
type = this._wordLookups.keywords.get(word) || tokTypes.name;
|
|
}
|
|
}
|
|
this.finishToken(type, word);
|
|
}
|
|
|
|
/**
|
|
* Mirror of acorn's `checkUnreserved` with its two per-identifier regexp
|
|
* tests (`keywords` and `reservedWords`/`reservedWordsStrict`) folded into a
|
|
* single `reservedKinds` lookup — one hash probe instead of two, and the
|
|
* common plain identifier misses it and returns. Branches and error
|
|
* messages match acorn exactly.
|
|
* @param {Identifier} ref identifier node
|
|
* @this {ParserInternals}
|
|
*/
|
|
checkUnreserved(ref) {
|
|
const { start, end, name } = ref;
|
|
// every reserved word and special name below is short lowercase ASCII, so
|
|
// most identifiers exit on this shape gate before any string compare
|
|
// (`yield`/`await`/`arguments` all pass it: lengths 5/5/9 ≤ reservedMaxLen,
|
|
// which keywords like `instanceof` keep at ≥ 10)
|
|
const lookups = this._wordLookups;
|
|
const nameLen = name.length;
|
|
if (nameLen < 2 || nameLen > lookups.reservedMaxLen) return;
|
|
const firstCC = name.charCodeAt(0);
|
|
if (firstCC < 97 || firstCC > 122) return;
|
|
// name-first ordering: acorn's `inGenerator`/`inAsync` are getters that
|
|
// walk the scope stack, so gate them behind the cheap string compare —
|
|
// a plain identifier never triggers them
|
|
if (name === "yield" && this.inGenerator) {
|
|
this.raiseRecoverable(
|
|
start,
|
|
"Cannot use 'yield' as identifier inside a generator"
|
|
);
|
|
} else if (name === "await" && this.inAsync) {
|
|
this.raiseRecoverable(
|
|
start,
|
|
"Cannot use 'await' as identifier inside an async function"
|
|
);
|
|
}
|
|
if (name === "arguments" && !(this.currentThisScope().flags & SCOPE_VAR)) {
|
|
this.raiseRecoverable(
|
|
start,
|
|
"Cannot use 'arguments' in class field initializer"
|
|
);
|
|
}
|
|
if ((name === "arguments" || name === "await") && this.inClassStaticBlock) {
|
|
this.raise(
|
|
start,
|
|
`Cannot use ${name} in class static initialization block`
|
|
);
|
|
}
|
|
const kind = lookups.reservedKinds.get(name);
|
|
if (kind === undefined) return;
|
|
if (kind === 1) {
|
|
this.raise(start, `Unexpected keyword '${name}'`);
|
|
}
|
|
if (
|
|
/** @type {number} */ (this.options.ecmaVersion) < 6 &&
|
|
this.input.slice(start, end).includes("\\")
|
|
) {
|
|
return;
|
|
}
|
|
if (kind === 2 || (kind === 3 && this.strict)) {
|
|
if (name === "await" && !this.inAsync) {
|
|
this.raiseRecoverable(
|
|
start,
|
|
"Cannot use keyword 'await' outside an async function"
|
|
);
|
|
}
|
|
this.raiseRecoverable(start, `The keyword '${name}' is reserved`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Replaces acorn's `canInsertSemicolon`, whose line-break check slices the
|
|
* inter-token gap and runs a regexp on it for every ASI decision (hundreds
|
|
* of thousands per file). Scan the gap for a line terminator instead — no
|
|
* slice, no regexp.
|
|
* @returns {boolean} whether a semicolon may be inserted here
|
|
* @this {ParserInternals}
|
|
*/
|
|
canInsertSemicolon() {
|
|
if (this.type === tokTypes.eof || this.type === tokTypes.braceR) {
|
|
return true;
|
|
}
|
|
// the owned nextToken already classified the gap; 2 (comment/unicode in
|
|
// the gap, or a token from acorn's tokenizer) falls back to the scan
|
|
return this._gapHasNewline();
|
|
}
|
|
|
|
// ----- comment collection without eager text slicing -----
|
|
|
|
/**
|
|
* Replaces acorn's `skipLineComment` when comments are collected lazily:
|
|
* the same scan, but no text slice and no position objects. Acorn calls
|
|
* this for `//`, hashbangs and HTML-style comments (varying `startSkip`).
|
|
* @this {ParserInternals}
|
|
* @param {number} startSkip length of the comment opener
|
|
* @returns {void}
|
|
*/
|
|
skipLineComment(startSkip) {
|
|
const comments = this._lazyComments;
|
|
if (comments === undefined) {
|
|
return base.skipLineComment.call(this, startSkip);
|
|
}
|
|
const input = this.input;
|
|
const start = this.pos;
|
|
const len = input.length;
|
|
let pos = start + startSkip;
|
|
while (pos < len) {
|
|
const ch = input.charCodeAt(pos);
|
|
// LF, CR, LS, PS terminate the comment but are not part of it
|
|
if (ch === 10 || ch === 13 || ch === 0x2028 || ch === 0x2029) break;
|
|
pos++;
|
|
}
|
|
this.pos = pos;
|
|
comments.push(new LazyComment(false, start + startSkip, start, pos, input));
|
|
}
|
|
|
|
/**
|
|
* Replaces acorn's `skipBlockComment` when comments are collected lazily.
|
|
* Locations are always off in lazy mode, so line breaks need no handling.
|
|
* @this {ParserInternals}
|
|
* @returns {void}
|
|
*/
|
|
skipBlockComment() {
|
|
const comments = this._lazyComments;
|
|
if (comments === undefined) {
|
|
return base.skipBlockComment.call(this);
|
|
}
|
|
const start = this.pos;
|
|
const end = this.input.indexOf("*/", (this.pos += 2));
|
|
if (end === -1) this.raise(this.pos - 2, "Unterminated comment");
|
|
this.pos = end + 2;
|
|
comments.push(
|
|
new LazyComment(true, start + 2, start, this.pos, this.input)
|
|
);
|
|
}
|
|
|
|
// ----- lazy range -----
|
|
|
|
/**
|
|
* @returns {Node} new node
|
|
* @this {ParserInternals}
|
|
*/
|
|
startNode() {
|
|
if (!this._lazy) return base.startNode.call(this);
|
|
return new LazyLocNode(this.start);
|
|
}
|
|
|
|
/**
|
|
* @param {number} pos start offset
|
|
* @param {Position=} loc start position when acorn tracks locations
|
|
* @returns {Node} new node
|
|
* @this {ParserInternals}
|
|
*/
|
|
startNodeAt(pos, loc) {
|
|
if (!this._lazy) return base.startNodeAt.call(this, pos, loc);
|
|
return new LazyLocNode(pos);
|
|
}
|
|
|
|
/**
|
|
* Lazy-mode `finishNode`: acorn's `locations`/`ranges` writes are dead when
|
|
* `range` is served lazily and `loc` not at all, so skip them and the `finishNodeAt`
|
|
* indirection. Runs once per node.
|
|
* @param {Node} node node to finish
|
|
* @param {string} type node type
|
|
* @returns {Node} the finished node
|
|
* @this {ParserInternals}
|
|
*/
|
|
finishNode(node, type) {
|
|
if (!this._lazy) return base.finishNode.call(this, node, type);
|
|
node.type = type;
|
|
node.end = this.lastTokEnd;
|
|
return node;
|
|
}
|
|
|
|
/**
|
|
* Mirror of acorn's `copyNode`, which bypasses `startNodeAt` via
|
|
* `new Node(...)` and would otherwise produce non-lazy nodes.
|
|
* @param {Node} node node to copy
|
|
* @returns {Node} copied node
|
|
* @this {ParserInternals}
|
|
*/
|
|
copyNode(node) {
|
|
const newNode = this.startNodeAt(node.start, this.startLoc);
|
|
const from = /** @type {Record<string, unknown>} */ (
|
|
/** @type {unknown} */ (node)
|
|
);
|
|
const to = /** @type {Record<string, unknown>} */ (
|
|
/** @type {unknown} */ (newNode)
|
|
);
|
|
for (const prop in from) to[prop] = from[prop];
|
|
return newNode;
|
|
}
|
|
|
|
// ----- owned node construction (single-shape nodes, replaces acorn's
|
|
// start-empty-then-mutate flow one node type at a time) -----
|
|
|
|
/**
|
|
* Owned `parseIdent` for the common name-token case: builds the finished
|
|
* `IdentifierNode` directly, skipping acorn's `parseIdentNode`/`startNode`/
|
|
* `finishNode` chain and its keyword branches. Keyword-as-identifier
|
|
* (`obj.class`) and non-lazy mode delegate to acorn.
|
|
* @param {boolean=} liberal whether reserved words are allowed
|
|
* @returns {Identifier} identifier node
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseIdent(liberal) {
|
|
if (this.type !== tokTypes.name || !this._lazy) {
|
|
return base.parseIdent.call(this, liberal);
|
|
}
|
|
const node = /** @type {Identifier} */ (
|
|
/** @type {unknown} */ (
|
|
new IdentifierNode(
|
|
this.start,
|
|
this.end,
|
|
/** @type {string} */ (this.value)
|
|
)
|
|
)
|
|
);
|
|
this.next(Boolean(liberal));
|
|
if (!liberal) {
|
|
this.checkUnreserved(node);
|
|
if (node.name === "await" && !this.awaitIdentPos) {
|
|
this.awaitIdentPos = node.start;
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
|
|
/**
|
|
* Owned `parseSubscript`, an exact-semantics copy of acorn 8's with the
|
|
* node construction replaced: member and call nodes are built fully-formed
|
|
* after their property/arguments parse (the half-built node was never
|
|
* reachable during it), landing on `MemberExpressionNode`/
|
|
* `CallExpressionNode`'s single shapes. Pre-optional-chaining ecmaVersions
|
|
* and non-lazy mode delegate to acorn.
|
|
* @param {Expression} baseExpr subscript base
|
|
* @param {number} startPos expression start offset
|
|
* @param {Position | undefined} startLoc expression start position
|
|
* @param {boolean | undefined} noCalls whether calls are forbidden (`new` callee)
|
|
* @param {boolean} maybeAsyncArrow whether this may be an async arrow head
|
|
* @param {boolean} optionalChained whether the chain is already optional
|
|
* @param {boolean | string} forInit for-init context flag
|
|
* @returns {Expression} subscript element or `baseExpr` when done
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseSubscript(
|
|
baseExpr,
|
|
startPos,
|
|
startLoc,
|
|
noCalls,
|
|
maybeAsyncArrow,
|
|
optionalChained,
|
|
forInit
|
|
) {
|
|
if (!this._subscriptFastPath) {
|
|
return base.parseSubscript.call(
|
|
this,
|
|
baseExpr,
|
|
startPos,
|
|
startLoc,
|
|
noCalls,
|
|
maybeAsyncArrow,
|
|
optionalChained,
|
|
forInit
|
|
);
|
|
}
|
|
const optional = this.eat(tokTypes.questionDot);
|
|
if (noCalls && optional) {
|
|
this.raise(
|
|
this.lastTokStart,
|
|
"Optional chaining cannot appear in the callee of new expressions"
|
|
);
|
|
}
|
|
|
|
const computed = this.eat(tokTypes.bracketL);
|
|
if (
|
|
computed ||
|
|
(optional &&
|
|
this.type !== tokTypes.parenL &&
|
|
this.type !== tokTypes.backQuote) ||
|
|
this.eat(tokTypes.dot)
|
|
) {
|
|
/** @type {Node} */
|
|
let property;
|
|
if (computed) {
|
|
property = this.parseExpression();
|
|
this.expect(tokTypes.bracketR);
|
|
} else if (
|
|
this.type === tokTypes.privateId &&
|
|
/** @type {string} */ (baseExpr.type) !== "Super"
|
|
) {
|
|
property = this.parsePrivateIdent();
|
|
} else {
|
|
property = this.parseIdent(this.options.allowReserved !== "never");
|
|
}
|
|
return /** @type {Expression} */ (
|
|
/** @type {unknown} */ (
|
|
new MemberExpressionNode(
|
|
startPos,
|
|
this.lastTokEnd,
|
|
baseExpr,
|
|
property,
|
|
computed,
|
|
optional
|
|
)
|
|
)
|
|
);
|
|
} else if (!noCalls && this.eat(tokTypes.parenL)) {
|
|
const refDestructuringErrors = this._acquireDestructuringErrors();
|
|
const oldYieldPos = this.yieldPos;
|
|
const oldAwaitPos = this.awaitPos;
|
|
const oldAwaitIdentPos = this.awaitIdentPos;
|
|
this.yieldPos = 0;
|
|
this.awaitPos = 0;
|
|
this.awaitIdentPos = 0;
|
|
const exprList = this.parseExprList(
|
|
tokTypes.parenR,
|
|
true,
|
|
false,
|
|
refDestructuringErrors
|
|
);
|
|
if (maybeAsyncArrow && !optional && this.shouldParseAsyncArrow()) {
|
|
this.checkPatternErrors(refDestructuringErrors, false);
|
|
this._releaseDestructuringErrors();
|
|
this.checkYieldAwaitInDefaultParams();
|
|
if (this.awaitIdentPos > 0) {
|
|
this.raise(
|
|
this.awaitIdentPos,
|
|
"Cannot use 'await' as identifier inside an async function"
|
|
);
|
|
}
|
|
this.yieldPos = oldYieldPos;
|
|
this.awaitPos = oldAwaitPos;
|
|
this.awaitIdentPos = oldAwaitIdentPos;
|
|
return this.parseSubscriptAsyncArrow(
|
|
startPos,
|
|
startLoc,
|
|
exprList,
|
|
forInit
|
|
);
|
|
}
|
|
this.checkExpressionErrors(refDestructuringErrors, true);
|
|
this._releaseDestructuringErrors();
|
|
this.yieldPos = oldYieldPos || this.yieldPos;
|
|
this.awaitPos = oldAwaitPos || this.awaitPos;
|
|
this.awaitIdentPos = oldAwaitIdentPos || this.awaitIdentPos;
|
|
return /** @type {Expression} */ (
|
|
/** @type {unknown} */ (
|
|
new CallExpressionNode(
|
|
startPos,
|
|
this.lastTokEnd,
|
|
baseExpr,
|
|
exprList,
|
|
optional
|
|
)
|
|
)
|
|
);
|
|
} else if (this.type === tokTypes.backQuote) {
|
|
if (optional || optionalChained) {
|
|
this.raise(
|
|
this.start,
|
|
"Optional chaining cannot appear in the tag of tagged template expressions"
|
|
);
|
|
}
|
|
const node = this.startNodeAt(startPos, startLoc);
|
|
/** @type {Node & { tag?: Expression, quasi?: Node }} */
|
|
(node).tag = baseExpr;
|
|
/** @type {Node & { tag?: Expression, quasi?: Node }} */
|
|
(node).quasi = this.parseTemplate({ isTagged: true });
|
|
return /** @type {Expression} */ (
|
|
/** @type {unknown} */ (
|
|
this.finishNode(node, "TaggedTemplateExpression")
|
|
)
|
|
);
|
|
}
|
|
return baseExpr;
|
|
}
|
|
|
|
/**
|
|
* Owned `parseStatement` for the hot statement heads: acorn starts a node
|
|
* before dispatching, but the owned statement parsers build their own
|
|
* single-shape nodes, so that started node was one discarded allocation per
|
|
* statement. Dispatch the common heads (`var`/`let`/`const`, `if`, `return`,
|
|
* blocks and plain expression statements) without it; everything rarer, the
|
|
* `name`-token ambiguities (`let`/`async`/`using`/`await` heads) and
|
|
* plugin-overridden parsers delegate to acorn.
|
|
* @param {string | null} context statement context
|
|
* @param {boolean=} topLevel whether parsing top-level statements
|
|
* @param {unknown=} exports export tracking object
|
|
* @returns {Node} statement
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseStatement(context, topLevel, exports) {
|
|
if (!this._stmtFastPath) {
|
|
return base.parseStatement.call(this, context, topLevel, exports);
|
|
}
|
|
const startType = this.type;
|
|
switch (startType) {
|
|
case tokTypes._var:
|
|
case tokTypes._const: {
|
|
const kind = /** @type {string} */ (this.value);
|
|
if (context && kind !== "var") this.unexpected();
|
|
return this._parseVarStatementAt(this.start, kind);
|
|
}
|
|
case tokTypes._if:
|
|
return this._parseIfStatementAt(this.start);
|
|
case tokTypes._return:
|
|
return this._parseReturnStatementAt(this.start);
|
|
case tokTypes.braceL:
|
|
// the owned parseBlock never reads the started node
|
|
return this.parseBlock(true);
|
|
case tokTypes._break:
|
|
case tokTypes._continue:
|
|
case tokTypes._debugger:
|
|
case tokTypes._do:
|
|
case tokTypes._for:
|
|
case tokTypes._function:
|
|
case tokTypes._class:
|
|
case tokTypes._switch:
|
|
case tokTypes._throw:
|
|
case tokTypes._try:
|
|
case tokTypes._while:
|
|
case tokTypes._with:
|
|
case tokTypes.semi:
|
|
case tokTypes._export:
|
|
case tokTypes._import:
|
|
return base.parseStatement.call(this, context, topLevel, exports);
|
|
default: {
|
|
if (startType === tokTypes.name) {
|
|
const value = this.value;
|
|
if (value === "let") {
|
|
if (this.isLet(context)) {
|
|
// mirrors acorn's `context && kind !== "var"` rejection
|
|
if (context) this.unexpected();
|
|
return this._parseVarStatementAt(this.start, "let");
|
|
}
|
|
// `let` as a plain identifier: expression/label tail below
|
|
} else if (
|
|
value === "async" ||
|
|
value === "using" ||
|
|
value === "await"
|
|
) {
|
|
// async functions and using declarations keep acorn's
|
|
// lookahead-heavy classification
|
|
return base.parseStatement.call(this, context, topLevel, exports);
|
|
}
|
|
}
|
|
// unambiguous expression statement, with acorn's label tail
|
|
const start = this.start;
|
|
const maybeName = this.value;
|
|
const expr = this.parseExpression();
|
|
if (
|
|
startType === tokTypes.name &&
|
|
expr.type === "Identifier" &&
|
|
this.eat(tokTypes.colon)
|
|
) {
|
|
// labels are rare enough to pay for the started node
|
|
return this.parseLabeledStatement(
|
|
this.startNodeAt(start),
|
|
/** @type {string} */ (maybeName),
|
|
/** @type {Identifier} */ (expr),
|
|
context
|
|
);
|
|
}
|
|
return this._parseExpressionStatementAt(start, expr);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Owned `parseVarStatement`: the passed started node is filled by
|
|
* `parseVar` as acorn expects, then the finished statement lands on
|
|
* `VariableDeclarationNode`'s single shape. Non-lazy mode delegates.
|
|
* @param {Node} node started statement node from `parseStatement`
|
|
* @param {string} kind declaration kind
|
|
* @param {boolean=} allowMissingInitializer whether `const x;` is allowed
|
|
* @returns {Node} variable declaration
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseVarStatement(node, kind, allowMissingInitializer) {
|
|
if (!this._lazy) {
|
|
return base.parseVarStatement.call(
|
|
this,
|
|
node,
|
|
kind,
|
|
allowMissingInitializer
|
|
);
|
|
}
|
|
return this._parseVarStatementAt(node.start, kind, allowMissingInitializer);
|
|
}
|
|
|
|
/**
|
|
* Statement-position `var`/`let`/`const` without a started node: the
|
|
* declaration lands directly on `VariableDeclarationNode`'s single shape.
|
|
* @param {number} start statement start offset
|
|
* @param {string} kind declaration kind
|
|
* @param {boolean=} allowMissingInitializer whether `const x;` is allowed
|
|
* @returns {Node} variable declaration
|
|
* @this {ParserInternals}
|
|
*/
|
|
_parseVarStatementAt(start, kind, allowMissingInitializer) {
|
|
this.next();
|
|
/** @type {Node[]} */
|
|
const declarations = [];
|
|
this._parseVarInto(declarations, false, kind, allowMissingInitializer);
|
|
this.semicolon();
|
|
return /** @type {Node} */ (
|
|
/** @type {unknown} */ (
|
|
new VariableDeclarationNode(start, this.lastTokEnd, declarations, kind)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Owned `parseVar`, an exact-semantics copy of acorn 8's that builds each
|
|
* declarator fully-formed on `VariableDeclaratorNode`'s single shape. The
|
|
* passed node keeps receiving `declarations`/`kind` because
|
|
* `parseForStatement` finishes it itself. Non-lazy mode delegates.
|
|
* @param {Node} node declaration node to fill
|
|
* @param {boolean} isFor whether parsing a `for` head
|
|
* @param {string} kind declaration kind
|
|
* @param {boolean=} allowMissingInitializer whether `const x;` is allowed
|
|
* @returns {Node} the filled node
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseVar(node, isFor, kind, allowMissingInitializer) {
|
|
if (!this._lazy) {
|
|
return base.parseVar.call(
|
|
this,
|
|
node,
|
|
isFor,
|
|
kind,
|
|
allowMissingInitializer
|
|
);
|
|
}
|
|
/** @type {Node[]} */
|
|
const declarations = [];
|
|
const target =
|
|
/** @type {Node & { declarations: Node[], kind: string }} */ (node);
|
|
target.declarations = declarations;
|
|
target.kind = kind;
|
|
this._parseVarInto(declarations, isFor, kind, allowMissingInitializer);
|
|
return node;
|
|
}
|
|
|
|
/**
|
|
* The declarator loop of the owned `parseVar`, shared with the owned
|
|
* `parseStatement`'s node-free statement path.
|
|
* @param {Node[]} declarations output array for the declarators
|
|
* @param {boolean} isFor whether parsing a `for` head
|
|
* @param {string} kind declaration kind
|
|
* @param {boolean=} allowMissingInitializer whether `const x;` is allowed
|
|
* @returns {void}
|
|
* @this {ParserInternals}
|
|
*/
|
|
_parseVarInto(declarations, isFor, kind, allowMissingInitializer) {
|
|
const ecmaVersion = this._ecmaVersion;
|
|
const usingKind = kind === "using" || kind === "await using";
|
|
for (;;) {
|
|
const declStart = this.start;
|
|
const id = usingKind ? this.parseIdent() : this.parseBindingAtom();
|
|
this.checkLValPattern(
|
|
id,
|
|
kind === "var" ? BIND_VAR : BIND_LEXICAL,
|
|
false
|
|
);
|
|
/** @type {Expression | null} */
|
|
let init = null;
|
|
if (this.eat(tokTypes.eq)) {
|
|
init = this.parseMaybeAssign(isFor);
|
|
} else if (
|
|
!allowMissingInitializer &&
|
|
kind === "const" &&
|
|
!(
|
|
this.type === tokTypes._in ||
|
|
(ecmaVersion >= 6 && this.isContextual("of"))
|
|
)
|
|
) {
|
|
this.unexpected();
|
|
} else if (
|
|
!allowMissingInitializer &&
|
|
usingKind &&
|
|
ecmaVersion >= 17 &&
|
|
this.type !== tokTypes._in &&
|
|
!this.isContextual("of")
|
|
) {
|
|
this.raise(
|
|
this.lastTokEnd,
|
|
`Missing initializer in ${kind} declaration`
|
|
);
|
|
} else if (
|
|
!allowMissingInitializer &&
|
|
id.type !== "Identifier" &&
|
|
!(isFor && (this.type === tokTypes._in || this.isContextual("of")))
|
|
) {
|
|
this.raise(
|
|
this.lastTokEnd,
|
|
"Complex binding patterns require an initialization value"
|
|
);
|
|
}
|
|
declarations.push(
|
|
/** @type {Node} */ (
|
|
/** @type {unknown} */ (
|
|
new VariableDeclaratorNode(declStart, this.lastTokEnd, id, init)
|
|
)
|
|
)
|
|
);
|
|
if (!this.eat(tokTypes.comma)) break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Owned `parseExpressionStatement`: the statement lands on
|
|
* `ExpressionStatementNode`'s single shape (the passed started node is
|
|
* discarded, matching acorn's observable output). Non-lazy mode delegates.
|
|
* @param {Node} node started statement node from `parseStatement`
|
|
* @param {Expression} expr the parsed expression
|
|
* @returns {Node} expression statement
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseExpressionStatement(node, expr) {
|
|
if (!this._lazy) {
|
|
return base.parseExpressionStatement.call(this, node, expr);
|
|
}
|
|
return this._parseExpressionStatementAt(node.start, expr);
|
|
}
|
|
|
|
/**
|
|
* `parseExpressionStatement` without a started node.
|
|
* @param {number} start statement start offset
|
|
* @param {Expression} expr the parsed expression
|
|
* @returns {Node} expression statement
|
|
* @this {ParserInternals}
|
|
*/
|
|
_parseExpressionStatementAt(start, expr) {
|
|
this.semicolon();
|
|
return /** @type {Node} */ (
|
|
/** @type {unknown} */ (
|
|
new ExpressionStatementNode(start, this.lastTokEnd, expr)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Owned `parseBlock`, an exact-semantics copy of acorn 8's landing on
|
|
* `BlockStatementNode`'s single shape. Non-lazy mode delegates.
|
|
* @param {boolean=} createNewLexicalScope whether the block opens a scope
|
|
* @param {Node=} node started statement node, when called from `parseStatement`
|
|
* @param {boolean=} exitStrict whether to restore sloppy mode at the end
|
|
* @returns {Node} block statement
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseBlock(createNewLexicalScope, node, exitStrict) {
|
|
if (!this._lazy) {
|
|
return base.parseBlock.call(
|
|
this,
|
|
createNewLexicalScope,
|
|
node,
|
|
exitStrict
|
|
);
|
|
}
|
|
if (createNewLexicalScope === undefined) createNewLexicalScope = true;
|
|
const start = this.start;
|
|
/** @type {Node[]} */
|
|
const body = [];
|
|
this.expect(tokTypes.braceL);
|
|
if (createNewLexicalScope) this.enterScope(0);
|
|
while (this.type !== tokTypes.braceR) {
|
|
body.push(this.parseStatement(null));
|
|
}
|
|
if (exitStrict) this.strict = false;
|
|
this.next();
|
|
if (createNewLexicalScope) this.exitScope();
|
|
return /** @type {Node} */ (
|
|
/** @type {unknown} */ (
|
|
new BlockStatementNode(start, this.lastTokEnd, body)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Owned `parseIfStatement` landing on `IfStatementNode`'s single shape.
|
|
* Non-lazy mode delegates to acorn.
|
|
* @param {Node} node started statement node from `parseStatement`
|
|
* @returns {Node} if statement
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseIfStatement(node) {
|
|
if (!this._lazy) return base.parseIfStatement.call(this, node);
|
|
return this._parseIfStatementAt(node.start);
|
|
}
|
|
|
|
/**
|
|
* `parseIfStatement` without a started node.
|
|
* @param {number} start statement start offset
|
|
* @returns {Node} if statement
|
|
* @this {ParserInternals}
|
|
*/
|
|
_parseIfStatementAt(start) {
|
|
this.next();
|
|
const test = this.parseParenExpression();
|
|
// function declarations are allowed in branches outside strict mode
|
|
const consequent = this.parseStatement("if");
|
|
const alternate = this.eat(tokTypes._else)
|
|
? this.parseStatement("if")
|
|
: null;
|
|
return /** @type {Node} */ (
|
|
/** @type {unknown} */ (
|
|
new IfStatementNode(start, this.lastTokEnd, test, consequent, alternate)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Owned `parseReturnStatement` landing on `ReturnStatementNode`'s single
|
|
* shape. Non-lazy mode delegates to acorn.
|
|
* @param {Node} node started statement node from `parseStatement`
|
|
* @returns {Node} return statement
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseReturnStatement(node) {
|
|
if (!this._lazy) {
|
|
if (!this.allowReturn) this._tryModuleFallback();
|
|
return base.parseReturnStatement.call(this, node);
|
|
}
|
|
return this._parseReturnStatementAt(node.start);
|
|
}
|
|
|
|
/**
|
|
* In `auto` source type a top-level `return` is script-only syntax. When the
|
|
* strict module parse reaches it with no module construct seen yet, downgrade
|
|
* to a sloppy script in place: the prefix parsed under stricter rules stays a
|
|
* valid sloppy prefix, so the second full parse is avoided.
|
|
* @returns {boolean} true when the parse was downgraded to script
|
|
* @this {ParserInternals}
|
|
*/
|
|
_tryModuleFallback() {
|
|
if (
|
|
!this._moduleFallback ||
|
|
this._moduleSyntaxSeen ||
|
|
!(this.currentVarScope().flags & SCOPE_TOP)
|
|
) {
|
|
return false;
|
|
}
|
|
this.options.allowReturnOutsideFunction = true;
|
|
// acorn stamps Program.sourceType from this at parseTopLevel's end
|
|
this.options.sourceType = "script";
|
|
this.strict = false;
|
|
this.inModule = false;
|
|
this._moduleFallback = false;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* `parseReturnStatement` without a started node.
|
|
* @param {number} start statement start offset
|
|
* @returns {Node} return statement
|
|
* @this {ParserInternals}
|
|
*/
|
|
_parseReturnStatementAt(start) {
|
|
if (!this.allowReturn && !this._tryModuleFallback()) {
|
|
this.raise(this.start, "'return' outside of function");
|
|
}
|
|
this.next();
|
|
/** @type {Expression | null} */
|
|
let argument = null;
|
|
// `return` takes an optional argument, so eagerly look for a semicolon
|
|
if (!(this.eat(tokTypes.semi) || this.insertSemicolon())) {
|
|
argument = this.parseExpression();
|
|
this.semicolon();
|
|
}
|
|
return /** @type {Node} */ (
|
|
/** @type {unknown} */ (
|
|
new ReturnStatementNode(start, this.lastTokEnd, argument)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Owned `parseSpread` landing on `RestSpreadNode`'s single shape.
|
|
* Non-lazy mode delegates.
|
|
* @param {DestructuringErrorsShim | null=} refDestructuringErrors destructuring errors to fill
|
|
* @returns {Node} spread element
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseSpread(refDestructuringErrors) {
|
|
if (!this._lazy) {
|
|
return base.parseSpread.call(this, refDestructuringErrors);
|
|
}
|
|
const start = this.start;
|
|
this.next();
|
|
const argument = this.parseMaybeAssign(false, refDestructuringErrors);
|
|
return /** @type {Node} */ (
|
|
/** @type {unknown} */ (
|
|
new RestSpreadNode(start, this.lastTokEnd, "SpreadElement", argument)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Owned `parseMaybeConditional` landing on
|
|
* `ConditionalExpressionNode`'s single shape. Non-lazy mode delegates.
|
|
* @param {boolean | string=} forInit for-init context flag
|
|
* @param {DestructuringErrorsShim | null=} refDestructuringErrors destructuring errors to fill
|
|
* @returns {Expression} expression node
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseMaybeConditional(forInit, refDestructuringErrors) {
|
|
if (!this._lazy) {
|
|
return base.parseMaybeConditional.call(
|
|
this,
|
|
forInit,
|
|
refDestructuringErrors
|
|
);
|
|
}
|
|
const startPos = this.start;
|
|
const expr = this.parseExprOps(forInit, refDestructuringErrors);
|
|
if (this.checkExpressionErrors(refDestructuringErrors)) return expr;
|
|
if (
|
|
!(expr.type === "ArrowFunctionExpression" && expr.start === startPos) &&
|
|
this.eat(tokTypes.question)
|
|
) {
|
|
const consequent = this.parseMaybeAssign();
|
|
this.expect(tokTypes.colon);
|
|
const alternate = this.parseMaybeAssign(forInit);
|
|
return /** @type {Expression} */ (
|
|
/** @type {unknown} */ (
|
|
new ConditionalExpressionNode(
|
|
startPos,
|
|
this.lastTokEnd,
|
|
expr,
|
|
consequent,
|
|
alternate
|
|
)
|
|
)
|
|
);
|
|
}
|
|
return expr;
|
|
}
|
|
|
|
/**
|
|
* Owned `parseNew`, an exact-semantics copy of acorn 8's: `NewExpression`
|
|
* lands on `NewExpressionNode`'s single shape (zero-argument calls share
|
|
* one empty array like acorn's `empty`); the rare `new.target` path keeps
|
|
* the generic node. Non-lazy mode delegates.
|
|
* @returns {Expression} new expression or meta property
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseNew() {
|
|
if (!this._lazy) return base.parseNew.call(this);
|
|
if (this.containsEsc) {
|
|
this.raiseRecoverable(this.start, "Escape sequence in keyword new");
|
|
}
|
|
const nodeStart = this.start;
|
|
this.next();
|
|
if (this._ecmaVersion >= 6 && this.type === tokTypes.dot) {
|
|
const node =
|
|
/** @type {Node & { meta?: Node, property?: Identifier }} */
|
|
(this.startNodeAt(nodeStart, undefined));
|
|
const meta =
|
|
/** @type {Node & { name?: string }} */
|
|
(this.startNodeAt(nodeStart, undefined));
|
|
meta.name = "new";
|
|
node.meta = this.finishNode(/** @type {Node} */ (meta), "Identifier");
|
|
this.next();
|
|
const containsEsc = this.containsEsc;
|
|
node.property = this.parseIdent(true);
|
|
if (node.property.name !== "target") {
|
|
this.raiseRecoverable(
|
|
node.property.start,
|
|
"The only valid meta property for new is 'new.target'"
|
|
);
|
|
}
|
|
if (containsEsc) {
|
|
this.raiseRecoverable(
|
|
nodeStart,
|
|
"'new.target' must not contain escaped characters"
|
|
);
|
|
}
|
|
if (!this.allowNewDotTarget) {
|
|
this.raiseRecoverable(
|
|
nodeStart,
|
|
"'new.target' can only be used in functions and class static block"
|
|
);
|
|
}
|
|
return /** @type {Expression} */ (
|
|
/** @type {unknown} */ (this.finishNode(node, "MetaProperty"))
|
|
);
|
|
}
|
|
const startPos = this.start;
|
|
const startLoc = this.startLoc;
|
|
const callee = this.parseSubscripts(
|
|
this.parseExprAtom(null, false, true),
|
|
startPos,
|
|
startLoc,
|
|
true,
|
|
false
|
|
);
|
|
if (/** @type {string} */ (callee.type) === "Super") {
|
|
this.raiseRecoverable(startPos, "Invalid use of 'super'");
|
|
}
|
|
/** @type {Expression[]} */
|
|
const args = this.eat(tokTypes.parenL)
|
|
? this.parseExprList(tokTypes.parenR, true, false)
|
|
: EMPTY_NEW_ARGS;
|
|
return /** @type {Expression} */ (
|
|
/** @type {unknown} */ (
|
|
new NewExpressionNode(nodeStart, this.lastTokEnd, callee, args)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Owned `parseTemplateElement` landing on `TemplateElementNode`'s single
|
|
* shape; matches acorn's CRLF normalization and invalid-escape handling.
|
|
* Non-lazy mode delegates.
|
|
* @param {{ isTagged: boolean }} opts whether the template is tagged
|
|
* @returns {Node} template element
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseTemplateElement(opts) {
|
|
if (!this._lazy) return base.parseTemplateElement.call(this, opts);
|
|
const start = this.start;
|
|
/** @type {{ raw: string, cooked: string | null }} */
|
|
let value;
|
|
if (this.type === tokTypes.invalidTemplate) {
|
|
if (!opts.isTagged) {
|
|
this.raiseRecoverable(
|
|
this.start,
|
|
"Bad escape sequence in untagged template literal"
|
|
);
|
|
}
|
|
value = {
|
|
raw: /** @type {string} */ (this.value).replace(/\r\n?/g, "\n"),
|
|
cooked: null
|
|
};
|
|
} else {
|
|
const cooked = /** @type {string} */ (this.value);
|
|
// Every escape cooks strictly shorter and CRLF shortens, while a lone CR
|
|
// cooks to the LF the raw normalization would produce — so an
|
|
// equal-length cooked string IS the normalized raw. That covers every
|
|
// fast-path chunk (no backslash, no CR): raw and cooked share one string.
|
|
value = {
|
|
raw:
|
|
cooked.length === this.end - this.start
|
|
? cooked
|
|
: this.input.slice(this.start, this.end).replace(/\r\n?/g, "\n"),
|
|
cooked
|
|
};
|
|
}
|
|
this.next();
|
|
return /** @type {Node} */ (
|
|
/** @type {unknown} */ (
|
|
new TemplateElementNode(
|
|
start,
|
|
this.lastTokEnd,
|
|
value,
|
|
this.type === tokTypes.backQuote
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Owned `parseTemplate` landing on `TemplateLiteralNode`'s single shape.
|
|
* Non-lazy mode delegates.
|
|
* @param {{ isTagged?: boolean }=} opts whether the template is tagged
|
|
* @returns {Node} template literal
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseTemplate(opts) {
|
|
if (!this._lazy) {
|
|
return base.parseTemplate.call(
|
|
this,
|
|
/** @type {{ isTagged: boolean }} */ (opts)
|
|
);
|
|
}
|
|
const isTagged = (opts !== undefined && opts.isTagged) === true;
|
|
const start = this.start;
|
|
this.next();
|
|
/** @type {Expression[]} */
|
|
const expressions = [];
|
|
// one options object for all chunks (only `isTagged` is ever read)
|
|
const eltOpts = { isTagged };
|
|
let curElt = /** @type {Node & { tail?: boolean }} */ (
|
|
this.parseTemplateElement(eltOpts)
|
|
);
|
|
const quasis = [/** @type {Node} */ (curElt)];
|
|
while (!curElt.tail) {
|
|
if (this.type === tokTypes.eof) {
|
|
this.raise(this.pos, "Unterminated template literal");
|
|
}
|
|
this.expect(tokTypes.dollarBraceL);
|
|
expressions.push(this.parseExpression());
|
|
this.expect(tokTypes.braceR);
|
|
curElt = /** @type {Node & { tail?: boolean }} */ (
|
|
this.parseTemplateElement(eltOpts)
|
|
);
|
|
quasis.push(/** @type {Node} */ (curElt));
|
|
}
|
|
this.next();
|
|
return /** @type {Node} */ (
|
|
/** @type {unknown} */ (
|
|
new TemplateLiteralNode(start, this.lastTokEnd, expressions, quasis)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Owned `parseMaybeUnary`, an exact-semantics copy of acorn 8's: prefix
|
|
* unary/update and postfix update nodes are built fully-formed on
|
|
* `UnaryNode`'s shared single shape. Non-lazy mode delegates to acorn.
|
|
* @param {DestructuringErrorsShim | null} refDestructuringErrors destructuring errors to fill
|
|
* @param {boolean} sawUnary whether a unary operator was already consumed
|
|
* @param {boolean} incDec whether the caller was an update operator
|
|
* @param {boolean | string=} forInit for-init context flag
|
|
* @returns {Expression} expression node
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseMaybeUnary(refDestructuringErrors, sawUnary, incDec, forInit) {
|
|
if (!this._lazy) {
|
|
return base.parseMaybeUnary.call(
|
|
this,
|
|
refDestructuringErrors,
|
|
sawUnary,
|
|
incDec,
|
|
forInit
|
|
);
|
|
}
|
|
const startPos = this.start;
|
|
const startLoc = this.startLoc;
|
|
/** @type {Expression} */
|
|
let expr;
|
|
if (this.isContextual("await") && this.canAwait) {
|
|
expr = this.parseAwait(forInit);
|
|
sawUnary = true;
|
|
} else if (/** @type {TokenTypeInternal} */ (this.type).prefix) {
|
|
const update = this.type === tokTypes.incDec;
|
|
const operator = /** @type {string} */ (this.value);
|
|
this.next();
|
|
const argument = this.parseMaybeUnary(null, true, update, forInit);
|
|
this.checkExpressionErrors(refDestructuringErrors, true);
|
|
if (update) {
|
|
this.checkLValSimple(argument);
|
|
} else if (
|
|
this.strict &&
|
|
operator === "delete" &&
|
|
isLocalVariableAccess(argument)
|
|
) {
|
|
this.raiseRecoverable(
|
|
startPos,
|
|
"Deleting local variable in strict mode"
|
|
);
|
|
} else if (operator === "delete" && isPrivateFieldAccess(argument)) {
|
|
this.raiseRecoverable(startPos, "Private fields can not be deleted");
|
|
} else {
|
|
sawUnary = true;
|
|
}
|
|
expr = /** @type {Expression} */ (
|
|
/** @type {unknown} */ (
|
|
new UnaryNode(
|
|
startPos,
|
|
this.lastTokEnd,
|
|
update ? "UpdateExpression" : "UnaryExpression",
|
|
operator,
|
|
true,
|
|
argument
|
|
)
|
|
)
|
|
);
|
|
} else if (!sawUnary && this.type === tokTypes.privateId) {
|
|
if (
|
|
(forInit || this.privateNameStack.length === 0) &&
|
|
this.options.checkPrivateFields
|
|
) {
|
|
this.unexpected();
|
|
}
|
|
expr = /** @type {Expression} */ (
|
|
/** @type {unknown} */ (this.parsePrivateIdent())
|
|
);
|
|
// a private name is only valid as `#x in obj`
|
|
if (this.type !== tokTypes._in) this.unexpected();
|
|
} else {
|
|
expr = this.parseExprSubscripts(refDestructuringErrors, forInit);
|
|
if (this.checkExpressionErrors(refDestructuringErrors)) return expr;
|
|
while (
|
|
/** @type {TokenTypeInternal} */ (this.type).postfix &&
|
|
!this.canInsertSemicolon()
|
|
) {
|
|
const operator = /** @type {string} */ (this.value);
|
|
this.checkLValSimple(expr);
|
|
this.next();
|
|
expr = /** @type {Expression} */ (
|
|
/** @type {unknown} */ (
|
|
new UnaryNode(
|
|
startPos,
|
|
this.lastTokEnd,
|
|
"UpdateExpression",
|
|
operator,
|
|
false,
|
|
expr
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
if (!incDec && this.eat(tokTypes.starstar)) {
|
|
if (sawUnary) {
|
|
this.unexpected(this.lastTokStart);
|
|
} else {
|
|
return this.buildBinary(
|
|
startPos,
|
|
startLoc,
|
|
expr,
|
|
this.parseMaybeUnary(null, false, false, forInit),
|
|
"**",
|
|
false
|
|
);
|
|
}
|
|
}
|
|
return expr;
|
|
}
|
|
|
|
/**
|
|
* Owned `parseMaybeAssign`, an exact-semantics copy of acorn 8's: the
|
|
* operator is captured before `next()` and the `AssignmentExpression` is
|
|
* built fully-formed on `AssignmentNode`'s single shape after the
|
|
* right-hand parse. Yield and non-lazy mode delegate to acorn.
|
|
* @param {boolean | string=} forInit for-init context flag
|
|
* @param {DestructuringErrorsShim | null=} refDestructuringErrors destructuring errors to fill
|
|
* @param {((this: unknown, left: Expression, startPos: number, startLoc?: Position) => Expression)=} afterLeftParse hook applied to the parsed left side
|
|
* @returns {Expression} expression node
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseMaybeAssign(forInit, refDestructuringErrors, afterLeftParse) {
|
|
if (!this._lazy) {
|
|
return base.parseMaybeAssign.call(
|
|
this,
|
|
forInit,
|
|
refDestructuringErrors,
|
|
afterLeftParse
|
|
);
|
|
}
|
|
if (this.isContextual("yield")) {
|
|
if (this.inGenerator) return this.parseYield(forInit);
|
|
// the tokenizer assumed an expression follows `yield`, but this
|
|
// isn't that kind of yield
|
|
this.exprAllowed = false;
|
|
}
|
|
|
|
let ownDestructuringErrors = false;
|
|
let oldParenAssign = -1;
|
|
let oldTrailingComma = -1;
|
|
let oldDoubleProto = -1;
|
|
if (refDestructuringErrors) {
|
|
oldParenAssign = refDestructuringErrors.parenthesizedAssign;
|
|
oldTrailingComma = refDestructuringErrors.trailingComma;
|
|
oldDoubleProto = refDestructuringErrors.doubleProto;
|
|
refDestructuringErrors.parenthesizedAssign =
|
|
refDestructuringErrors.trailingComma = -1;
|
|
} else {
|
|
refDestructuringErrors = this._acquireDestructuringErrors();
|
|
ownDestructuringErrors = true;
|
|
}
|
|
|
|
const startPos = this.start;
|
|
const startLoc = this.startLoc;
|
|
if (this.type === tokTypes.parenL || this.type === tokTypes.name) {
|
|
this.potentialArrowAt = this.start;
|
|
this.potentialArrowInForAwait = forInit === "await";
|
|
}
|
|
let left = this.parseMaybeConditional(forInit, refDestructuringErrors);
|
|
if (afterLeftParse) {
|
|
left = afterLeftParse.call(this, left, startPos, startLoc);
|
|
}
|
|
if (/** @type {TokenTypeInternal} */ (this.type).isAssign) {
|
|
const operator = /** @type {string} */ (this.value);
|
|
if (this.type === tokTypes.eq) {
|
|
left = /** @type {Expression} */ (
|
|
this.toAssignable(left, false, refDestructuringErrors)
|
|
);
|
|
}
|
|
if (!ownDestructuringErrors) {
|
|
refDestructuringErrors.parenthesizedAssign =
|
|
refDestructuringErrors.trailingComma =
|
|
refDestructuringErrors.doubleProto =
|
|
-1;
|
|
}
|
|
if (refDestructuringErrors.shorthandAssign >= left.start) {
|
|
// shorthand default was used correctly
|
|
refDestructuringErrors.shorthandAssign = -1;
|
|
}
|
|
if (this.type === tokTypes.eq) this.checkLValPattern(left);
|
|
else this.checkLValSimple(left);
|
|
// the own record's last read was above, so the nested right-side
|
|
// parse below can already reuse its pool slot
|
|
if (ownDestructuringErrors) this._releaseDestructuringErrors();
|
|
this.next();
|
|
const right = this.parseMaybeAssign(forInit);
|
|
if (oldDoubleProto > -1) {
|
|
refDestructuringErrors.doubleProto = oldDoubleProto;
|
|
}
|
|
return /** @type {Expression} */ (
|
|
/** @type {unknown} */ (
|
|
new AssignmentNode(startPos, this.lastTokEnd, operator, left, right)
|
|
)
|
|
);
|
|
} else if (ownDestructuringErrors) {
|
|
this.checkExpressionErrors(refDestructuringErrors, true);
|
|
this._releaseDestructuringErrors();
|
|
}
|
|
if (oldParenAssign > -1) {
|
|
refDestructuringErrors.parenthesizedAssign = oldParenAssign;
|
|
}
|
|
if (oldTrailingComma > -1) {
|
|
refDestructuringErrors.trailingComma = oldTrailingComma;
|
|
}
|
|
return left;
|
|
}
|
|
|
|
/**
|
|
* Owned `parseExprOps`, an exact copy of acorn 8's, so the hot expression
|
|
* spine (`parseMaybeAssign` → here → `parseMaybeUnary`) stays monomorphic
|
|
* on owned code. Non-lazy mode delegates.
|
|
* @param {boolean | string=} forInit for-init context flag
|
|
* @param {DestructuringErrorsShim | null=} refDestructuringErrors destructuring errors to fill
|
|
* @returns {Expression} expression node
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseExprOps(forInit, refDestructuringErrors) {
|
|
if (!this._lazy) {
|
|
return base.parseExprOps.call(this, forInit, refDestructuringErrors);
|
|
}
|
|
const startPos = this.start;
|
|
const startLoc = this.startLoc;
|
|
const expr = this.parseMaybeUnary(
|
|
refDestructuringErrors || null,
|
|
false,
|
|
false,
|
|
forInit
|
|
);
|
|
if (this.checkExpressionErrors(refDestructuringErrors)) return expr;
|
|
return expr.start === startPos && expr.type === "ArrowFunctionExpression"
|
|
? expr
|
|
: this.parseExprOp(expr, startPos, startLoc, -1, forInit);
|
|
}
|
|
|
|
/**
|
|
* Owned `parseExprOp`, an exact-semantics copy of acorn 8's with the
|
|
* same-precedence continuation turned from tail recursion into a loop —
|
|
* `a + b + c + d` runs one frame instead of one per operator. Non-lazy mode
|
|
* delegates.
|
|
* @param {Expression} left left operand
|
|
* @param {number} leftStartPos expression start offset
|
|
* @param {Position | undefined} leftStartLoc expression start position
|
|
* @param {number} minPrec minimal binding precedence to continue
|
|
* @param {boolean | string=} forInit for-init context flag (excludes `in`)
|
|
* @returns {Expression} expression node
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseExprOp(left, leftStartPos, leftStartLoc, minPrec, forInit) {
|
|
if (!this._lazy) {
|
|
return base.parseExprOp.call(
|
|
this,
|
|
left,
|
|
leftStartPos,
|
|
leftStartLoc,
|
|
minPrec,
|
|
forInit
|
|
);
|
|
}
|
|
for (;;) {
|
|
const type = /** @type {TokenTypeInternal} */ (this.type);
|
|
let prec = type.binop;
|
|
// acorn's TokenType sets binop to null (never undefined) when absent
|
|
if (
|
|
prec === null ||
|
|
prec <= minPrec ||
|
|
(forInit && type === tokTypes._in)
|
|
) {
|
|
return left;
|
|
}
|
|
const logical =
|
|
type === tokTypes.logicalOR || type === tokTypes.logicalAND;
|
|
const coalesce = type === tokTypes.coalesce;
|
|
if (coalesce) {
|
|
// acorn parses `??`'s right at logical precedence so the mixing
|
|
// check below sees any unparenthesized `&&`/`||` as a sibling
|
|
prec = /** @type {number} */ (
|
|
/** @type {TokenTypeInternal} */ (tokTypes.logicalAND).binop
|
|
);
|
|
}
|
|
const op = /** @type {string} */ (this.value);
|
|
this.next();
|
|
const startPos = this.start;
|
|
const right = this.parseExprOp(
|
|
this.parseMaybeUnary(null, false, false, forInit),
|
|
startPos,
|
|
this.startLoc,
|
|
prec,
|
|
forInit
|
|
);
|
|
left = this.buildBinary(
|
|
leftStartPos,
|
|
leftStartLoc,
|
|
left,
|
|
right,
|
|
op,
|
|
logical || coalesce
|
|
);
|
|
if (
|
|
(logical && this.type === tokTypes.coalesce) ||
|
|
(coalesce &&
|
|
(this.type === tokTypes.logicalOR ||
|
|
this.type === tokTypes.logicalAND))
|
|
) {
|
|
this.raiseRecoverable(
|
|
this.start,
|
|
"Logical expressions and coalesce expressions cannot be mixed. Wrap either by parentheses"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Owned `buildBinary` (acorn calls it only from `parseExprOp`): binary and
|
|
* logical nodes are built fully-formed on `BinaryNode`'s single shape.
|
|
* Non-lazy mode delegates to acorn.
|
|
* @param {number} startPos expression start offset
|
|
* @param {Position | undefined} startLoc expression start position
|
|
* @param {Expression} left left operand
|
|
* @param {Expression} right right operand
|
|
* @param {string} op operator text
|
|
* @param {boolean} logical whether this is a logical/coalesce expression
|
|
* @returns {Expression} binary or logical expression node
|
|
* @this {ParserInternals}
|
|
*/
|
|
buildBinary(startPos, startLoc, left, right, op, logical) {
|
|
if (!this._lazy) {
|
|
return base.buildBinary.call(
|
|
this,
|
|
startPos,
|
|
startLoc,
|
|
left,
|
|
right,
|
|
op,
|
|
logical
|
|
);
|
|
}
|
|
const rightNode = /** @type {Node} */ (/** @type {unknown} */ (right));
|
|
if (rightNode.type === "PrivateIdentifier") {
|
|
this.raise(
|
|
rightNode.start,
|
|
"Private identifier can only be left side of binary expression"
|
|
);
|
|
}
|
|
return /** @type {Expression} */ (
|
|
/** @type {unknown} */ (
|
|
new BinaryNode(
|
|
startPos,
|
|
this.lastTokEnd,
|
|
logical ? "LogicalExpression" : "BinaryExpression",
|
|
left,
|
|
op,
|
|
right
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Owned `parseExprAtom` for the hot atoms: identifiers (with acorn's exact
|
|
* async-function/async-arrow detection), number/string literals, keyword
|
|
* literals (`true`/`false`/`null` — on the same `LiteralNode` shape as the
|
|
* rest) and `this`. Everything else, and non-lazy mode, delegates to acorn.
|
|
* @param {DestructuringErrorsShim | null=} refDestructuringErrors destructuring errors to fill
|
|
* @param {boolean | string=} forInit for-init context flag
|
|
* @param {boolean=} forNew whether parsed as a `new` callee
|
|
* @returns {Expression} expression atom
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseExprAtom(refDestructuringErrors, forInit, forNew) {
|
|
if (!this._lazy) {
|
|
return base.parseExprAtom.call(
|
|
this,
|
|
refDestructuringErrors,
|
|
forInit,
|
|
forNew
|
|
);
|
|
}
|
|
// division in expression position: the tokenizer got confused, force a
|
|
// regexp re-read (mirrors the top of acorn's parseExprAtom)
|
|
if (this.type === tokTypes.slash) this.readRegexp();
|
|
const type = this.type;
|
|
if (type === tokTypes.name) {
|
|
const canBeArrow = this.potentialArrowAt === this.start;
|
|
const startPos = this.start;
|
|
const startLoc = this.startLoc;
|
|
const containsEsc = this.containsEsc;
|
|
let id = this.parseIdent(false);
|
|
// `async` compare first — almost every identifier fails it, skipping
|
|
// the version probe (all operands are pure)
|
|
if (
|
|
id.name === "async" &&
|
|
!containsEsc &&
|
|
this._ecmaVersion >= 8 &&
|
|
!this.canInsertSemicolon() &&
|
|
this.eat(tokTypes._function)
|
|
) {
|
|
this.overrideContext(tokContexts.f_expr);
|
|
return this.parseFunction(
|
|
this.startNodeAt(startPos, startLoc),
|
|
0,
|
|
false,
|
|
true,
|
|
forInit
|
|
);
|
|
}
|
|
if (canBeArrow && !this.canInsertSemicolon()) {
|
|
if (this.eat(tokTypes.arrow)) {
|
|
return this.parseArrowExpression(
|
|
this.startNodeAt(startPos, startLoc),
|
|
[id],
|
|
false,
|
|
forInit
|
|
);
|
|
}
|
|
if (
|
|
id.name === "async" &&
|
|
!containsEsc &&
|
|
this._ecmaVersion >= 8 &&
|
|
this.type === tokTypes.name &&
|
|
(!this.potentialArrowInForAwait ||
|
|
this.value !== "of" ||
|
|
this.containsEsc)
|
|
) {
|
|
id = this.parseIdent(false);
|
|
if (this.canInsertSemicolon() || !this.eat(tokTypes.arrow)) {
|
|
this.unexpected();
|
|
}
|
|
return this.parseArrowExpression(
|
|
this.startNodeAt(startPos, startLoc),
|
|
[id],
|
|
true,
|
|
forInit
|
|
);
|
|
}
|
|
}
|
|
return id;
|
|
}
|
|
if (type === tokTypes.num || type === tokTypes.string) {
|
|
return /** @type {Expression} */ (
|
|
/** @type {unknown} */ (this.parseLiteral(this.value))
|
|
);
|
|
}
|
|
if (
|
|
type === tokTypes._null ||
|
|
type === tokTypes._true ||
|
|
type === tokTypes._false
|
|
) {
|
|
const node = new LiteralNode(
|
|
this.start,
|
|
this.end,
|
|
type === tokTypes._null ? null : type === tokTypes._true,
|
|
/** @type {string} */ (type.keyword)
|
|
);
|
|
this.next();
|
|
return /** @type {Expression} */ (/** @type {unknown} */ (node));
|
|
}
|
|
if (type === tokTypes._this) {
|
|
const node = new ThisNode(this.start, this.end);
|
|
this.next();
|
|
return /** @type {Expression} */ (/** @type {unknown} */ (node));
|
|
}
|
|
if (type === tokTypes.bracketL) {
|
|
const start = this.start;
|
|
this.next();
|
|
const elements = this.parseExprList(
|
|
tokTypes.bracketR,
|
|
true,
|
|
true,
|
|
refDestructuringErrors
|
|
);
|
|
return /** @type {Expression} */ (
|
|
/** @type {unknown} */ (
|
|
new ArrayExpressionNode(start, this.lastTokEnd, elements)
|
|
)
|
|
);
|
|
}
|
|
return base.parseExprAtom.call(
|
|
this,
|
|
refDestructuringErrors,
|
|
forInit,
|
|
forNew
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Owned `parseObj`, an exact-semantics copy of acorn 8's landing on
|
|
* `ObjectNode`'s single shape (the ES5 trailing-comma gate is dropped —
|
|
* the fast path requires ES11+). Non-lazy mode delegates.
|
|
* @param {boolean} isPattern whether parsing a binding pattern
|
|
* @param {DestructuringErrorsShim | null=} refDestructuringErrors destructuring errors to fill
|
|
* @returns {Node} object expression or pattern
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseObj(isPattern, refDestructuringErrors) {
|
|
if (!this._subscriptFastPath) {
|
|
return base.parseObj.call(this, isPattern, refDestructuringErrors);
|
|
}
|
|
const start = this.start;
|
|
let first = true;
|
|
// acorn's ES6+ `checkPropClash` only ever reads/writes `.proto`, so the
|
|
// record is pooled by nesting depth (like `_deStack`); a subclass override
|
|
// might write arbitrary keys and gets a fresh `{}` instead. Depth resets
|
|
// implicitly since a raise aborts the whole parse.
|
|
const pooled = this._propHashFastPath;
|
|
/** @type {Record<string, unknown>} */
|
|
let propHash;
|
|
if (pooled) {
|
|
const stack = this._propHashStack;
|
|
const depth = this._propHashDepth++;
|
|
const cached = stack[depth];
|
|
if (cached !== undefined) {
|
|
cached.proto = false;
|
|
propHash = cached;
|
|
} else {
|
|
propHash = stack[depth] = { proto: false };
|
|
}
|
|
} else {
|
|
propHash = {};
|
|
}
|
|
/** @type {Node[]} */
|
|
const properties = [];
|
|
this.next();
|
|
while (!this.eat(tokTypes.braceR)) {
|
|
if (!first) {
|
|
this.expect(tokTypes.comma);
|
|
if (this.afterTrailingComma(tokTypes.braceR)) break;
|
|
} else {
|
|
first = false;
|
|
}
|
|
const prop = this.parseProperty(isPattern, refDestructuringErrors);
|
|
if (!isPattern) {
|
|
this.checkPropClash(prop, propHash, refDestructuringErrors);
|
|
}
|
|
properties.push(prop);
|
|
}
|
|
if (pooled) this._propHashDepth--;
|
|
return /** @type {Node} */ (
|
|
/** @type {unknown} */ (
|
|
new ObjectNode(
|
|
start,
|
|
this.lastTokEnd,
|
|
isPattern ? "ObjectPattern" : "ObjectExpression",
|
|
properties
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Owned `parseProperty`, an exact-semantics copy of acorn 8's: spread/rest
|
|
* land fully-formed on `RestSpreadNode` and properties start pre-shaped on
|
|
* `PropertyNode`, which acorn's shared `parsePropertyName`/
|
|
* `parsePropertyValue` then fill in place (ES9+ semantics assumed via the
|
|
* ES11 fast-path gate). Non-lazy mode delegates.
|
|
* @param {boolean} isPattern whether parsing a binding pattern
|
|
* @param {DestructuringErrorsShim | null=} refDestructuringErrors destructuring errors to fill
|
|
* @returns {Node} property, spread element or rest element
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseProperty(isPattern, refDestructuringErrors) {
|
|
if (!this._subscriptFastPath) {
|
|
return base.parseProperty.call(this, isPattern, refDestructuringErrors);
|
|
}
|
|
const nodeStart = this.start;
|
|
if (this.eat(tokTypes.ellipsis)) {
|
|
if (isPattern) {
|
|
const argument = /** @type {Node} */ (
|
|
/** @type {unknown} */ (this.parseIdent(false))
|
|
);
|
|
if (this.type === tokTypes.comma) {
|
|
this.raiseRecoverable(
|
|
this.start,
|
|
"Comma is not permitted after the rest element"
|
|
);
|
|
}
|
|
return /** @type {Node} */ (
|
|
/** @type {unknown} */ (
|
|
new RestSpreadNode(
|
|
nodeStart,
|
|
this.lastTokEnd,
|
|
"RestElement",
|
|
argument
|
|
)
|
|
)
|
|
);
|
|
}
|
|
const argument = /** @type {Node} */ (
|
|
/** @type {unknown} */ (
|
|
this.parseMaybeAssign(false, refDestructuringErrors)
|
|
)
|
|
);
|
|
// disallow trailing comma via `this.toAssignable()`
|
|
if (
|
|
this.type === tokTypes.comma &&
|
|
refDestructuringErrors &&
|
|
refDestructuringErrors.trailingComma < 0
|
|
) {
|
|
refDestructuringErrors.trailingComma = this.start;
|
|
}
|
|
return /** @type {Node} */ (
|
|
/** @type {unknown} */ (
|
|
new RestSpreadNode(
|
|
nodeStart,
|
|
this.lastTokEnd,
|
|
"SpreadElement",
|
|
argument
|
|
)
|
|
)
|
|
);
|
|
}
|
|
const prop = /** @type {Node} */ (
|
|
/** @type {unknown} */ (new PropertyNode(nodeStart))
|
|
);
|
|
let isGenerator = false;
|
|
/** @type {number | undefined} */
|
|
let startPos;
|
|
/** @type {Position | undefined} */
|
|
let startLoc;
|
|
if (isPattern || refDestructuringErrors) {
|
|
startPos = this.start;
|
|
startLoc = this.startLoc;
|
|
}
|
|
if (!isPattern) isGenerator = this.eat(tokTypes.star);
|
|
const containsEsc = this.containsEsc;
|
|
this.parsePropertyName(prop);
|
|
let isAsync = false;
|
|
if (!isPattern && !containsEsc && !isGenerator && this.isAsyncProp(prop)) {
|
|
isAsync = true;
|
|
isGenerator = this.eat(tokTypes.star);
|
|
this.parsePropertyName(prop);
|
|
}
|
|
this.parsePropertyValue(
|
|
prop,
|
|
isPattern,
|
|
isGenerator,
|
|
isAsync,
|
|
startPos,
|
|
startLoc,
|
|
refDestructuringErrors,
|
|
containsEsc
|
|
);
|
|
return this.finishNode(prop, "Property");
|
|
}
|
|
|
|
/**
|
|
* Owned `parseLiteral`: builds the finished `LiteralNode` directly; the
|
|
* `bigint` branch matches acorn's. Non-lazy mode delegates to acorn.
|
|
* @param {unknown} value literal value
|
|
* @returns {Node} literal node
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseLiteral(value) {
|
|
if (!this._lazy) return base.parseLiteral.call(this, value);
|
|
const start = this.start;
|
|
const end = this.end;
|
|
const raw = this.input.slice(start, end);
|
|
const node = new LiteralNode(start, end, value, raw);
|
|
if (raw.charCodeAt(raw.length - 1) === 110) {
|
|
// acorn falls back to normalizing `raw` when `BigInt` is missing;
|
|
// every Node version webpack supports has it, so `value` is set
|
|
/** @type {LiteralNode & { bigint?: string }} */ (node).bigint =
|
|
/** @type {bigint} */ (value).toString();
|
|
}
|
|
this.next();
|
|
return /** @type {Node} */ (/** @type {unknown} */ (node));
|
|
}
|
|
|
|
/**
|
|
* Single-construction regexp literals: acorn validates the pattern and
|
|
* then builds the value with a second `new RegExp`. This override scans
|
|
* like acorn, keeps acorn's flag validation (for its exact messages) and
|
|
* lets one `new RegExp` be both the V8-backed validation and the value.
|
|
* @this {ParserInternals & { regexpState: unknown }}
|
|
* @returns {void}
|
|
*/
|
|
readRegexp() {
|
|
const input = this.input;
|
|
const start = this.pos;
|
|
const len = input.length;
|
|
let escaped = false;
|
|
let inClass = false;
|
|
let pos = start;
|
|
for (;;) {
|
|
if (pos >= len) this.raise(start, "Unterminated regular expression");
|
|
const ch = input.charCodeAt(pos);
|
|
// LF, CR, LS, PS
|
|
if (ch === 10 || ch === 13 || ch === 0x2028 || ch === 0x2029) {
|
|
this.raise(start, "Unterminated regular expression");
|
|
}
|
|
if (escaped) {
|
|
escaped = false;
|
|
} else {
|
|
if (ch === 91) inClass = true;
|
|
else if (ch === 93 && inClass) inClass = false;
|
|
else if (ch === 47 && !inClass) break;
|
|
escaped = ch === 92;
|
|
}
|
|
pos++;
|
|
}
|
|
const pattern = input.slice(start, pos);
|
|
this.pos = pos + 1;
|
|
const flagsStart = this.pos;
|
|
const flags = this.readWord1();
|
|
if (this.containsEsc) this.unexpected(flagsStart);
|
|
|
|
// acorn's per-ecmaVersion flag validation, kept for its exact errors;
|
|
// the whitelist is precomputed in the constructor
|
|
const ecmaVersion = this._ecmaVersion;
|
|
const validFlags = this._validRegexpFlags;
|
|
let hasU = false;
|
|
let hasV = false;
|
|
for (let i = 0; i < flags.length; i++) {
|
|
const flag = flags.charAt(i);
|
|
if (!validFlags.includes(flag)) {
|
|
this.raise(start, "Invalid regular expression flag");
|
|
}
|
|
if (flags.includes(flag, i + 1)) {
|
|
this.raise(start, "Duplicate regular expression flag");
|
|
}
|
|
if (flag === "u") hasU = true;
|
|
if (flag === "v") hasV = true;
|
|
}
|
|
if (ecmaVersion >= 15 && hasU && hasV) {
|
|
this.raise(start, "Invalid regular expression flag");
|
|
}
|
|
|
|
let value = null;
|
|
try {
|
|
value = new RegExp(pattern, flags);
|
|
} catch (err) {
|
|
// V8's verdict on the pattern, like validateRegExpPattern below
|
|
this.raiseRecoverable(start, /** @type {Error} */ (err).message);
|
|
}
|
|
return this.finishToken(tokTypes.regexp, { pattern, flags, value });
|
|
}
|
|
|
|
// ----- regexp validation (V8-backed, replaces acorn's JS revalidation) -----
|
|
|
|
/**
|
|
* Acorn constructs the literal's `RegExp` value right after this hook, so
|
|
* V8 validates every pattern anyway; acorn's own JS copy of
|
|
* that validation costs several percent of parse time. Raise from V8's
|
|
* verdict instead — invalid patterns still fail the module build, only
|
|
* exotic engine-specific message texts may differ.
|
|
* @param {{ start: number, source: string, flags: string }} state acorn regexp validation state
|
|
* @this {ParserInternals}
|
|
*/
|
|
validateRegExpPattern(state) {
|
|
try {
|
|
// eslint-disable-next-line no-new
|
|
new RegExp(state.source, state.flags);
|
|
} catch (err) {
|
|
this.raiseRecoverable(state.start, /** @type {Error} */ (err).message);
|
|
}
|
|
}
|
|
|
|
// ----- scope tracking (Set-based, replaces acorn's array + indexOf) -----
|
|
|
|
/**
|
|
* @param {number} flags scope flags
|
|
* @this {ParserInternals}
|
|
*/
|
|
enterScope(flags) {
|
|
this.scopeStack.push(new Scope(flags));
|
|
}
|
|
|
|
/**
|
|
* Set-backed replacement for acorn's `declareName` on Set-backed scopes.
|
|
* @param {string} name declared name
|
|
* @param {number} bindingType acorn BIND_* binding type
|
|
* @param {number} pos source offset for redeclaration errors
|
|
* @this {ParserInternals}
|
|
*/
|
|
declareName(name, bindingType, pos) {
|
|
let redeclared = false;
|
|
if (bindingType === BIND_LEXICAL) {
|
|
const scope = this.currentScope();
|
|
redeclared =
|
|
(scope.lexical !== undefined && scope.lexical.has(name)) ||
|
|
(scope.functions !== undefined && scope.functions.has(name)) ||
|
|
(scope.var !== undefined && scope.var.has(name));
|
|
if (scope.lexical === undefined) {
|
|
scope.firstLexical = name;
|
|
scope.lexical = new Set();
|
|
}
|
|
scope.lexical.add(name);
|
|
if (this.inModule && scope.flags & SCOPE_TOP) {
|
|
delete this.undefinedExports[name];
|
|
}
|
|
} else if (bindingType === /* BIND_SIMPLE_CATCH */ 4) {
|
|
const scope = this.currentScope();
|
|
if (scope.lexical === undefined) {
|
|
scope.firstLexical = name;
|
|
scope.lexical = new Set();
|
|
}
|
|
scope.lexical.add(name);
|
|
} else if (bindingType === /* BIND_FUNCTION */ 3) {
|
|
const scope = this.currentScope();
|
|
redeclared = this.treatFunctionsAsVar
|
|
? scope.lexical !== undefined && scope.lexical.has(name)
|
|
: (scope.lexical !== undefined && scope.lexical.has(name)) ||
|
|
(scope.var !== undefined && scope.var.has(name));
|
|
(scope.functions || (scope.functions = new Set())).add(name);
|
|
} else {
|
|
for (let i = this.scopeStack.length - 1; i >= 0; --i) {
|
|
const scope = this.scopeStack[i];
|
|
if (
|
|
(scope.lexical !== undefined &&
|
|
scope.lexical.has(name) &&
|
|
!(
|
|
scope.flags & SCOPE_SIMPLE_CATCH && scope.firstLexical === name
|
|
)) ||
|
|
// lazy-Set check first: `functions` is undefined for almost all
|
|
// scopes, and the method call walks no state worth paying for then
|
|
(scope.functions !== undefined &&
|
|
!this.treatFunctionsAsVarInScope(scope) &&
|
|
scope.functions.has(name))
|
|
) {
|
|
redeclared = true;
|
|
break;
|
|
}
|
|
(scope.var || (scope.var = new Set())).add(name);
|
|
if (this.inModule && scope.flags & SCOPE_TOP) {
|
|
delete this.undefinedExports[name];
|
|
}
|
|
if (scope.flags & SCOPE_VAR) break;
|
|
}
|
|
}
|
|
if (redeclared) {
|
|
this.raiseRecoverable(
|
|
pos,
|
|
`Identifier '${name}' has already been declared`
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set-backed replacement for acorn's `checkLocalExport` on Set-backed scopes.
|
|
* @param {Identifier} id exported identifier
|
|
* @this {ParserInternals}
|
|
*/
|
|
checkLocalExport(id) {
|
|
const topScope = this.scopeStack[0];
|
|
if (
|
|
!(topScope.lexical !== undefined && topScope.lexical.has(id.name)) &&
|
|
!(topScope.var !== undefined && topScope.var.has(id.name))
|
|
) {
|
|
this.undefinedExports[id.name] = id;
|
|
}
|
|
}
|
|
|
|
// ----- import attributes (`with { ... }` / legacy `assert { ... }`) -----
|
|
|
|
/**
|
|
* @returns {ImportAttribute[]} import attributes
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseWithClause() {
|
|
/** @type {ImportAttribute[] & { [LEGACY_ASSERT_ATTRIBUTES]?: boolean }} */
|
|
const nodes = [];
|
|
|
|
const isAssertLegacy = this.value === "assert";
|
|
|
|
if (isAssertLegacy) {
|
|
if (!this.eat(tokTypes.name)) {
|
|
return nodes;
|
|
}
|
|
} else if (!this.eat(tokTypes._with)) {
|
|
return nodes;
|
|
}
|
|
|
|
this.expect(tokTypes.braceL);
|
|
|
|
/** @type {Record<string, boolean>} */
|
|
const attributeKeys = {};
|
|
let first = true;
|
|
|
|
while (!this.eat(tokTypes.braceR)) {
|
|
if (!first) {
|
|
this.expect(tokTypes.comma);
|
|
if (this.afterTrailingComma(tokTypes.braceR)) {
|
|
break;
|
|
}
|
|
} else {
|
|
first = false;
|
|
}
|
|
|
|
const attr = this.parseImportAttribute();
|
|
const keyName =
|
|
/** @type {string} */
|
|
(attr.key.type === "Identifier" ? attr.key.name : attr.key.value);
|
|
|
|
if (Object.prototype.hasOwnProperty.call(attributeKeys, keyName)) {
|
|
this.raiseRecoverable(
|
|
attr.key.start,
|
|
`Duplicate attribute key '${keyName}'`
|
|
);
|
|
}
|
|
|
|
attributeKeys[keyName] = true;
|
|
nodes.push(attr);
|
|
}
|
|
|
|
if (isAssertLegacy) {
|
|
nodes[LEGACY_ASSERT_ATTRIBUTES] = true;
|
|
}
|
|
|
|
return nodes;
|
|
}
|
|
|
|
// ----- import phases (`import defer/source`, `import.defer/source()`) -----
|
|
|
|
/**
|
|
* @param {Node & { phase?: ImportPhase }} node import declaration node
|
|
* @returns {Node} finished node
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseImport(node) {
|
|
this._moduleSyntaxSeen = true;
|
|
this._importPhase = null;
|
|
const result = base.parseImport.call(this, node);
|
|
if (this._importPhase) node.phase = this._importPhase;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Owned `parseExport` only to flag module syntax for the auto-fallback guard;
|
|
* parsing itself delegates to acorn.
|
|
* @param {Node} node started export node
|
|
* @param {unknown} exports export-name tracking object
|
|
* @returns {Node} export declaration
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseExport(node, exports) {
|
|
this._moduleSyntaxSeen = true;
|
|
return base.parseExport.call(this, node, exports);
|
|
}
|
|
|
|
/**
|
|
* Owned `parseAwait` only to flag top-level await (module-only) for the
|
|
* auto-fallback guard; await inside a function is not module syntax.
|
|
* @param {boolean | string=} forInit for-loop init context flag
|
|
* @returns {Expression} await expression
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseAwait(forInit) {
|
|
if (this.inModule && this.currentVarScope().flags & SCOPE_TOP) {
|
|
this._moduleSyntaxSeen = true;
|
|
}
|
|
return base.parseAwait.call(this, forInit);
|
|
}
|
|
|
|
/**
|
|
* @returns {AnyImportSpecifier[]} import specifiers
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseImportSpecifiers() {
|
|
if (!this._importPhasesEnabled) {
|
|
return base.parseImportSpecifiers.call(this);
|
|
}
|
|
|
|
/** @type {ImportPhase | null} */
|
|
const phase = this.isContextual("defer")
|
|
? "defer"
|
|
: this.isContextual("source")
|
|
? "source"
|
|
: null;
|
|
if (!phase) return base.parseImportSpecifiers.call(this);
|
|
|
|
const phaseId = this.parseIdent();
|
|
if (this.isContextual("from") || this.type === tokTypes.comma) {
|
|
// `defer`/`source` was the default import name, not a phase modifier
|
|
const defaultSpecifier =
|
|
/** @type {ImportDefaultSpecifier} */
|
|
(
|
|
this.startNodeAt(
|
|
phaseId.start,
|
|
phaseId.loc ? phaseId.loc.start : undefined
|
|
)
|
|
);
|
|
defaultSpecifier.local = phaseId;
|
|
this.checkLValSimple(phaseId, BIND_LEXICAL);
|
|
|
|
/** @type {AnyImportSpecifier[]} */
|
|
const nodes = [
|
|
/** @type {ImportDefaultSpecifier} */
|
|
(this.finishNode(defaultSpecifier, "ImportDefaultSpecifier"))
|
|
];
|
|
if (this.eat(tokTypes.comma)) {
|
|
if (this.type !== tokTypes.star && this.type !== tokTypes.braceL) {
|
|
this.unexpected();
|
|
}
|
|
nodes.push(...base.parseImportSpecifiers.call(this));
|
|
}
|
|
return nodes;
|
|
}
|
|
|
|
this._importPhase = phase;
|
|
|
|
if (phase === "defer") {
|
|
if (this.type !== tokTypes.star) {
|
|
this.raiseRecoverable(
|
|
phaseId.start,
|
|
"'import defer' can only be used with namespace imports ('import defer * as identifierName from ...')."
|
|
);
|
|
}
|
|
} else if (this.type !== tokTypes.name) {
|
|
this.raiseRecoverable(
|
|
phaseId.start,
|
|
"'import source' can only be used with direct identifier specifier imports."
|
|
);
|
|
}
|
|
|
|
const specifiers = base.parseImportSpecifiers.call(this);
|
|
|
|
if (
|
|
phase === "source" &&
|
|
specifiers.some((s) => s.type !== "ImportDefaultSpecifier")
|
|
) {
|
|
this.raiseRecoverable(
|
|
phaseId.start,
|
|
"'import source' can only be used with direct identifier specifier imports ('import source identifierName from ...')."
|
|
);
|
|
}
|
|
|
|
return specifiers;
|
|
}
|
|
|
|
/**
|
|
* @param {boolean} forNew whether parsed as the operand of `new`
|
|
* @returns {Expression} expression node
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseExprImport(forNew) {
|
|
const node = base.parseExprImport.call(this, forNew);
|
|
|
|
if (
|
|
this._importPhasesEnabled &&
|
|
node.type === "MetaProperty" &&
|
|
(node.property.name === "defer" || node.property.name === "source")
|
|
) {
|
|
if (this.type === tokTypes.parenL) {
|
|
if (forNew) {
|
|
// same guard acorn applies to `new import(...)`
|
|
this.raise(node.start, "import call cannot be the target of `new`");
|
|
}
|
|
const dynImport =
|
|
/** @type {ImportExpression & { phase?: ImportPhase }} */
|
|
(
|
|
this.parseDynamicImport(
|
|
this.startNodeAt(
|
|
node.start,
|
|
node.loc ? node.loc.start : undefined
|
|
)
|
|
)
|
|
);
|
|
dynImport.phase = node.property.name;
|
|
return dynImport;
|
|
}
|
|
this.raiseRecoverable(
|
|
node.start,
|
|
`'import.${node.property.name}' can only be used in a dynamic import.`
|
|
);
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
/**
|
|
* @param {Node & { property?: Identifier }} node started node with `meta` set to `import`
|
|
* @returns {Expression} MetaProperty node
|
|
* @this {ParserInternals}
|
|
*/
|
|
parseImportMeta(node) {
|
|
if (!this._importPhasesEnabled) {
|
|
// base only accepts `import.meta` here, which is module-only
|
|
this._moduleSyntaxSeen = true;
|
|
return base.parseImportMeta.call(this, node);
|
|
}
|
|
|
|
this.next();
|
|
|
|
const containsEsc = this.containsEsc;
|
|
const property = this.parseIdent(true);
|
|
node.property = property;
|
|
const { name } = property;
|
|
|
|
// only `import.meta` is module-only; `import.defer`/`.source` are dynamic
|
|
if (name === "meta") this._moduleSyntaxSeen = true;
|
|
|
|
if (name !== "meta" && name !== "defer" && name !== "source") {
|
|
this.raiseRecoverable(
|
|
property.start,
|
|
"The only valid meta property for import is 'import.meta'"
|
|
);
|
|
}
|
|
if (containsEsc) {
|
|
this.raiseRecoverable(
|
|
node.start,
|
|
`'import.${name}' must not contain escaped characters`
|
|
);
|
|
}
|
|
if (
|
|
name === "meta" &&
|
|
this.options.sourceType !== "module" &&
|
|
!this.options.allowImportExportEverywhere
|
|
) {
|
|
this.raiseRecoverable(
|
|
node.start,
|
|
"Cannot use 'import.meta' outside a module"
|
|
);
|
|
}
|
|
|
|
return /** @type {Expression} */ (this.finishNode(node, "MetaProperty"));
|
|
}
|
|
}
|
|
|
|
/** @typedef {import("../Dependency").SourcePosition} SourcePosition */
|
|
|
|
/**
|
|
* Whether a raw string literal contains a legacy octal (`\47`, `\0` followed by
|
|
* a digit) or non-octal decimal (`\8`, `\9`) escape — all SyntaxErrors in
|
|
* strict mode. Escaped backslashes (`\\`) and `\x` / `\u` escapes are skipped.
|
|
* @param {string} raw raw string literal text, including quotes
|
|
* @returns {boolean} true when a strict-forbidden escape is present
|
|
*/
|
|
const hasOctalEscape = (raw) => {
|
|
for (let i = 0; i < raw.length; i++) {
|
|
if (raw.charCodeAt(i) !== 92) continue;
|
|
const next = raw.charCodeAt(i + 1);
|
|
if (next === 92) {
|
|
i++;
|
|
continue;
|
|
}
|
|
// `\0` is a valid NUL escape unless a digit follows it.
|
|
if (next === 48) {
|
|
const after = raw.charCodeAt(i + 2);
|
|
if (after >= 48 && after <= 57) return true;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (next >= 49 && next <= 57) return true;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
// Location decoding for lazy-mode output: nodes carry only offsets (the parser
|
|
// skips acorn's location tracking), so line/column are derived on demand from
|
|
// these two helpers.
|
|
|
|
/**
|
|
* Offset of each line's first character. Char-code scan matching acorn's
|
|
* `lineBreak` semantics (CRLF is one break): a regex `exec` loop here
|
|
* allocates a match array per line.
|
|
* @param {string} source source code
|
|
* @returns {number[]} line start offsets
|
|
*/
|
|
const buildLineStarts = (source) => {
|
|
const len = source.length;
|
|
const lineStarts = [0];
|
|
for (let i = 0; i < len; i++) {
|
|
const ch = source.charCodeAt(i);
|
|
if (ch === 10) {
|
|
lineStarts.push(i + 1);
|
|
} else if (ch === 13) {
|
|
if (source.charCodeAt(i + 1) === 10) i++;
|
|
lineStarts.push(i + 1);
|
|
} else if (ch === 0x2028 || ch === 0x2029) {
|
|
lineStarts.push(i + 1);
|
|
}
|
|
}
|
|
return lineStarts;
|
|
};
|
|
|
|
/**
|
|
* Binary search for the line containing the offset.
|
|
* @param {number[]} lineStarts line start offsets
|
|
* @param {number} offset source offset
|
|
* @returns {SourcePosition} position (1-based line, 0-based column)
|
|
*/
|
|
const positionAt = (lineStarts, offset) => {
|
|
let lo = 0;
|
|
let hi = lineStarts.length - 1;
|
|
while (lo < hi) {
|
|
const mid = (lo + hi + 1) >>> 1;
|
|
if (lineStarts[mid] <= offset) lo = mid;
|
|
else hi = mid - 1;
|
|
}
|
|
return { line: lo + 1, column: offset - lineStarts[lo] };
|
|
};
|
|
|
|
module.exports.LEGACY_ASSERT_ATTRIBUTES = LEGACY_ASSERT_ATTRIBUTES;
|
|
module.exports.WebpackParser = WebpackParser;
|
|
module.exports.buildLineStarts = buildLineStarts;
|
|
module.exports.hasOctalEscape = hasOctalEscape;
|
|
module.exports.positionAt = positionAt;
|