webpack 5.98.0 → 5.99.1

package/lib/javascript/JavascriptParser.js

@@ -86,17 +86,18 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").TaggedTemplateExpression} TaggedTemplateExpression */
 /** @typedef {import("estree").TemplateLiteral} TemplateLiteral */
 /** @typedef {import("estree").AssignmentProperty} AssignmentProperty */
+/** @typedef {import("estree").MaybeNamedFunctionDeclaration} MaybeNamedFunctionDeclaration */
+/** @typedef {import("estree").MaybeNamedClassDeclaration} MaybeNamedClassDeclaration */
 /**
  * @template T
  * @typedef {import("tapable").AsArray<T>} AsArray<T>
  */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
-/** @typedef {{declaredScope: ScopeInfo, freeName: string | true | undefined, tagInfo: TagInfo | undefined}} VariableInfoInterface */
 /** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => string[], getMembersOptionals: () => boolean[], getMemberRanges: () => Range[] }} GetInfoResult */
-/** @typedef {Statement | ModuleDeclaration | Expression} StatementPathItem */
-/** @typedef {function(string): void} OnIdentString */
-/** @typedef {function(string, Identifier): void} OnIdent */
+/** @typedef {Statement | ModuleDeclaration | Expression | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} StatementPathItem */
+/** @typedef {(ident: string) => void} OnIdentString */
+/** @typedef {(ident: string, identifier: Identifier) => void} OnIdent */
 /** @typedef {StatementPathItem[]} StatementPath */
 
 // TODO remove cast when @types/estree has been updated to import assertions
@@ -115,66 +116,68 @@ const ALLOWED_MEMBER_TYPES_ALL = 0b11;
 
 const LEGACY_ASSERT_ATTRIBUTES = Symbol("assert");
 
-/**
- * @param {any} Parser parser
- * @returns {typeof AcornParser} extender acorn parser
- */
+/** @type {(BaseParser: typeof AcornParser) => typeof AcornParser} */
 const importAssertions = Parser =>
-	/** @type {typeof AcornParser} */ (
-		/** @type {unknown} */ (
-			class extends Parser {
-				parseWithClause() {
-					const nodes = [];
-
-					const isAssertLegacy = this.value === "assert";
-
-					if (isAssertLegacy) {
-						if (!this.eat(tokTypes.name)) {
-							return nodes;
-						}
-					} else if (!this.eat(tokTypes._with)) {
-						return nodes;
-					}
+	class extends Parser {
+		/**
+		 * @this {TODO}
+		 * @returns {ImportAttribute[]} import attributes
+		 */
+		parseWithClause() {
+			/** @type {ImportAttribute[]} */
+			const nodes = [];
 
-					this.expect(tokTypes.braceL);
+			const isAssertLegacy = this.value === "assert";
 
-					const attributeKeys = {};
-					let first = true;
+			if (isAssertLegacy) {
+				if (!this.eat(tokTypes.name)) {
+					return nodes;
+				}
+			} else if (!this.eat(tokTypes._with)) {
+				return nodes;
+			}
 
-					while (!this.eat(tokTypes.braceR)) {
-						if (!first) {
-							this.expect(tokTypes.comma);
-							if (this.afterTrailingComma(tokTypes.braceR)) {
-								break;
-							}
-						} else {
-							first = false;
-						}
+			this.expect(tokTypes.braceL);
 
-						const attr = this.parseImportAttribute();
-						const keyName =
-							attr.key.type === "Identifier" ? attr.key.name : attr.key.value;
+			/** @type {Record<string, boolean>} */
+			const attributeKeys = {};
+			let first = true;
 
-						if (Object.prototype.hasOwnProperty.call(attributeKeys, keyName)) {
-							this.raiseRecoverable(
-								attr.key.start,
-								`Duplicate attribute key '${keyName}'`
-							);
-						}
-
-						attributeKeys[keyName] = true;
-						nodes.push(attr);
+			while (!this.eat(tokTypes.braceR)) {
+				if (!first) {
+					this.expect(tokTypes.comma);
+					if (this.afterTrailingComma(tokTypes.braceR)) {
+						break;
 					}
+				} else {
+					first = false;
+				}
 
-					if (isAssertLegacy) {
-						nodes[LEGACY_ASSERT_ATTRIBUTES] = true;
-					}
+				const attr =
+					/** @type {ImportAttribute} */
+					this.parseImportAttribute();
+				const keyName =
+					attr.key.type === "Identifier" ? attr.key.name : attr.key.value;
 
-					return nodes;
+				if (Object.prototype.hasOwnProperty.call(attributeKeys, keyName)) {
+					this.raiseRecoverable(
+						attr.key.start,
+						`Duplicate attribute key '${keyName}'`
+					);
 				}
+
+				attributeKeys[keyName] = true;
+				nodes.push(attr);
+			}
+
+			if (isAssertLegacy) {
+				/** @type {EXPECTED_ANY} */
+				(nodes)[LEGACY_ASSERT_ATTRIBUTES] = true;
 			}
-		)
-	);
+
+			return nodes;
+		}
+	};
 
 // Syntax: https://developer.mozilla.org/en/SpiderMonkey/Parser_API
 const parser = AcornParser.extend(importAssertions);
@@ -247,7 +250,7 @@ const getImportAttributes = node => {
 		result[key] = /** @type {string} */ (attribute.value.value);
 	}
 
-	if (node.attributes[LEGACY_ASSERT_ATTRIBUTES]) {
+	if (/** @type {EXPECTED_ANY} */ (node.attributes)[LEGACY_ASSERT_ATTRIBUTES]) {
 		result._isLegacyAssert = true;
 	}
 
@@ -271,10 +274,13 @@ class VariableInfo {
 /** @typedef {Literal | string | null | undefined} ImportSource */
 /** @typedef {Omit<AcornOptions, "sourceType" | "ecmaVersion"> & { sourceType: "module" | "script" | "auto", ecmaVersion?: AcornOptions["ecmaVersion"] }} ParseOptions */
 
+/** @typedef {symbol} Tag */
+/** @typedef {Record<string, TODO>} TagData */
+
 /**
  * @typedef {object} TagInfo
- * @property {any} tag
- * @property {any} data
+ * @property {Tag} tag
+ * @property {TagData} [data]
  * @property {TagInfo | undefined} next
  */
 
@@ -287,6 +293,8 @@ class VariableInfo {
  * @property {boolean} inTry
  * @property {boolean} isStrict
  * @property {boolean} isAsmJs
+ * @property {boolean} inExecutedPath false for unknown state
+ * @property {undefined|"return"|"throw"} terminated
  */
 
 /** @typedef {[number, number]} Range */
@@ -388,7 +396,7 @@ class JavascriptParser extends Parser {
 		this.hooks = Object.freeze({
 			/** @type {HookMap<SyncBailHook<[UnaryExpression], BasicEvaluatedExpression | null | undefined>>} */
 			evaluateTypeof: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[Expression | SpreadElement | PrivateIdentifier], BasicEvaluatedExpression | null | undefined>>} */
+			/** @type {HookMap<SyncBailHook<[Expression | SpreadElement | PrivateIdentifier | Super], BasicEvaluatedExpression | null | undefined>>} */
 			evaluate: new HookMap(() => new SyncBailHook(["expression"])),
 			/** @type {HookMap<SyncBailHook<[Identifier | ThisExpression | MemberExpression | MetaProperty], BasicEvaluatedExpression | null | undefined>>} */
 			evaluateIdentifier: new HookMap(() => new SyncBailHook(["expression"])),
@@ -408,27 +416,27 @@ class JavascriptParser extends Parser {
 			evaluateCallExpressionMember: new HookMap(
 				() => new SyncBailHook(["expression", "param"])
 			),
-			/** @type {HookMap<SyncBailHook<[Expression | Declaration | PrivateIdentifier, number], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Expression | Declaration | PrivateIdentifier | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration, number], boolean | void>>} */
 			isPure: new HookMap(
 				() => new SyncBailHook(["expression", "commentsStartPosition"])
 			),
-			/** @type {SyncBailHook<[Statement | ModuleDeclaration], boolean | void>} */
+			/** @type {SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>} */
 			preStatement: new SyncBailHook(["statement"]),
 
-			/** @type {SyncBailHook<[Statement | ModuleDeclaration], boolean | void>} */
+			/** @type {SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>} */
 			blockPreStatement: new SyncBailHook(["declaration"]),
-			/** @type {SyncBailHook<[Statement | ModuleDeclaration], boolean | void>} */
+			/** @type {SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration], boolean | void>} */
 			statement: new SyncBailHook(["statement"]),
 			/** @type {SyncBailHook<[IfStatement], boolean | void>} */
 			statementIf: new SyncBailHook(["statement"]),
-			/** @type {SyncBailHook<[Expression, ClassExpression | ClassDeclaration], boolean | void>} */
+			/** @type {SyncBailHook<[Expression, ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration], boolean | void>} */
 			classExtendsExpression: new SyncBailHook([
 				"expression",
 				"classDefinition"
 			]),
-			/** @type {SyncBailHook<[MethodDefinition | PropertyDefinition | StaticBlock, ClassExpression | ClassDeclaration], boolean | void>} */
+			/** @type {SyncBailHook<[MethodDefinition | PropertyDefinition | StaticBlock, ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration], boolean | void>} */
 			classBodyElement: new SyncBailHook(["element", "classDefinition"]),
-			/** @type {SyncBailHook<[Expression, MethodDefinition | PropertyDefinition, ClassExpression | ClassDeclaration], boolean | void>} */
+			/** @type {SyncBailHook<[Expression, MethodDefinition | PropertyDefinition, ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration], boolean | void>} */
 			classBodyValue: new SyncBailHook([
 				"expression",
 				"element",
@@ -451,8 +459,8 @@ class JavascriptParser extends Parser {
 			exportImport: new SyncBailHook(["statement", "source"]),
 			/** @type {SyncBailHook<[ExportDefaultDeclaration | ExportNamedDeclaration | ExportAllDeclaration, Declaration], boolean | void>} */
 			exportDeclaration: new SyncBailHook(["statement", "declaration"]),
-			/** @type {SyncBailHook<[ExportDefaultDeclaration, FunctionDeclaration | ClassDeclaration], boolean | void>} */
-			exportExpression: new SyncBailHook(["statement", "declaration"]),
+			/** @type {SyncBailHook<[ExportDefaultDeclaration, MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression], boolean | void>} */
+			exportExpression: new SyncBailHook(["statement", "node"]),
 			/** @type {SyncBailHook<[ExportDefaultDeclaration | ExportNamedDeclaration | ExportAllDeclaration, string, string, number | undefined], boolean | void>} */
 			exportSpecifier: new SyncBailHook([
 				"statement",
@@ -563,24 +571,27 @@ class JavascriptParser extends Parser {
 			expressionLogicalOperator: new SyncBailHook(["expression"]),
 			/** @type {SyncBailHook<[Program, Comment[]], boolean | void>} */
 			program: new SyncBailHook(["ast", "comments"]),
+			/** @type {SyncBailHook<[ThrowStatement | ReturnStatement], boolean | void>} */
+			terminate: new SyncBailHook(["statement"]),
 			/** @type {SyncBailHook<[Program, Comment[]], boolean | void>} */
 			finish: new SyncBailHook(["ast", "comments"])
 		});
 		this.sourceType = sourceType;
 		/** @type {ScopeInfo} */
-		this.scope = undefined;
+		this.scope = /** @type {TODO} */ (undefined);
 		/** @type {ParserState} */
-		this.state = undefined;
+		this.state = /** @type {TODO} */ (undefined);
 		/** @type {Comment[] | undefined} */
 		this.comments = undefined;
 		/** @type {Set<number> | undefined} */
 		this.semicolons = undefined;
 		/** @type {StatementPath | undefined} */
 		this.statementPath = undefined;
-		/** @type {Statement | ModuleDeclaration | Expression | undefined} */
+		/** @type {Statement | ModuleDeclaration | Expression | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | undefined} */
 		this.prevStatement = undefined;
 		/** @type {WeakMap<Expression, Set<DestructuringAssignmentProperty>> | undefined} */
 		this.destructuringAssignmentProperties = undefined;
+		/** @type {TagData | undefined} */
 		this.currentTagData = undefined;
 		this.magicCommentContext = createMagicCommentContext();
 		this._initializeEvaluating();
@@ -1242,7 +1253,8 @@ class JavascriptParser extends Parser {
 						case "MetaProperty": {
 							const res = this.callHooksForName(
 								this.hooks.evaluateTypeof,
-								/** @type {string} */ (getRootName(expr.argument)),
+								/** @type {string} */
+								(getRootName(expr.argument)),
 								expr
 							);
 							if (res !== undefined) return res;
@@ -1349,7 +1361,7 @@ class JavascriptParser extends Parser {
 		});
 		/**
 		 * @param {"Identifier" | "ThisExpression" | "MemberExpression"} exprType expression type name
-		 * @param {function(Expression | SpreadElement): GetInfoResult | undefined} getInfo get info
+		 * @param {(node: Expression | SpreadElement) => GetInfoResult | undefined} getInfo get info
 		 * @returns {void}
 		 */
 		const tapEvaluateWithVariableInfo = (exprType, getInfo) => {
@@ -1440,7 +1452,8 @@ class JavascriptParser extends Parser {
 
 			return this.callHooksForName(
 				this.hooks.evaluateIdentifier,
-				/** @type {string} */ (getRootName(metaProperty)),
+				/** @type {string} */
+				(getRootName(metaProperty)),
 				metaProperty
 			);
 		});
@@ -1673,13 +1686,14 @@ class JavascriptParser extends Parser {
 						continue;
 					}
 
-					/** @type {string} */
 					const value = argExpr.isString()
 						? /** @type {string} */ (argExpr.string)
-						: String(/** @type {number} */ (argExpr.number));
+						: String(argExpr.number);
 
 					/** @type {string} */
-					const newString = value + (stringSuffix ? stringSuffix.string : "");
+					const newString =
+						value +
+						(stringSuffix ? /** @type {string} */ (stringSuffix.string) : "");
 					const newRange = /** @type {Range} */ ([
 						/** @type {Range} */ (argExpr.range)[0],
 						/** @type {Range} */ ((stringSuffix || argExpr).range)[1]
@@ -1854,7 +1868,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {Expression | SpreadElement} expr expression
-	 * @returns {string | VariableInfoInterface | undefined} identifier
+	 * @returns {string | VariableInfo | undefined} identifier
 	 */
 	getRenameIdentifier(expr) {
 		const result = this.evaluateExpression(expr);
@@ -1864,7 +1878,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {ClassExpression | ClassDeclaration} classy a class node
+	 * @param {ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration} classy a class node
 	 * @returns {void}
 	 */
 	walkClass(classy) {
@@ -1938,15 +1952,25 @@ class JavascriptParser extends Parser {
 	 * @param {(Statement | ModuleDeclaration)[]} statements statements
 	 */
 	walkStatements(statements) {
+		let onlyFunctionDeclaration = false;
+
 		for (let index = 0, len = statements.length; index < len; index++) {
 			const statement = statements[index];
+
+			if (onlyFunctionDeclaration && statement.type !== "FunctionDeclaration")
+				continue;
+
 			this.walkStatement(statement);
+
+			if (this.scope.terminated) {
+				onlyFunctionDeclaration = true;
+			}
 		}
 	}
 
 	/**
 	 * Walking iterates the statements and expressions and processes them
-	 * @param {Statement | ModuleDeclaration} statement statement
+	 * @param {Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration} statement statement
 	 */
 	preWalkStatement(statement) {
 		/** @type {StatementPath} */
@@ -2004,7 +2028,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {Statement | ModuleDeclaration} statement statement
+	 * @param {Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration} statement statement
 	 */
 	blockPreWalkStatement(statement) {
 		/** @type {StatementPath} */
@@ -2043,7 +2067,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {Statement | ModuleDeclaration} statement statement
+	 * @param {Statement | ModuleDeclaration | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} statement statement
 	 */
 	walkStatement(statement) {
 		/** @type {StatementPath} */
@@ -2147,7 +2171,7 @@ class JavascriptParser extends Parser {
 			this.blockPreWalkStatements(body);
 			this.prevStatement = prev;
 			this.walkStatements(body);
-		});
+		}, this.scope.inExecutedPath);
 	}
 
 	/**
@@ -2173,15 +2197,21 @@ class JavascriptParser extends Parser {
 	walkIfStatement(statement) {
 		const result = this.hooks.statementIf.call(statement);
 		if (result === undefined) {
-			this.walkExpression(statement.test);
-			this.walkNestedStatement(statement.consequent);
-			if (statement.alternate) {
-				this.walkNestedStatement(statement.alternate);
-			}
-		} else if (result) {
-			this.walkNestedStatement(statement.consequent);
-		} else if (statement.alternate) {
-			this.walkNestedStatement(statement.alternate);
+			this.inExecutedPath(false, () => {
+				this.walkExpression(statement.test);
+				this.walkNestedStatement(statement.consequent);
+				if (statement.alternate) {
+					this.walkNestedStatement(statement.alternate);
+				}
+			});
+		} else {
+			this.inExecutedPath(true, () => {
+				if (result) {
+					this.walkNestedStatement(statement.consequent);
+				} else if (statement.alternate) {
+					this.walkNestedStatement(statement.alternate);
+				}
+			});
 		}
 	}
 
@@ -2239,6 +2269,12 @@ class JavascriptParser extends Parser {
 	 */
 	walkTerminatingStatement(statement) {
 		if (statement.argument) this.walkExpression(statement.argument);
+		// Skip top level scope because to handle `export` and `module.exports` after terminate
+		if (this.scope.topLevelScope === true) return;
+		if (this.hooks.terminate.call(statement)) {
+			this.scope.terminated =
+				statement.type === "ReturnStatement" ? "return" : "throw";
+		}
 	}
 
 	/**
@@ -2275,8 +2311,19 @@ class JavascriptParser extends Parser {
 			this.walkStatement(statement.block);
 			this.scope.inTry = false;
 		}
+
+		if (this.scope.terminated === "throw") {
+			this.scope.terminated = undefined;
+		}
+
+		const oldTerminate = this.scope.terminated;
+
+		this.scope.terminated = undefined;
+
 		if (statement.handler) this.walkCatchClause(statement.handler);
 		if (statement.finalizer) this.walkStatement(statement.finalizer);
+
+		this.scope.terminated = oldTerminate;
 	}
 
 	/**
@@ -2426,7 +2473,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {FunctionDeclaration} statement function declaration
+	 * @param {FunctionDeclaration | MaybeNamedFunctionDeclaration} statement function declaration
 	 */
 	preWalkFunctionDeclaration(statement) {
 		if (statement.id) {
@@ -2435,7 +2482,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {FunctionDeclaration} statement function declaration
+	 * @param {FunctionDeclaration | MaybeNamedFunctionDeclaration} statement function declaration
 	 */
 	walkFunctionDeclaration(statement) {
 		const wasTopLevel = this.scope.topLevelScope;
@@ -2444,15 +2491,14 @@ class JavascriptParser extends Parser {
 			for (const param of statement.params) {
 				this.walkPattern(param);
 			}
-			if (statement.body.type === "BlockStatement") {
-				this.detectMode(statement.body.body);
-				const prev = this.prevStatement;
-				this.preWalkStatement(statement.body);
-				this.prevStatement = prev;
-				this.walkStatement(statement.body);
-			} else {
-				this.walkExpression(statement.body);
-			}
+
+			this.detectMode(statement.body.body);
+
+			const prev = this.prevStatement;
+
+			this.preWalkStatement(statement.body);
+			this.prevStatement = prev;
+			this.walkStatement(statement.body);
 		});
 		this.scope.topLevelScope = wasTopLevel;
 	}
@@ -2647,26 +2693,29 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {TODO} statement statement
+	 * @param {ExportDefaultDeclaration} statement statement
 	 */
 	blockPreWalkExportDefaultDeclaration(statement) {
 		const prev = this.prevStatement;
-		this.preWalkStatement(statement.declaration);
+
+		this.preWalkStatement(/** @type {TODO} */ (statement.declaration));
 		this.prevStatement = prev;
-		this.blockPreWalkStatement(statement.declaration);
+		this.blockPreWalkStatement(/** @type {TODO} */ (statement.declaration));
+
 		if (
-			/** @type {FunctionDeclaration | ClassDeclaration} */ (
-				statement.declaration
-			).id &&
+			/** @type {MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} */
+			(statement.declaration).id &&
 			statement.declaration.type !== "FunctionExpression" &&
 			statement.declaration.type !== "ClassExpression"
 		) {
 			const declaration =
-				/** @type {FunctionDeclaration | ClassDeclaration} */
+				/** @type {MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} */
 				(statement.declaration);
+
 			this.hooks.exportSpecifier.call(
 				statement,
-				declaration.id.name,
+				/** @type {Identifier} */
+				(declaration.id).name,
 				"default",
 				undefined
 			);
@@ -2679,9 +2728,8 @@ class JavascriptParser extends Parser {
 	walkExportDefaultDeclaration(statement) {
 		this.hooks.export.call(statement);
 		if (
-			/** @type {FunctionDeclaration | ClassDeclaration} */ (
-				statement.declaration
-			).id &&
+			/** @type {FunctionDeclaration | ClassDeclaration} */
+			(statement.declaration).id &&
 			statement.declaration.type !== "FunctionExpression" &&
 			statement.declaration.type !== "ClassExpression"
 		) {
@@ -2699,23 +2747,16 @@ class JavascriptParser extends Parser {
 				statement.declaration.type === "FunctionDeclaration" ||
 				statement.declaration.type === "ClassDeclaration"
 			) {
-				this.walkStatement(
-					/** @type {FunctionDeclaration | ClassDeclaration} */
-					(statement.declaration)
-				);
+				this.walkStatement(statement.declaration);
 			} else {
 				this.walkExpression(statement.declaration);
 			}
 
-			if (
-				!this.hooks.exportExpression.call(
-					statement,
-					/** @type {TODO} */ (statement).declaration
-				)
-			) {
+			if (!this.hooks.exportExpression.call(statement, statement.declaration)) {
 				this.hooks.exportSpecifier.call(
 					statement,
-					/** @type {TODO} */ (statement.declaration),
+					/** @type {TODO} */
+					(statement.declaration),
 					"default",
 					undefined
 				);
@@ -2887,7 +2928,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {ClassDeclaration} statement class declaration
+	 * @param {ClassDeclaration | MaybeNamedClassDeclaration} statement class declaration
 	 */
 	blockPreWalkClassDeclaration(statement) {
 		if (statement.id) {
@@ -2896,7 +2937,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {ClassDeclaration} statement class declaration
+	 * @param {ClassDeclaration | MaybeNamedClassDeclaration} statement class declaration
 	 */
 	walkClassDeclaration(statement) {
 		this.walkClass(statement);
@@ -2943,8 +2984,10 @@ class JavascriptParser extends Parser {
 				if (switchCase.test) {
 					this.walkExpression(switchCase.test);
 				}
+
 				if (switchCase.consequent.length > 0) {
 					this.walkStatements(switchCase.consequent);
+					this.scope.terminated = undefined;
 				}
 			}
 		});
@@ -3052,7 +3095,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {TODO} expression expression
+	 * @param {Expression | SpreadElement | PrivateIdentifier | Super} expression expression
 	 */
 	walkExpression(expression) {
 		switch (expression.type) {
@@ -3191,7 +3234,10 @@ class JavascriptParser extends Parser {
 			this.walkIdentifier(prop.value);
 			this.scope.inShorthand = false;
 		} else {
-			this.walkExpression(prop.value);
+			this.walkExpression(
+				/** @type {Exclude<Property["value"], AssignmentPattern | ObjectPattern | ArrayPattern | RestElement>} */
+				(prop.value)
+			);
 		}
 	}
 
@@ -3212,15 +3258,14 @@ class JavascriptParser extends Parser {
 			for (const param of expression.params) {
 				this.walkPattern(param);
 			}
-			if (expression.body.type === "BlockStatement") {
-				this.detectMode(expression.body.body);
-				const prev = this.prevStatement;
-				this.preWalkStatement(expression.body);
-				this.prevStatement = prev;
-				this.walkStatement(expression.body);
-			} else {
-				this.walkExpression(expression.body);
-			}
+
+			this.detectMode(expression.body.body);
+
+			const prev = this.prevStatement;
+
+			this.preWalkStatement(expression.body);
+			this.prevStatement = prev;
+			this.walkStatement(expression.body);
 		});
 		this.scope.topLevelScope = wasTopLevel;
 	}
@@ -3379,12 +3424,13 @@ class JavascriptParser extends Parser {
 			this.walkExpression(expression.right);
 			this.enterPattern(expression.left, (name, decl) => {
 				if (!this.callHooksForName(this.hooks.assign, name, expression)) {
-					this.walkExpression(expression.left);
+					this.walkExpression(
+						/** @type {MemberExpression} */
+						(expression.left)
+					);
 				}
 			});
-			return;
-		}
-		if (expression.left.type.endsWith("Pattern")) {
+		} else if (expression.left.type.endsWith("Pattern")) {
 			this.walkExpression(expression.right);
 			this.enterPattern(expression.left, (name, decl) => {
 				if (!this.callHooksForName(this.hooks.assign, name, expression)) {
@@ -3412,7 +3458,10 @@ class JavascriptParser extends Parser {
 			this.walkExpression(expression.left);
 		} else {
 			this.walkExpression(expression.right);
-			this.walkExpression(expression.left);
+			this.walkExpression(
+				/** @type {Exclude<AssignmentExpression["left"], Identifier | RestElement | MemberExpression | ObjectPattern | ArrayPattern | AssignmentPattern>} */
+				(expression.left)
+			);
 		}
 	}
 
@@ -3422,15 +3471,21 @@ class JavascriptParser extends Parser {
 	walkConditionalExpression(expression) {
 		const result = this.hooks.expressionConditionalOperator.call(expression);
 		if (result === undefined) {
-			this.walkExpression(expression.test);
-			this.walkExpression(expression.consequent);
-			if (expression.alternate) {
-				this.walkExpression(expression.alternate);
-			}
-		} else if (result) {
-			this.walkExpression(expression.consequent);
-		} else if (expression.alternate) {
-			this.walkExpression(expression.alternate);
+			this.inExecutedPath(false, () => {
+				this.walkExpression(expression.test);
+				this.walkExpression(expression.consequent);
+				if (expression.alternate) {
+					this.walkExpression(expression.alternate);
+				}
+			});
+		} else {
+			this.inExecutedPath(true, () => {
+				if (result) {
+					this.walkExpression(expression.consequent);
+				} else if (expression.alternate) {
+					this.walkExpression(expression.alternate);
+				}
+			});
 		}
 	}
 
@@ -3513,7 +3568,7 @@ class JavascriptParser extends Parser {
 	_walkIIFE(functionExpression, options, currentThis) {
 		/**
 		 * @param {Expression | SpreadElement} argOrThis arg or this
-		 * @returns {string | VariableInfoInterface | undefined} var info
+		 * @returns {string | VariableInfo | undefined} var info
 		 */
 		const getVarInfo = argOrThis => {
 			const renameIdentifier = this.getRenameIdentifier(argOrThis);
@@ -3603,13 +3658,13 @@ class JavascriptParser extends Parser {
 			expression.callee.type === "MemberExpression" &&
 			expression.callee.object.type.endsWith("FunctionExpression") &&
 			!expression.callee.computed &&
-			// eslint-disable-next-line no-warning-comments
-			// @ts-ignore
-			// TODO check me and handle more cases
-			(expression.callee.property.name === "call" ||
-				// eslint-disable-next-line no-warning-comments
-				// @ts-ignore
-				expression.callee.property.name === "bind") &&
+			/** @type {boolean} */
+			(
+				/** @type {Identifier} */
+				(expression.callee.property).name === "call" ||
+					/** @type {Identifier} */
+					(expression.callee.property).name === "bind"
+			) &&
 			expression.arguments.length > 0 &&
 			isSimpleFunction(
 				/** @type {FunctionExpression | ArrowFunctionExpression} */
@@ -3656,9 +3711,7 @@ class JavascriptParser extends Parser {
 					if (result === true) return;
 				}
 			}
-			const callee = this.evaluateExpression(
-				/** @type {TODO} */ (expression.callee)
-			);
+			const callee = this.evaluateExpression(expression.callee);
 			if (callee.isIdentifier()) {
 				const result1 = this.callHooksForInfo(
 					this.hooks.callMemberChain,
@@ -3764,11 +3817,12 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {TODO} expression member expression
+	 * @template R
+	 * @param {MemberExpression} expression member expression
 	 * @param {string} name name
 	 * @param {string | VariableInfo} rootInfo root info
 	 * @param {string[]} members members
-	 * @param {TODO} onUnhandled on unhandled callback
+	 * @param {() => R | undefined} onUnhandled on unhandled callback
 	 */
 	walkMemberExpressionWithExpressionName(
 		expression,
@@ -3781,7 +3835,9 @@ class JavascriptParser extends Parser {
 			// optimize the case where expression.object is a MemberExpression too.
 			// we can keep info here when calling walkMemberExpression directly
 			const property =
-				expression.property.name || `${expression.property.value}`;
+				/** @type {Identifier} */
+				(expression.property).name ||
+				`${/** @type {Literal} */ (expression.property).value}`;
 			name = name.slice(0, -property.length - 1);
 			members.pop();
 			const result = this.callHooksForInfo(
@@ -3847,8 +3903,8 @@ class JavascriptParser extends Parser {
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
 	 * @param {Expression | Super} expr expression info
-	 * @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 {((name: string, rootInfo: string | ScopeInfo | VariableInfo, getMembers: () => string[]) => TODO) | undefined} fallback callback when variable in 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
 	 */
@@ -3899,7 +3955,7 @@ class JavascriptParser extends Parser {
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks that should be called
 	 * @param {ExportedVariableInfo} info variable info
-	 * @param  {AsArray<T>} args args for the hook
+	 * @param {AsArray<T>} args args for the hook
 	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForInfo(hookMap, info, ...args) {
@@ -3917,8 +3973,8 @@ 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) | undefined} fallback callback when variable in not handled by hooks
-	 * @param {(function(string=): any) | undefined} defined callback when variable is defined
+	 * @param {((name: string) => TODO) | undefined} fallback callback when variable in not handled by hooks
+	 * @param {((result?: string) => TODO) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
 	 * @returns {R | undefined} result of hook
 	 */
@@ -3967,8 +4023,8 @@ 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) | undefined} fallback callback when variable in not handled by hooks
-	 * @param {(function(): any) | undefined} defined callback when variable is defined
+	 * @param {((value: string) => R | undefined) | undefined} fallback callback when variable in not handled by hooks
+	 * @param {(() => R) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
 	 * @returns {R | undefined} result of hook
 	 */
@@ -3984,8 +4040,8 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @deprecated
-	 * @param {any} params scope params
-	 * @param {function(): void} fn inner function
+	 * @param {(string | Pattern | Property)[]} params scope params
+	 * @param {() => void} fn inner function
 	 * @returns {void}
 	 */
 	inScope(params, fn) {
@@ -3997,6 +4053,8 @@ class JavascriptParser extends Parser {
 			inTaggedTemplateTag: false,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
+			inExecutedPath: false,
+			terminated: undefined,
 			definitions: oldScope.definitions.createChild()
 		};
 
@@ -4011,10 +4069,27 @@ class JavascriptParser extends Parser {
 		this.scope = oldScope;
 	}
 
+	/**
+	 * @param {boolean} state executed state
+	 * @param {() => void} fn inner function
+	 */
+	inExecutedPath(state, fn) {
+		const oldState = this.scope.inExecutedPath;
+		const oldTerminated = this.scope.terminated;
+		this.scope.inExecutedPath = state;
+
+		fn();
+
+		if (!state) {
+			this.scope.terminated = oldTerminated;
+		}
+		this.scope.inExecutedPath = oldState;
+	}
+
 	/**
 	 * @param {boolean} hasThis true, when this is defined
 	 * @param {Identifier[]} params scope params
-	 * @param {function(): void} fn inner function
+	 * @param {() => void} fn inner function
 	 * @returns {void}
 	 */
 	inClassScope(hasThis, params, fn) {
@@ -4024,8 +4099,10 @@ class JavascriptParser extends Parser {
 			inTry: false,
 			inShorthand: false,
 			inTaggedTemplateTag: false,
+			inExecutedPath: true,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
+			terminated: undefined,
 			definitions: oldScope.definitions.createChild()
 		};
 
@@ -4045,7 +4122,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * @param {boolean} hasThis true, when this is defined
 	 * @param {(Pattern | string)[]} params scope params
-	 * @param {function(): void} fn inner function
+	 * @param {() => void} fn inner function
 	 * @returns {void}
 	 */
 	inFunctionScope(hasThis, params, fn) {
@@ -4055,8 +4132,10 @@ class JavascriptParser extends Parser {
 			inTry: false,
 			inShorthand: false,
 			inTaggedTemplateTag: false,
+			inExecutedPath: true,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
+			terminated: undefined,
 			definitions: oldScope.definitions.createChild()
 		};
 
@@ -4074,23 +4153,35 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {function(): void} fn inner function
+	 * @param {() => void} fn inner function
+	 * @param {boolean} inExecutedPath executed state
 	 * @returns {void}
 	 */
-	inBlockScope(fn) {
+	inBlockScope(fn, inExecutedPath = false) {
 		const oldScope = this.scope;
 		this.scope = {
 			topLevelScope: oldScope.topLevelScope,
 			inTry: oldScope.inTry,
 			inShorthand: false,
 			inTaggedTemplateTag: false,
+			inExecutedPath,
 			isStrict: oldScope.isStrict,
 			isAsmJs: oldScope.isAsmJs,
+			terminated: oldScope.terminated,
 			definitions: oldScope.definitions.createChild()
 		};
 
 		fn();
 
+		const terminated = this.scope.terminated;
+
+		if (
+			inExecutedPath &&
+			((this.scope.inTry && terminated === "throw") || terminated === "return")
+		) {
+			oldScope.terminated = terminated;
+		}
+
 		this.scope = oldScope;
 	}
 
@@ -4228,7 +4319,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {Expression | SpreadElement | PrivateIdentifier} expression expression node
+	 * @param {Expression | SpreadElement | PrivateIdentifier | Super} expression expression node
 	 * @returns {BasicEvaluatedExpression} evaluation result
 	 */
 	evaluateExpression(expression) {
@@ -4242,6 +4333,7 @@ class JavascriptParser extends Parser {
 				}
 			}
 		} catch (err) {
+			// eslint-disable-next-line no-console
 			console.warn(err);
 			// ignore error
 		}
@@ -4274,7 +4366,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {Expression} expression expression
-	 * @returns {{ range?: Range, value: string, code: boolean, conditional: TODO }} result
+	 * @returns {{ range?: Range, value: string, code: boolean, conditional: boolean | TODO }} result
 	 */
 	parseCalculatedString(expression) {
 		switch (expression.type) {
@@ -4379,6 +4471,13 @@ class JavascriptParser extends Parser {
 		if (typeof source === "object") {
 			ast = /** @type {Program} */ (source);
 			comments = source.comments;
+			if (source.semicolons) {
+				// Forward semicolon information from the preparsed AST if present
+				// This ensures the output is consistent with that of a fresh AST
+				for (const pos of source.semicolons) {
+					semicolons.add(pos);
+				}
+			}
 		} else {
 			comments = [];
 			ast = JavascriptParser._parse(source, {
@@ -4399,12 +4498,13 @@ class JavascriptParser extends Parser {
 			inTry: false,
 			inShorthand: false,
 			inTaggedTemplateTag: false,
+			inExecutedPath: false,
 			isStrict: false,
 			isAsmJs: false,
+			terminated: undefined,
 			definitions: new StackedMap()
 		};
-		/** @type {ParserState} */
-		this.state = state;
+		this.state = /** @type {ParserState} */ (state);
 		this.comments = comments;
 		this.semicolons = semicolons;
 		this.statementPath = [];
@@ -4421,7 +4521,6 @@ class JavascriptParser extends Parser {
 		}
 		this.hooks.finish.call(ast, comments);
 		this.scope = oldScope;
-		/** @type {ParserState} */
 		this.state = oldState;
 		this.comments = oldComments;
 		this.semicolons = oldSemicolons;
@@ -4446,7 +4545,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {Expression | Declaration | PrivateIdentifier | null | undefined} expr an expression
+	 * @param {Expression | Declaration | PrivateIdentifier | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | null | undefined} expr an expression
 	 * @param {number} commentsStartPos source position from which annotation comments are checked
 	 * @returns {boolean} true, when the expression is pure
 	 */
@@ -4666,8 +4765,8 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {string} name name
-	 * @param {symbol} tag tag info
-	 * @returns {TODO} tag data
+	 * @param {Tag} tag tag info
+	 * @returns {TagData | undefined} tag data
 	 */
 	getTagData(name, tag) {
 		const info = this.scope.definitions.get(name);
@@ -4682,8 +4781,8 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {string} name name
-	 * @param {symbol} tag tag info
-	 * @param {TODO=} data data
+	 * @param {Tag} tag tag info
+	 * @param {TagData=} data data
 	 */
 	tagVariable(name, tag, data) {
 		const oldInfo = this.scope.definitions.get(name);
@@ -4784,7 +4883,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {Range} range range of the comment
-	 * @returns {{ options: Record<string, any> | null, errors: (Error & { comment: Comment })[] | null }} result
+	 * @returns {{ options: Record<string, EXPECTED_ANY> | null, errors: (Error & { comment: Comment })[] | null }} result
 	 */
 	parseCommentOptions(range) {
 		const comments = this.getComments(range);