webpack 5.112.0 → 5.112.1

package/lib/javascript/JavascriptParser.js

@@ -33,6 +33,7 @@ const {
 	positionAt
 } = require("./syntax-parser");
 
+/** @import { BuiltJavascriptModule } from "./JavascriptModule" */
 /** @import { EcmaVersion, ParserOptions, ParserPlugin } from "./syntax-parser" */
 /**
  * @import {
@@ -138,7 +139,7 @@ const {
  * @property {number=} lastHarmonyImportOrder deprecated, use `lastESMImportOrder`
  */
 
-/** @typedef {ParserState & KnownJavascriptParserState} JavascriptParserState */
+/** @typedef {ParserState<BuiltJavascriptModule> & KnownJavascriptParserState} JavascriptParserState */
 
 /** @import Compilation from "../Compilation" */
 /** @import Module from "../module/Module" */
@@ -181,6 +182,7 @@ const EMPTY_MODULE_DECLARATIONS = [];
 // object pattern, so a tap on that type is not served from the list.
 const BLOCK_DECLARATION_TYPES = new Set([
 	"VariableDeclaration",
+	"FunctionDeclaration",
 	"ClassDeclaration",
 	"ExportNamedDeclaration",
 	"ExportDefaultDeclaration"
@@ -387,7 +389,8 @@ class VariableInfo {
 /** @import { TopLevelSymbol } from "../optimize/InnerGraph" */
 
 /** @typedef {ESMSettings | ImportSettings | CommonJsImportSettings | TopLevelSymbol | CompatibilitySettings} KnownTagData */
-/** @typedef {KnownTagData | Record<string, EXPECTED_ANY>} TagData */
+// The open branch is whatever a plugin tags a variable with.
+/** @typedef {KnownTagData | EXPECTED_OBJECT} TagData */
 
 /**
  * Defines the tag info type used by this module.
@@ -1120,6 +1123,35 @@ const hoistedDeclarationsOf = (node, trusted) => {
 	return collectHoistedDeclarations(node.body, EMPTY_HOISTED_DECLARATIONS);
 };
 
+/**
+ * Whether a statement is one of the list's own, or the declaration of an
+ * `export` that is, rather than nested in one of them. It is found by its start
+ * offset since the list is in source order.
+ * @param {(Statement | ModuleDeclaration)[]} statements the list
+ * @param {Statement | ModuleDeclaration | MaybeNamedFunctionDeclaration} statement the statement to find
+ * @returns {boolean} whether the list holds it directly
+ */
+const holdsStatement = (statements, statement) => {
+	const start = /** @type {Range} */ (statement.range)[0];
+	let low = 0;
+	let high = statements.length - 1;
+	while (low <= high) {
+		const middle = (low + high) >>> 1;
+		const candidate = statements[middle];
+		if (candidate === statement) return true;
+		if (/** @type {Range} */ (candidate.range)[0] < start) low = middle + 1;
+		else high = middle - 1;
+	}
+	// the last statement starting before it is the one that could hold it
+	const holder = high >= 0 ? statements[high] : undefined;
+	return (
+		holder !== undefined &&
+		(holder.type === "ExportNamedDeclaration" ||
+			holder.type === "ExportDefaultDeclaration") &&
+		holder.declaration === statement
+	);
+};
+
 /**
  * Which statements of a list declare into its block scope, scanned for an AST
  * some other parser built. The parser's own record is read instead when there
@@ -1193,6 +1225,9 @@ const STRICT_MODE_OUTPUT_REASON =
 const MODULE_GOAL_OUTPUT_REASON =
 	'The output is an ES module, where "await" is a reserved word.';
 
+/**
+ * @extends {Parser<BuiltJavascriptModule>}
+ */
 class JavascriptParser extends Parser {
 	/**
 	 * Creates an instance of JavascriptParser.
@@ -1459,9 +1494,13 @@ class JavascriptParser extends Parser {
 		this.options = options;
 
 		/** @type {ScopeInfo} */
-		this.scope = /** @type {EXPECTED_ANY} */ (undefined);
+		this.scope = /** @type {ScopeInfo} */ (
+			/** @type {ScopeInfo | undefined} */ (undefined)
+		);
 		/** @type {JavascriptParserState} */
-		this.state = /** @type {EXPECTED_ANY} */ (undefined);
+		this.state = /** @type {JavascriptParserState} */ (
+			/** @type {JavascriptParserState | undefined} */ (undefined)
+		);
 		/** @type {Comment[] | undefined} */
 		this.comments = undefined;
 		// ASI overrides keyed by statement-end offset: true forces an ASI
@@ -1475,6 +1514,9 @@ class JavascriptParser extends Parser {
 		this.prevStatement = undefined;
 		/** @type {boolean} */
 		this._hasParserRecord = false;
+		// the statements of the scope last hoisted into, which its block pass reads next
+		/** @type {(Statement | ModuleDeclaration)[] | undefined} */
+		this._scopeStatements = undefined;
 		// BACKWARD-COMPAT START
 
 		// WHY: the hoisting pass reaches declarations alone, so a tap that
@@ -2720,6 +2762,7 @@ class JavascriptParser extends Parser {
 	 * @param {Program | BlockStatement} node the node owning the scope
 	 */
 	_preWalkScope(node) {
+		this._scopeStatements = node.body;
 		// BACKWARD-COMPAT START
 		if (this._needsFullPreWalk || this.hooks.preStatement.taps.length !== 0) {
 			if (node.type === "Program") this.preWalkStatements(node.body);
@@ -2747,6 +2790,25 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * Whether a function declaration stays in its block rather than hoisting to
+	 * the scope last pre-walked, which only sloppy-mode Annex B lets it do.
+	 * @param {FunctionDeclaration | MaybeNamedFunctionDeclaration} statement function declaration
+	 * @returns {boolean} whether its block, not the scope, binds it
+	 */
+	_isBlockScopedFunction(statement) {
+		const statements = this._scopeStatements;
+		// WHY: strictness is read here, not in the parser: `javascript/auto`
+		// reads a script as a strict module first.
+		return (
+			statements !== undefined &&
+			(this.scope.isStrict ||
+				statement.generator === true ||
+				statement.async === true) &&
+			!holdsStatement(statements, statement)
+		);
+	}
+
 	// BACKWARD-COMPAT START
 	/**
 	 * Walk every statement of a scope to declare what hoists to it. Only a tap
@@ -3032,8 +3094,18 @@ class JavascriptParser extends Parser {
 		let bail =
 			preStatement.taps.length !== 0 ? preStatement.call(statement) : undefined;
 		if (!bail) {
-			const typed = preStatementByType.get(statement.type);
-			if (typed !== undefined) bail = typed.call(statement);
+			// WHY: a block-scoped function is the block pass's; the full pre-walk
+			// still shows it to `preStatement`, but not to the typed hooks, which
+			// would declare it in the scope (`InnerGraphPlugin` tags it top-level).
+			if (
+				statement.type === "FunctionDeclaration" &&
+				this._isBlockScopedFunction(statement)
+			) {
+				bail = true;
+			} else {
+				const typed = preStatementByType.get(statement.type);
+				if (typed !== undefined) bail = typed.call(statement);
+			}
 		}
 		if (bail) {
 			this.prevStatement =
@@ -3123,6 +3195,9 @@ class JavascriptParser extends Parser {
 			case "ClassDeclaration":
 				this.blockPreWalkClassDeclaration(statement);
 				break;
+			case "FunctionDeclaration":
+				this.blockPreWalkFunctionDeclaration(statement);
+				break;
 			case "ExportNamedDeclaration":
 				this.blockPreWalkExportNamedDeclaration(statement);
 				break;
@@ -3569,6 +3644,17 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * Bind a function declaration in the block holding it, when it does not
+	 * hoist to the enclosing scope.
+	 * @param {FunctionDeclaration | MaybeNamedFunctionDeclaration} statement function declaration
+	 */
+	blockPreWalkFunctionDeclaration(statement) {
+		if (statement.id && this._isBlockScopedFunction(statement)) {
+			this.defineVariable(statement.id.name);
+		}
+	}
+
 	/**
 	 * Walk function declaration.
 	 * @param {FunctionDeclaration | MaybeNamedFunctionDeclaration} statement function declaration
@@ -4409,7 +4495,7 @@ class JavascriptParser extends Parser {
 	 * @param {Literal} expression literal
 	 */
 	_checkStrictModeLiteral(expression) {
-		const raw = /** @type {string | undefined} */ (expression.raw);
+		const raw = expression.raw;
 		if (raw === undefined) return;
 		if (typeof expression.value === "number") {
 			// Legacy octal (`0777`) or non-octal decimal (`08`) integer literal.
@@ -4666,7 +4752,7 @@ class JavascriptParser extends Parser {
 					this._walkPatternWriteMembers(
 						property.type === "RestElement"
 							? property.argument
-							: /** @type {Pattern} */ (property.value),
+							: property.value,
 						node
 					);
 				}
@@ -6316,7 +6402,7 @@ class JavascriptParser extends Parser {
 			terminated: undefined,
 			definitions: new StackedMap()
 		};
-		this.state = state;
+		this.state = /** @type {JavascriptParserState} */ (state);
 		this.comments = comments;
 		this.semicolons = undefined;
 		// evaluating a defined, untagged identifier can only fall through when
@@ -6703,7 +6789,9 @@ class JavascriptParser extends Parser {
 		}
 		const loc = node.loc;
 		if (!loc) {
-			return /** @type {DependencyLocation} */ (/** @type {unknown} */ (loc));
+			return /** @type {DependencyLocation} */ (
+				/** @type {DependencyLocation | null | undefined} */ (loc)
+			);
 		}
 		// a plain copy: a foreign parser's location class must not reach the cache
 		return {
@@ -7475,7 +7563,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * Whether a definition is a variable rather than a free name or a scope.
-	 * @param {unknown} value a scope definition
+	 * @param {ExportedVariableInfo | undefined} value a scope definition
 	 * @returns {value is VariableInfo} true when the value is a variable
 	 */
 	static isVariableInfo(value) {