webpack 5.86.0 → 5.88.0

package/lib/javascript/JavascriptParser.js

@@ -47,6 +47,7 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").MetaProperty} MetaProperty */
 /** @typedef {import("estree").Property} Property */
 /** @typedef {import("estree").AssignmentPattern} AssignmentPattern */
+/** @typedef {import("estree").ChainElement} ChainElement */
 /** @typedef {import("estree").Pattern} Pattern */
 /** @typedef {import("estree").UpdateExpression} UpdateExpression */
 /** @typedef {import("estree").ObjectExpression} ObjectExpression */
@@ -105,7 +106,7 @@ const parser = AcornParser.extend(importAssertions);
 class VariableInfo {
 	/**
 	 * @param {ScopeInfo} declaredScope scope in which the variable is declared
-	 * @param {string | true} freeName which free name the variable aliases, or true when none
+	 * @param {string | true | undefined} freeName which free name the variable aliases, or true when none
 	 * @param {TagInfo | undefined} tagInfo info about tags
 	 */
 	constructor(declaredScope, freeName, tagInfo) {
@@ -131,9 +132,10 @@ class VariableInfo {
  * @property {StackedMap<string, VariableInfo | ScopeInfo>} definitions
  * @property {boolean | "arrow"} topLevelScope
  * @property {boolean | string} inShorthand
+ * @property {boolean} inTaggedTemplateTag
+ * @property {boolean} inTry
  * @property {boolean} isStrict
  * @property {boolean} isAsmJs
- * @property {boolean} inTry
  */
 
 /** @typedef {[number, number]} Range */
@@ -347,7 +349,7 @@ class JavascriptParser extends Parser {
 			importCall: new SyncBailHook(["expression"]),
 			/** @type {SyncBailHook<[Expression], boolean | void>} */
 			topLevelAwait: new SyncBailHook(["expression"]),
-			/** @type {HookMap<SyncBailHook<[BaseCallExpression], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[CallExpression], boolean | void>>} */
 			call: new HookMap(() => new SyncBailHook(["expression"])),
 			/** Something like "a.b()" */
 			/** @type {HookMap<SyncBailHook<[CallExpression, string[], boolean[], Range[]], boolean | void>>} */
@@ -372,7 +374,7 @@ class JavascriptParser extends Parser {
 					])
 			),
 			/** Something like "a.b().c.d()"" */
-			/** @type {HookMap<SyncBailHook<[Expression, string[], CallExpression, string[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[CallExpression, string[], CallExpression, string[]], boolean | void>>} */
 			callMemberChainOfCallMemberChain: new HookMap(
 				() =>
 					new SyncBailHook([
@@ -390,7 +392,7 @@ class JavascriptParser extends Parser {
 			binaryExpression: new SyncBailHook(["binaryExpression"]),
 			/** @type {HookMap<SyncBailHook<[Expression], boolean | void>>} */
 			expression: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[Expression, string[], boolean[], Range[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[MemberExpression, string[], boolean[], Range[]], boolean | void>>} */
 			expressionMemberChain: new HookMap(
 				() =>
 					new SyncBailHook([
@@ -400,13 +402,13 @@ class JavascriptParser extends Parser {
 						"memberRanges"
 					])
 			),
-			/** @type {HookMap<SyncBailHook<[Expression, string[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[MemberExpression, string[]], boolean | void>>} */
 			unhandledExpressionMemberChain: new HookMap(
 				() => new SyncBailHook(["expression", "members"])
 			),
-			/** @type {SyncBailHook<[Expression], boolean | void>} */
+			/** @type {SyncBailHook<[ConditionalExpression], boolean | void>} */
 			expressionConditionalOperator: new SyncBailHook(["expression"]),
-			/** @type {SyncBailHook<[Expression], boolean | void>} */
+			/** @type {SyncBailHook<[LogicalExpression], boolean | void>} */
 			expressionLogicalOperator: new SyncBailHook(["expression"]),
 			/** @type {SyncBailHook<[Program, Comment[]], boolean | void>} */
 			program: new SyncBailHook(["ast", "comments"]),
@@ -422,7 +424,7 @@ class JavascriptParser extends Parser {
 		this.semicolons = undefined;
 		/** @type {(Statement | ModuleDeclaration | Expression)[]} */
 		this.statementPath = undefined;
-		/** @type {Statement | ModuleDeclaration | Expression} */
+		/** @type {Statement | ModuleDeclaration | Expression | undefined} */
 		this.prevStatement = undefined;
 		/** @type {WeakMap<Expression, Set<string>>} */
 		this.destructuringAssignmentProperties = undefined;
@@ -438,27 +440,29 @@ class JavascriptParser extends Parser {
 				case "number":
 					return new BasicEvaluatedExpression()
 						.setNumber(expr.value)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				case "bigint":
 					return new BasicEvaluatedExpression()
 						.setBigInt(expr.value)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				case "string":
 					return new BasicEvaluatedExpression()
 						.setString(expr.value)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				case "boolean":
 					return new BasicEvaluatedExpression()
 						.setBoolean(expr.value)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 			}
 			if (expr.value === null) {
-				return new BasicEvaluatedExpression().setNull().setRange(expr.range);
+				return new BasicEvaluatedExpression()
+					.setNull()
+					.setRange(/** @type {Range} */ (expr.range));
 			}
 			if (expr.value instanceof RegExp) {
 				return new BasicEvaluatedExpression()
 					.setRegExp(expr.value)
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			}
 		});
 		this.hooks.evaluate.for("NewExpression").tap("JavascriptParser", _expr => {
@@ -493,7 +497,7 @@ class JavascriptParser extends Parser {
 			} else {
 				return new BasicEvaluatedExpression()
 					.setRegExp(new RegExp(""))
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			}
 
 			const arg2 = expr.arguments[1];
@@ -518,7 +522,7 @@ class JavascriptParser extends Parser {
 
 			return new BasicEvaluatedExpression()
 				.setRegExp(flags ? new RegExp(regExp, flags) : new RegExp(regExp))
-				.setRange(expr.range);
+				.setRange(/** @type {Range} */ (expr.range));
 		});
 		this.hooks.evaluate
 			.for("LogicalExpression")
@@ -584,7 +588,7 @@ class JavascriptParser extends Parser {
 		 * @param {boolean | number | BigInt | string} value the value to convert to an expression
 		 * @param {BinaryExpression | UnaryExpression} expr the expression being evaluated
 		 * @param {boolean} sideEffects whether the expression has side effects
-		 * @returns {BasicEvaluatedExpression} the evaluated expression
+		 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
 		 * @example
 		 *
 		 * ```js
@@ -611,22 +615,22 @@ class JavascriptParser extends Parser {
 					return new BasicEvaluatedExpression()
 						.setBoolean(value)
 						.setSideEffects(sideEffects)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				case "number":
 					return new BasicEvaluatedExpression()
 						.setNumber(value)
 						.setSideEffects(sideEffects)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				case "bigint":
 					return new BasicEvaluatedExpression()
 						.setBigInt(value)
 						.setSideEffects(sideEffects)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				case "string":
 					return new BasicEvaluatedExpression()
 						.setString(value)
 						.setSideEffects(sideEffects)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 			}
 		};
 
@@ -720,7 +724,7 @@ class JavascriptParser extends Parser {
 					const left = this.evaluateExpression(expr.left);
 					const right = this.evaluateExpression(expr.right);
 					const res = new BasicEvaluatedExpression();
-					res.setRange(expr.range);
+					res.setRange(/** @type {Range} */ (expr.range));
 
 					const leftConst = left.isCompileTimeValue();
 					const rightConst = right.isCompileTimeValue();
@@ -758,8 +762,14 @@ class JavascriptParser extends Parser {
 						(rightPrimitive === false &&
 							(rightConst || leftPrimitive === true)) ||
 						// Different nullish or boolish status also means not equal
-						isAlwaysDifferent(left.asBool(), right.asBool()) ||
-						isAlwaysDifferent(left.asNullish(), right.asNullish())
+						isAlwaysDifferent(
+							/** @type {boolean} */ (left.asBool()),
+							/** @type {boolean} */ (right.asBool())
+						) ||
+						isAlwaysDifferent(
+							/** @type {boolean} */ (left.asNullish()),
+							/** @type {boolean} */ (right.asNullish())
+						)
 					) {
 						return res
 							.setBoolean(!eql)
@@ -1363,7 +1373,7 @@ class JavascriptParser extends Parser {
 
 				const part = new BasicEvaluatedExpression()
 					.setString(quasi)
-					.setRange(quasiExpr.range)
+					.setRange(/** @type {Range} */ (quasiExpr.range))
 					.setExpression(quasiExpr);
 				quasis.push(part);
 				parts.push(part);
@@ -1381,11 +1391,11 @@ class JavascriptParser extends Parser {
 
 				const { quasis, parts } = getSimplifiedTemplateResult("cooked", node);
 				if (parts.length === 1) {
-					return parts[0].setRange(node.range);
+					return parts[0].setRange(/** @type {Range} */ (node.range));
 				}
 				return new BasicEvaluatedExpression()
 					.setTemplateString(quasis, parts, "cooked")
-					.setRange(node.range);
+					.setRange(/** @type {Range} */ (node.range));
 			});
 		this.hooks.evaluate
 			.for("TaggedTemplateExpression")
@@ -1400,7 +1410,7 @@ class JavascriptParser extends Parser {
 					);
 					return new BasicEvaluatedExpression()
 						.setTemplateString(quasis, parts, "raw")
-						.setRange(node.range);
+						.setRange(/** @type {Range} */ (node.range));
 				}
 			});
 
@@ -1490,7 +1500,7 @@ class JavascriptParser extends Parser {
 				return new BasicEvaluatedExpression()
 					.setArray(result)
 					.setSideEffects(param.couldHaveSideEffects())
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			});
 		this.hooks.evaluate
 			.for("ConditionalExpression")
@@ -1505,12 +1515,16 @@ class JavascriptParser extends Parser {
 					const alternate = this.evaluateExpression(expr.alternate);
 					res = new BasicEvaluatedExpression();
 					if (consequent.isConditional()) {
-						res.setOptions(consequent.options);
+						res.setOptions(
+							/** @type {BasicEvaluatedExpression[]} */ (consequent.options)
+						);
 					} else {
 						res.setOptions([consequent]);
 					}
 					if (alternate.isConditional()) {
-						res.addOptions(alternate.options);
+						res.addOptions(
+							/** @type {BasicEvaluatedExpression[]} */ (alternate.options)
+						);
 					} else {
 						res.addOptions([alternate]);
 					}
@@ -1520,7 +1534,7 @@ class JavascriptParser extends Parser {
 					);
 					if (condition.couldHaveSideEffects()) res.setSideEffects();
 				}
-				res.setRange(expr.range);
+				res.setRange(/** @type {Range} */ (expr.range));
 				return res;
 			});
 		this.hooks.evaluate
@@ -1538,7 +1552,7 @@ class JavascriptParser extends Parser {
 				if (!items.every(Boolean)) return;
 				return new BasicEvaluatedExpression()
 					.setItems(items)
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			});
 		this.hooks.evaluate
 			.for("ChainExpression")
@@ -1573,11 +1587,13 @@ class JavascriptParser extends Parser {
 				}
 
 				while (optionalExpressionsStack.length > 0) {
-					const expression = optionalExpressionsStack.pop();
+					const expression =
+						/** @type {Expression} */
+						(optionalExpressionsStack.pop());
 					const evaluated = this.evaluateExpression(expression);
 
 					if (evaluated.asNullish()) {
-						return evaluated.setRange(_expr.range);
+						return evaluated.setRange(/** @type {Range} */ (_expr.range));
 					}
 				}
 				return this.evaluateExpression(expr.expression);
@@ -2458,6 +2474,10 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {ObjectPattern} objectPattern object pattern
+	 * @returns {Set<string> | undefined} set of names or undefined if not all keys are identifiers
+	 */
 	_preWalkObjectPattern(objectPattern) {
 		const ids = new Set();
 		const properties = objectPattern.properties;
@@ -2696,6 +2716,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {TODO} expression expression
+	 */
 	walkExpression(expression) {
 		switch (expression.type) {
 			case "ArrayExpression":
@@ -3108,7 +3131,9 @@ class JavascriptParser extends Parser {
 	 */
 	walkTaggedTemplateExpression(expression) {
 		if (expression.tag) {
+			this.scope.inTaggedTemplateTag = true;
 			this.walkExpression(expression.tag);
+			this.scope.inTaggedTemplateTag = false;
 		}
 		if (expression.quasi && expression.quasi.expressions) {
 			this.walkExpressions(expression.quasi.expressions);
@@ -3423,10 +3448,10 @@ class JavascriptParser extends Parser {
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
 	 * @param {MemberExpression} expr expression info
-	 * @param {function(string, string | ScopeInfo | VariableInfo, function(): string[]): any} fallback callback when variable in not handled by hooks
-	 * @param {function(string): any} defined callback when variable is defined
+	 * @param {(function(string, string | ScopeInfo | VariableInfo, function(): string[]): any) | undefined} fallback callback when variable in not handled by hooks
+	 * @param {(function(string): any) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
+	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForExpressionWithFallback(
 		hookMap,
@@ -3458,7 +3483,7 @@ class JavascriptParser extends Parser {
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
 	 * @param {string} name key in map
 	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
+	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForName(hookMap, name, ...args) {
 		return this.callHooksForNameWithFallback(
@@ -3476,7 +3501,7 @@ class JavascriptParser extends Parser {
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks that should be called
 	 * @param {ExportedVariableInfo} info variable info
 	 * @param  {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
+	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForInfo(hookMap, info, ...args) {
 		return this.callHooksForInfoWithFallback(
@@ -3493,10 +3518,10 @@ class JavascriptParser extends Parser {
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
 	 * @param {ExportedVariableInfo} info variable info
-	 * @param {function(string): any} fallback callback when variable in not handled by hooks
-	 * @param {function(): any} defined callback when variable is defined
+	 * @param {(function(string): any) | undefined} fallback callback when variable in not handled by hooks
+	 * @param {(function(): any) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
+	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForInfoWithFallback(hookMap, info, fallback, defined, ...args) {
 		let name;
@@ -3543,10 +3568,10 @@ class JavascriptParser extends Parser {
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
 	 * @param {string} name key in map
-	 * @param {function(string): any} fallback callback when variable in not handled by hooks
-	 * @param {function(): any} defined callback when variable is defined
+	 * @param {(function(string): any) | undefined} fallback callback when variable in not handled by hooks
+	 * @param {(function(): any) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
+	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForNameWithFallback(hookMap, name, fallback, defined, ...args) {
 		return this.callHooksForInfoWithFallback(
@@ -3570,6 +3595,7 @@ class JavascriptParser extends Parser {
 			topLevelScope: oldScope.topLevelScope,
 			inTry: false,
 			inShorthand: false,
+			inTaggedTemplateTag: false,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
 			definitions: oldScope.definitions.createChild()
@@ -3586,12 +3612,19 @@ class JavascriptParser extends Parser {
 		this.scope = oldScope;
 	}
 
+	/**
+	 * @param {boolean} hasThis true, when this is defined
+	 * @param {any} params scope params
+	 * @param {function(): void} fn inner function
+	 * @returns {void}
+	 */
 	inClassScope(hasThis, params, fn) {
 		const oldScope = this.scope;
 		this.scope = {
 			topLevelScope: oldScope.topLevelScope,
 			inTry: false,
 			inShorthand: false,
+			inTaggedTemplateTag: false,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
 			definitions: oldScope.definitions.createChild()
@@ -3610,12 +3643,19 @@ class JavascriptParser extends Parser {
 		this.scope = oldScope;
 	}
 
+	/**
+	 * @param {boolean} hasThis true, when this is defined
+	 * @param {any} params scope params
+	 * @param {function(): void} fn inner function
+	 * @returns {void}
+	 */
 	inFunctionScope(hasThis, params, fn) {
 		const oldScope = this.scope;
 		this.scope = {
 			topLevelScope: oldScope.topLevelScope,
 			inTry: false,
 			inShorthand: false,
+			inTaggedTemplateTag: false,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
 			definitions: oldScope.definitions.createChild()
@@ -3634,12 +3674,17 @@ class JavascriptParser extends Parser {
 		this.scope = oldScope;
 	}
 
+	/**
+	 * @param {function(): void} fn inner function
+	 * @returns {void}
+	 */
 	inBlockScope(fn) {
 		const oldScope = this.scope;
 		this.scope = {
 			topLevelScope: oldScope.topLevelScope,
 			inTry: oldScope.inTry,
 			inShorthand: false,
+			inTaggedTemplateTag: false,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
 			definitions: oldScope.definitions.createChild()
@@ -3650,15 +3695,28 @@ class JavascriptParser extends Parser {
 		this.scope = oldScope;
 	}
 
+	/**
+	 * @param {Array<Directive | Statement | ModuleDeclaration>} statements statements
+	 */
 	detectMode(statements) {
 		const isLiteral =
 			statements.length >= 1 &&
 			statements[0].type === "ExpressionStatement" &&
 			statements[0].expression.type === "Literal";
-		if (isLiteral && statements[0].expression.value === "use strict") {
+		if (
+			isLiteral &&
+			/** @type {Literal} */
+			(/** @type {ExpressionStatement} */ (statements[0]).expression).value ===
+				"use strict"
+		) {
 			this.scope.isStrict = true;
 		}
-		if (isLiteral && statements[0].expression.value === "use asm") {
+		if (
+			isLiteral &&
+			/** @type {Literal} */
+			(/** @type {ExpressionStatement} */ (statements[0]).expression).value ===
+				"use asm"
+		) {
 			this.scope.isAsmJs = true;
 		}
 	}
@@ -3761,7 +3819,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {Expression} expression expression node
+	 * @param {TODO} expression expression node
 	 * @returns {BasicEvaluatedExpression} evaluation result
 	 */
 	evaluateExpression(expression) {
@@ -3779,7 +3837,7 @@ class JavascriptParser extends Parser {
 			// ignore error
 		}
 		return new BasicEvaluatedExpression()
-			.setRange(expression.range)
+			.setRange(/** @type {Range} */ (expression.range))
 			.setExpression(expression);
 	}
 
@@ -3916,6 +3974,7 @@ class JavascriptParser extends Parser {
 			topLevelScope: true,
 			inTry: false,
 			inShorthand: false,
+			inTaggedTemplateTag: false,
 			isStrict: false,
 			isAsmJs: false,
 			definitions: new StackedMap()
@@ -4024,43 +4083,52 @@ class JavascriptParser extends Parser {
 
 			case "VariableDeclaration":
 				return expr.declarations.every(decl =>
-					this.isPure(decl.init, decl.range[0])
+					this.isPure(decl.init, /** @type {Range} */ (decl.range)[0])
 				);
 
 			case "ConditionalExpression":
 				return (
 					this.isPure(expr.test, commentsStartPos) &&
-					this.isPure(expr.consequent, expr.test.range[1]) &&
-					this.isPure(expr.alternate, expr.consequent.range[1])
+					this.isPure(
+						expr.consequent,
+						/** @type {Range} */ (expr.test.range)[1]
+					) &&
+					this.isPure(
+						expr.alternate,
+						/** @type {Range} */ (expr.consequent.range)[1]
+					)
 				);
 
 			case "LogicalExpression":
 				return (
 					this.isPure(expr.left, commentsStartPos) &&
-					this.isPure(expr.right, expr.left.range[1])
+					this.isPure(expr.right, /** @type {Range} */ (expr.left.range)[1])
 				);
 
 			case "SequenceExpression":
 				return expr.expressions.every(expr => {
 					const pureFlag = this.isPure(expr, commentsStartPos);
-					commentsStartPos = expr.range[1];
+					commentsStartPos = /** @type {Range} */ (expr.range)[1];
 					return pureFlag;
 				});
 
 			case "CallExpression": {
 				const pureFlag =
-					expr.range[0] - commentsStartPos > 12 &&
-					this.getComments([commentsStartPos, expr.range[0]]).some(
+					/** @type {Range} */ (expr.range)[0] - commentsStartPos > 12 &&
+					this.getComments([
+						commentsStartPos,
+						/** @type {Range} */ (expr.range)[0]
+					]).some(
 						comment =>
 							comment.type === "Block" &&
 							/^\s*(#|@)__PURE__\s*$/.test(comment.value)
 					);
 				if (!pureFlag) return false;
-				commentsStartPos = expr.callee.range[1];
+				commentsStartPos = /** @type {Range} */ (expr.callee.range)[1];
 				return expr.arguments.every(arg => {
 					if (arg.type === "SpreadElement") return false;
 					const pureFlag = this.isPure(arg, commentsStartPos);
-					commentsStartPos = arg.range[1];
+					commentsStartPos = /** @type {Range} */ (arg.range)[1];
 					return pureFlag;
 				});
 			}
@@ -4114,6 +4182,10 @@ class JavascriptParser extends Parser {
 		this.semicolons.delete(pos);
 	}
 
+	/**
+	 * @param {Expression} expr expression
+	 * @returns {boolean} true, when the expression is a statement level expression
+	 */
 	isStatementLevelExpression(expr) {
 		const currentStatement = this.statementPath[this.statementPath.length - 1];
 		return (
@@ -4303,7 +4375,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {string} varName variable name
-	 * @returns {{name: string, info: VariableInfo | string}} name of the free variable and variable info for that
+	 * @returns {{name: string, info: VariableInfo | string} | undefined} name of the free variable and variable info for that
 	 */
 	getFreeInfoFromVariable(varName) {
 		const info = this.getVariableInfo(varName);
@@ -4383,7 +4455,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {MemberExpression} expression an expression
-	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => string[]}} name info
+	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => string[]} | undefined} name info
 	 */
 	getNameForExpression(expression) {
 		return this.getMemberExpressionInfo(
@@ -4407,7 +4479,7 @@ class JavascriptParser extends Parser {
 			sourceType: type === "auto" ? "module" : type
 		};
 
-		/** @type {AnyNode} */
+		/** @type {AnyNode | undefined} */
 		let ast;
 		let error;
 		let threw = false;