webpack 5.107.2 → 5.108.0

package/lib/javascript/JavascriptParser.js

@@ -17,7 +17,6 @@ const {
 	createMagicCommentContext,
 	webpackCommentRegExp
 } = require("../util/magicComment");
-const memoize = require("../util/memoize");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
 /** @typedef {import("acorn").Options} AcornOptions */
@@ -120,6 +119,7 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("../Module")} Module */
 
 /** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => Members, getMembersOptionals: () => MembersOptionals, getMemberRanges: () => MemberRanges }} GetInfoResult */
+/** @typedef {{ consequent?: EXPECTED_OBJECT, alternate?: EXPECTED_OBJECT }} GuardCollection per-branch guard frames pushed onto the parser state guard stack */
 /** @typedef {Statement | ModuleDeclaration | Expression | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} StatementPathItem */
 /** @typedef {(ident: string) => void} OnIdentString */
 /** @typedef {(ident: string, identifier: Identifier) => void} OnIdent */
@@ -132,6 +132,26 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
 /** @type {string[]} */
 const EMPTY_ARRAY = [];
+
+/**
+ * Getter that reverses `arr` in place on first access and caches it. Lighter
+ * than `memoize(() => arr.reverse())` (one closure instead of two) and called
+ * per member expression on hot parse paths.
+ * @template T
+ * @param {T[]} arr array reversed lazily on first access
+ * @returns {() => T[]} getter returning the reversed array
+ */
+const lazyReverse = (arr) => {
+	let reversed = false;
+	return () => {
+		if (!reversed) {
+			arr.reverse();
+			reversed = true;
+		}
+		return arr;
+	};
+};
+
 const ALLOWED_MEMBER_TYPES_CALL_EXPRESSION = 0b01;
 const ALLOWED_MEMBER_TYPES_EXPRESSION = 0b10;
 const ALLOWED_MEMBER_TYPES_ALL = 0b11;
@@ -299,9 +319,13 @@ class VariableInfo {
 	 * @param {TagInfo | undefined} tagInfo info about tags
 	 */
 	constructor(declaredScope, name, flags, tagInfo) {
+		/** @type {ScopeInfo} */
 		this.declaredScope = declaredScope;
+		/** @type {string | undefined} */
 		this.name = name;
+		/** @type {VariableInfoFlagsType} */
 		this.flags = flags;
+		/** @type {TagInfo | undefined} */
 		this.tagInfo = tagInfo;
 	}
 
@@ -359,13 +383,12 @@ class VariableInfo {
 /** @typedef {symbol} Tag */
 
 /** @typedef {import("../dependencies/HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
-/** @typedef {import("../dependencies/HarmonyImportDependencyParserPlugin").HarmonySpecifierGuards} HarmonySpecifierGuards */
 /** @typedef {import("../dependencies/ImportParserPlugin").ImportSettings} ImportSettings */
 /** @typedef {import("../dependencies/CommonJsImportsParserPlugin").CommonJsImportSettings} CommonJsImportSettings */
 /** @typedef {import("../CompatibilityPlugin").CompatibilitySettings} CompatibilitySettings */
 /** @typedef {import("../optimize/InnerGraph").TopLevelSymbol} TopLevelSymbol */
 
-/** @typedef {HarmonySettings | ImportSettings | CommonJsImportSettings | TopLevelSymbol | CompatibilitySettings | HarmonySpecifierGuards} KnownTagData */
+/** @typedef {HarmonySettings | ImportSettings | CommonJsImportSettings | TopLevelSymbol | CompatibilitySettings} KnownTagData */
 /** @typedef {KnownTagData | Record<string, EXPECTED_ANY>} TagData */
 
 /**
@@ -474,6 +497,25 @@ const getRootName = (expression) => {
 	}
 };
 
+/**
+ * @param {string} type AST node type
+ * @returns {boolean} true for FunctionExpression or ArrowFunctionExpression
+ */
+const isFunctionExpression = (type) =>
+	type === "FunctionExpression" || type === "ArrowFunctionExpression";
+
+/**
+ * @param {FunctionExpression | ArrowFunctionExpression} fn function
+ * @returns {boolean} true when all params are plain identifiers
+ */
+const isSimpleFunction = (fn) => {
+	const params = fn.params;
+	for (let i = 0; i < params.length; i++) {
+		if (params[i].type !== "Identifier") return false;
+	}
+	return true;
+};
+
 /** @type {ParseOptions} */
 const defaultParserOptions = {
 	sourceType: "module",
@@ -536,7 +578,7 @@ class JavascriptParser extends Parser {
 			statement: new SyncBailHook(["statement"]),
 			/** @type {SyncBailHook<[IfStatement], boolean | void>} */
 			statementIf: new SyncBailHook(["statement"]),
-			/** @type {SyncBailHook<[Expression], ((walk: () => void) => void) | void>} */
+			/** @type {SyncBailHook<[Expression], GuardCollection | void>} */
 			collectGuards: new SyncBailHook(["expression"]),
 			/** @type {SyncBailHook<[Expression, ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration], boolean | void>} */
 			classExtendsExpression: new SyncBailHook([
@@ -713,6 +755,9 @@ class JavascriptParser extends Parser {
 		/** @type {TagData | undefined} */
 		this.currentTagData = undefined;
 		this.magicCommentContext = createMagicCommentContext();
+		// Reused for enterPatterns on every scope entry to avoid per-scope closures.
+		/** @type {OnIdentString} */
+		this._defineVariable = (ident) => this.defineVariable(ident);
 		this._initializeEvaluating();
 	}
 
@@ -1494,15 +1539,16 @@ class JavascriptParser extends Parser {
 					/** @type {Identifier | ThisExpression | MemberExpression} */ (expr);
 
 				const info = getInfo(expression);
+				// Cache the result (even when undefined) so the stage-100 tap below
+				// reuses it instead of recomputing getInfo — getMemberExpressionInfo
+				// is expensive and previously ran twice for every rejected member.
+				cachedExpression = expression;
+				cachedInfo = info;
 				if (info !== undefined) {
 					return this.callHooksForInfoWithFallback(
 						this.hooks.evaluateIdentifier,
 						info.name,
-						(_name) => {
-							cachedExpression = expression;
-							cachedInfo = info;
-							return undefined;
-						},
+						(_name) => undefined,
 						(name) => {
 							const hook = this.hooks.evaluateDefinedIdentifier.get(name);
 							if (hook !== undefined) {
@@ -1542,7 +1588,11 @@ class JavascriptParser extends Parser {
 			const info = this.getVariableInfo(/** @type {Identifier} */ (expr).name);
 			if (
 				typeof info === "string" ||
-				(info instanceof VariableInfo && (info.isFree() || info.isTagged()))
+				(info instanceof VariableInfo &&
+					(info.isFree() ||
+						info.isTagged() ||
+						// Walk `tagInfo` in `callHooksForInfo` if tagInfo is present.
+						info.tagInfo !== undefined))
 			) {
 				return {
 					name: info,
@@ -2368,6 +2418,27 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * Walks a conditional branch with its guard frame (if any) pushed onto the
+	 * parser-state guard stack for the duration of the branch body.
+	 * @param {EXPECTED_OBJECT | undefined | null} frame guard frame, or falsy when the branch is unguarded
+	 * @param {() => void} walk branch walk
+	 * @returns {void}
+	 */
+	walkGuardedBranch(frame, walk) {
+		if (!frame) {
+			walk();
+			return;
+		}
+		const stack = this.state.guardStack || (this.state.guardStack = []);
+		stack.push(frame);
+		try {
+			walk();
+		} finally {
+			stack.pop();
+		}
+	}
+
 	/**
 	 * Processes the provided statement.
 	 * @param {IfStatement} statement if statement
@@ -2375,22 +2446,20 @@ class JavascriptParser extends Parser {
 	walkIfStatement(statement) {
 		const result = this.hooks.statementIf.call(statement);
 		if (result === undefined) {
-			const inGuard = this.hooks.collectGuards.call(statement.test);
-			if (inGuard) {
-				inGuard(() => {
-					this.walkExpression(statement.test);
-					this.walkNestedStatement(statement.consequent);
-				});
-			} else {
-				this.walkExpression(statement.test);
-				this.walkNestedStatement(statement.consequent);
-			}
+			const guard = this.hooks.collectGuards.call(statement.test);
+			this.walkExpression(statement.test);
+			this.walkGuardedBranch(guard ? guard.consequent : undefined, () =>
+				this.walkNestedStatement(statement.consequent)
+			);
 
 			const consequentTerminated = this.scope.terminated;
 			this.scope.terminated = undefined;
 
 			if (statement.alternate) {
-				this.walkNestedStatement(statement.alternate);
+				const alternate = statement.alternate;
+				this.walkGuardedBranch(guard ? guard.alternate : undefined, () =>
+					this.walkNestedStatement(alternate)
+				);
 			}
 
 			const alternateTerminated = this.scope.terminated;
@@ -3101,23 +3170,42 @@ class JavascriptParser extends Parser {
 	 * @param {HookMap<SyncBailHook<[Identifier], boolean | void>>} hookMap map of hooks
 	 */
 	_preWalkVariableDeclaration(statement, hookMap) {
+		/** @type {OnIdent | undefined} */
+		let onIdent;
 		for (const declarator of statement.declarations) {
-			switch (declarator.type) {
-				case "VariableDeclarator": {
-					this.preWalkVariableDeclarator(declarator);
-					if (!this.hooks.preDeclarator.call(declarator, statement)) {
-						this.enterPattern(declarator.id, (name, ident) => {
-							let hook = hookMap.get(name);
-							if (hook === undefined || !hook.call(ident)) {
-								hook = this.hooks.varDeclaration.get(name);
-								if (hook === undefined || !hook.call(ident)) {
-									this.defineVariable(name);
-								}
-							}
-						});
-					}
-					break;
+			if (declarator.type !== "VariableDeclarator") continue;
+			this.preWalkVariableDeclarator(declarator);
+			if (this.hooks.preDeclarator.call(declarator, statement)) continue;
+			const id = declarator.id;
+			if (id.type === "Identifier") {
+				// fast path: plain `const x =` skips the enterPattern dispatch and
+				// the per-declaration onIdent closure (only patterns need it)
+				if (!this.callHooksForName(this.hooks.pattern, id.name, id)) {
+					this._defineVariableForDeclaration(id.name, id, hookMap);
 				}
+			} else {
+				if (onIdent === undefined) {
+					onIdent = (name, ident) =>
+						this._defineVariableForDeclaration(name, ident, hookMap);
+				}
+				this.enterPattern(id, onIdent);
+			}
+		}
+	}
+
+	/**
+	 * Defines a declared variable unless a declaration hook handles it.
+	 * @param {string} name variable name
+	 * @param {Identifier} ident identifier node
+	 * @param {HookMap<SyncBailHook<[Identifier], boolean | void>>} hookMap kind-specific declaration hooks
+	 * @returns {void}
+	 */
+	_defineVariableForDeclaration(name, ident, hookMap) {
+		let hook = hookMap.get(name);
+		if (hook === undefined || !hook.call(ident)) {
+			hook = this.hooks.varDeclaration.get(name);
+			if (hook === undefined || !hook.call(ident)) {
+				this.defineVariable(name);
 			}
 		}
 	}
@@ -3437,7 +3525,8 @@ class JavascriptParser extends Parser {
 	 * @param {(Expression | SpreadElement | null)[]} expressions expressions
 	 */
 	walkExpressions(expressions) {
-		for (const expression of expressions) {
+		for (let i = 0, len = expressions.length; i < len; i++) {
+			const expression = expressions[i];
 			if (expression) {
 				this.walkExpression(expression);
 			}
@@ -3605,12 +3694,11 @@ class JavascriptParser extends Parser {
 	walkFunctionExpression(expression) {
 		const wasTopLevel = this.scope.topLevelScope;
 		this.scope.topLevelScope = false;
-		const scopeParams = [...expression.params];
-
-		// Add function name in scope for recursive calls
-		if (expression.id) {
-			scopeParams.push(expression.id);
-		}
+		// Only copy params when the function name must be added (recursive calls);
+		// inFunctionScope reads params without mutating, like arrow functions.
+		const scopeParams = expression.id
+			? [...expression.params, expression.id]
+			: expression.params;
 
 		this.inFunctionScope(true, scopeParams, () => {
 			for (const param of expression.params) {
@@ -3838,19 +3926,17 @@ class JavascriptParser extends Parser {
 	walkConditionalExpression(expression) {
 		const result = this.hooks.expressionConditionalOperator.call(expression);
 		if (result === undefined) {
-			const inGuard = this.hooks.collectGuards.call(expression.test);
-			if (inGuard) {
-				inGuard(() => {
-					this.walkExpression(expression.test);
-					this.walkExpression(expression.consequent);
-				});
-			} else {
-				this.walkExpression(expression.test);
-				this.walkExpression(expression.consequent);
-			}
+			const guard = this.hooks.collectGuards.call(expression.test);
+			this.walkExpression(expression.test);
+			this.walkGuardedBranch(guard ? guard.consequent : undefined, () =>
+				this.walkExpression(expression.consequent)
+			);
 
 			if (expression.alternate) {
-				this.walkExpression(expression.alternate);
+				const alternate = expression.alternate;
+				this.walkGuardedBranch(guard ? guard.alternate : undefined, () =>
+					this.walkExpression(alternate)
+				);
 			}
 		} else if (result) {
 			this.walkExpression(expression.consequent);
@@ -3864,35 +3950,36 @@ class JavascriptParser extends Parser {
 	 * @param {NewExpression} expression new expression
 	 */
 	walkNewExpression(expression) {
-		// TODO: not a webpack bug — `acorn-import-phases` accepts
-		// `new import.defer(...)` / `new import.source(...)` even though
-		// `ImportCall` is a `CallExpression` per spec and is therefore not a
-		// valid `new` operand. Acorn rejects bare `new import(...)` correctly.
-		// Drop this block once the upstream plugin (or acorn itself) reports
-		// the SyntaxError. Parenthesized forms (`new (import.defer(...))`)
-		// produce the same AST shape, so we look at the source between `new`
-		// and the callee (with comments stripped) to keep them valid.
-		if (
-			expression.callee.type === "ImportExpression" &&
-			typeof this.state.source === "string"
-		) {
-			const newStart = /** @type {Range} */ (expression.range)[0];
-			const calleeStart = /** @type {Range} */ (expression.callee.range)[0];
-			const between = this.state.source
-				.slice(newStart, calleeStart)
-				.replace(/\/\*[\s\S]*?\*\//g, "")
-				.replace(/\/\/[^\n]*/g, "");
-			if (!between.includes("(")) {
-				const err =
-					/** @type {SyntaxError & { loc?: { line: number, column: number } }} */
-					(new SyntaxError("import call cannot be the target of `new`"));
-				if (expression.loc) {
-					err.loc = {
-						line: expression.loc.start.line,
-						column: expression.loc.start.column
-					};
+		// TODO acorn-import-phases bug: it omits acorn's `!forNew` guard, so
+		// `import.defer(...)`/`import.source(...)` are wrongly accepted as `new`
+		// operands; drop once fixed. Parenthesized forms stay valid (check `(`).
+		if (typeof this.state.source === "string") {
+			let base = expression.callee;
+			while (
+				base.type === "MemberExpression" ||
+				base.type === "CallExpression"
+			) {
+				base = base.type === "MemberExpression" ? base.object : base.callee;
+			}
+			if (base.type === "ImportExpression") {
+				const newStart = /** @type {Range} */ (expression.range)[0];
+				const importStart = /** @type {Range} */ (base.range)[0];
+				const between = this.state.source
+					.slice(newStart, importStart)
+					.replace(/\/\*[\s\S]*?\*\//g, "")
+					.replace(/\/\/[^\n]*/g, "");
+				if (!between.includes("(")) {
+					const err =
+						/** @type {SyntaxError & { loc?: { line: number, column: number } }} */
+						(new SyntaxError("import call cannot be the target of `new`"));
+					if (expression.loc) {
+						err.loc = {
+							line: expression.loc.start.line,
+							column: expression.loc.start.column
+						};
+					}
+					throw err;
 				}
-				throw err;
 			}
 		}
 		const result = this.callHooksForExpression(
@@ -4059,16 +4146,9 @@ class JavascriptParser extends Parser {
 	 * @param {CallExpression} expression expression
 	 */
 	walkCallExpression(expression) {
-		/**
-		 * Checks whether this javascript parser is simple function.
-		 * @param {FunctionExpression | ArrowFunctionExpression} fn function
-		 * @returns {boolean} true when simple function
-		 */
-		const isSimpleFunction = (fn) =>
-			fn.params.every((p) => p.type === "Identifier");
 		if (
 			expression.callee.type === "MemberExpression" &&
-			expression.callee.object.type.endsWith("FunctionExpression") &&
+			isFunctionExpression(expression.callee.object.type) &&
 			!expression.callee.computed &&
 			/** @type {boolean} */
 			(
@@ -4091,7 +4171,7 @@ class JavascriptParser extends Parser {
 				expression.arguments[0]
 			);
 		} else if (
-			expression.callee.type.endsWith("FunctionExpression") &&
+			isFunctionExpression(expression.callee.type) &&
 			isSimpleFunction(
 				/** @type {FunctionExpression | ArrowFunctionExpression} */
 				(expression.callee)
@@ -4106,21 +4186,29 @@ class JavascriptParser extends Parser {
 			);
 		} else {
 			if (expression.callee.type === "MemberExpression") {
-				const exprInfo = this.getMemberExpressionInfo(
-					expression.callee,
-					ALLOWED_MEMBER_TYPES_CALL_EXPRESSION
-				);
-				if (exprInfo && exprInfo.type === "call") {
-					const result = this.callHooksForInfo(
-						this.hooks.callMemberChainOfCallMemberChain,
-						exprInfo.rootInfo,
-						expression,
-						exprInfo.getCalleeMembers(),
-						exprInfo.call,
-						exprInfo.getMembers(),
-						exprInfo.getMemberRanges()
+				// callMemberChainOfCallMemberChain only applies to call-rooted
+				// chains (e.g. `a().b()`); for the common identifier/this-rooted
+				// callee the CALL lookup always rejects, so gate on the cheap root.
+				if (
+					this.getMemberExpressionRoot(expression.callee).type ===
+					"CallExpression"
+				) {
+					const exprInfo = this.getMemberExpressionInfo(
+						expression.callee,
+						ALLOWED_MEMBER_TYPES_CALL_EXPRESSION
 					);
-					if (result === true) return;
+					if (exprInfo && exprInfo.type === "call") {
+						const result = this.callHooksForInfo(
+							this.hooks.callMemberChainOfCallMemberChain,
+							exprInfo.rootInfo,
+							expression,
+							exprInfo.getCalleeMembers(),
+							exprInfo.call,
+							exprInfo.getMembers(),
+							exprInfo.getMemberRanges()
+						);
+						if (result === true) return;
+					}
 				}
 				// import("./m").then(m => { ... })
 				if (
@@ -4374,12 +4462,12 @@ class JavascriptParser extends Parser {
 	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForName(hookMap, name, ...args) {
-		return this.callHooksForNameWithFallback(
+		return this._callHooksForInfo(
 			hookMap,
-			name,
+			this.getVariableInfo(name),
 			undefined,
 			undefined,
-			...args
+			args
 		);
 	}
 
@@ -4393,13 +4481,7 @@ class JavascriptParser extends Parser {
 	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForInfo(hookMap, info, ...args) {
-		return this.callHooksForInfoWithFallback(
-			hookMap,
-			info,
-			undefined,
-			undefined,
-			...args
-		);
+		return this._callHooksForInfo(hookMap, info, undefined, undefined, args);
 	}
 
 	/**
@@ -4414,6 +4496,23 @@ class JavascriptParser extends Parser {
 	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForInfoWithFallback(hookMap, info, fallback, defined, ...args) {
+		return this._callHooksForInfo(hookMap, info, fallback, defined, args);
+	}
+
+	/**
+	 * Shared core for the callHooksFor* helpers. Takes `args` as an already
+	 * collected array so the public wrappers each allocate it once instead of
+	 * re-collecting it through several rest-parameter layers (hot per identifier).
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks that should be called
+	 * @param {ExportedVariableInfo} info variable info
+	 * @param {((name: string) => R | undefined) | undefined} fallback callback when variable is not handled by hooks
+	 * @param {((result?: string) => R | undefined) | undefined} defined callback when variable is defined
+	 * @param {AsArray<T>} args args for the hook
+	 * @returns {R | undefined} result of hook
+	 */
+	_callHooksForInfo(hookMap, info, fallback, defined, args) {
 		/** @type {string} */
 		let name;
 		if (typeof info === "string") {
@@ -4466,12 +4565,12 @@ class JavascriptParser extends Parser {
 	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForNameWithFallback(hookMap, name, fallback, defined, ...args) {
-		return this.callHooksForInfoWithFallback(
+		return this._callHooksForInfo(
 			hookMap,
 			this.getVariableInfo(name),
 			fallback,
 			defined,
-			...args
+			args
 		);
 	}
 
@@ -4497,9 +4596,7 @@ class JavascriptParser extends Parser {
 
 		this.undefineVariable("this");
 
-		this.enterPatterns(params, (ident) => {
-			this.defineVariable(ident);
-		});
+		this.enterPatterns(params, this._defineVariable);
 
 		fn();
 
@@ -4530,9 +4627,7 @@ class JavascriptParser extends Parser {
 			this.undefineVariable("this");
 		}
 
-		this.enterPatterns(params, (ident) => {
-			this.defineVariable(ident);
-		});
+		this.enterPatterns(params, this._defineVariable);
 
 		fn();
 
@@ -4563,9 +4658,7 @@ class JavascriptParser extends Parser {
 			this.undefineVariable("this");
 		}
 
-		this.enterPatterns(params, (ident) => {
-			this.defineVariable(ident);
-		});
+		this.enterPatterns(params, this._defineVariable);
 
 		fn();
 
@@ -4607,24 +4700,18 @@ class JavascriptParser extends Parser {
 	 * @param {(Directive | Statement | ModuleDeclaration)[]} statements statements
 	 */
 	detectMode(statements) {
-		const isLiteral =
-			statements.length >= 1 &&
-			statements[0].type === "ExpressionStatement" &&
-			statements[0].expression.type === "Literal";
+		const statement = statements.length >= 1 ? statements[0] : undefined;
 		if (
-			isLiteral &&
-			/** @type {Literal} */
-			(/** @type {ExpressionStatement} */ (statements[0]).expression).value ===
-				"use strict"
+			statement === undefined ||
+			statement.type !== "ExpressionStatement" ||
+			statement.expression.type !== "Literal"
 		) {
-			this.scope.isStrict = true;
+			return;
 		}
-		if (
-			isLiteral &&
-			/** @type {Literal} */
-			(/** @type {ExpressionStatement} */ (statements[0]).expression).value ===
-				"use asm"
-		) {
+		const value = /** @type {Literal} */ (statement.expression).value;
+		if (value === "use strict") {
+			this.scope.isStrict = true;
+		} else if (value === "use asm") {
 			this.scope.isAsmJs = true;
 		}
 	}
@@ -4635,7 +4722,8 @@ class JavascriptParser extends Parser {
 	 * @param {OnIdentString} onIdent on ident callback
 	 */
 	enterPatterns(patterns, onIdent) {
-		for (const pattern of patterns) {
+		for (let i = 0, len = patterns.length; i < len; i++) {
+			const pattern = patterns[i];
 			if (typeof pattern !== "string") {
 				this.enterPattern(pattern, onIdent);
 			} else if (pattern) {
@@ -5005,7 +5093,6 @@ class JavascriptParser extends Parser {
 			.for(expr.type)
 			.call(expr, commentsStartPos);
 		if (typeof result === "boolean") return result;
-		// TODO handle more cases
 		switch (expr.type) {
 			case "ClassDeclaration":
 			case "ClassExpression": {
@@ -5534,6 +5621,38 @@ class JavascriptParser extends Parser {
 		return { options, errors };
 	}
 
+	/**
+	 * Finds the root object of a member expression chain without allocating the
+	 * member arrays. The traversal/break logic must stay in sync with
+	 * `extractMemberExpressionChain`; it lets `getMemberExpressionInfo` reject
+	 * unrecognized roots (~77% of calls) before paying for the arrays.
+	 * @param {Expression | Super} expression a member expression
+	 * @returns {Expression | Super} the root object of the chain
+	 */
+	getMemberExpressionRoot(expression) {
+		/** @type {Node} */
+		let expr = expression;
+		while (expr.type === "MemberExpression") {
+			if (expr.computed) {
+				const prop = expr.property;
+				if (
+					prop.type !== "Literal" &&
+					!(
+						prop.type === "TemplateLiteral" &&
+						prop.expressions.length === 0 &&
+						typeof prop.quasis[0].value.cooked === "string"
+					)
+				) {
+					break;
+				}
+			} else if (expr.property.type !== "Identifier") {
+				break;
+			}
+			expr = expr.object;
+		}
+		return /** @type {Expression | Super} */ (expr);
+	}
+
 	/**
 	 * Extract member expression chain.
 	 * @param {Expression | Super} expression a member expression
@@ -5631,33 +5750,39 @@ class JavascriptParser extends Parser {
 	 * @returns {CallExpressionInfo | ExpressionExpressionInfo | undefined} expression info
 	 */
 	getMemberExpressionInfo(expression, allowedTypes) {
-		const { object, members, membersOptionals, memberRanges } =
-			this.extractMemberExpressionChain(expression);
+		// Resolve the root first (no allocation); most calls reject here and so
+		// never build the member arrays via extractMemberExpressionChain.
+		const object = this.getMemberExpressionRoot(expression);
 		switch (object.type) {
 			case "CallExpression": {
 				if ((allowedTypes & ALLOWED_MEMBER_TYPES_CALL_EXPRESSION) === 0) return;
-				let callee = object.callee;
-				let rootMembers = EMPTY_ARRAY;
-				if (callee.type === "MemberExpression") {
-					({ object: callee, members: rootMembers } =
-						this.extractMemberExpressionChain(callee));
-				}
+				const calleeExpr = object.callee;
+				const callee =
+					calleeExpr.type === "MemberExpression"
+						? this.getMemberExpressionRoot(calleeExpr)
+						: calleeExpr;
 				const rootName = getRootName(callee);
 				if (!rootName) return;
 				const result = this.getNameInfoFromVariable(rootName);
 				if (!result) return;
 				const { info: rootInfo, name: resolvedRoot } = result;
+				const rootMembers =
+					calleeExpr.type === "MemberExpression"
+						? this.extractMemberExpressionChain(calleeExpr).members
+						: EMPTY_ARRAY;
+				const { members, membersOptionals, memberRanges } =
+					this.extractMemberExpressionChain(expression);
 				const calleeName = objectAndMembersToName(resolvedRoot, rootMembers);
 				return {
 					type: "call",
 					call: object,
 					calleeName,
 					rootInfo,
-					getCalleeMembers: memoize(() => rootMembers.reverse()),
+					getCalleeMembers: lazyReverse(rootMembers),
 					name: objectAndMembersToName(`${calleeName}()`, members),
-					getMembers: memoize(() => members.reverse()),
-					getMembersOptionals: memoize(() => membersOptionals.reverse()),
-					getMemberRanges: memoize(() => memberRanges.reverse())
+					getMembers: lazyReverse(members),
+					getMembersOptionals: lazyReverse(membersOptionals),
+					getMemberRanges: lazyReverse(memberRanges)
 				};
 			}
 			case "Identifier":
@@ -5670,13 +5795,15 @@ class JavascriptParser extends Parser {
 				const result = this.getNameInfoFromVariable(rootName);
 				if (!result) return;
 				const { info: rootInfo, name: resolvedRoot } = result;
+				const { members, membersOptionals, memberRanges } =
+					this.extractMemberExpressionChain(expression);
 				return {
 					type: "expression",
 					name: objectAndMembersToName(resolvedRoot, members),
 					rootInfo,
-					getMembers: memoize(() => members.reverse()),
-					getMembersOptionals: memoize(() => membersOptionals.reverse()),
-					getMemberRanges: memoize(() => memberRanges.reverse())
+					getMembers: lazyReverse(members),
+					getMembersOptionals: lazyReverse(membersOptionals),
+					getMemberRanges: lazyReverse(memberRanges)
 				};
 			}
 		}