webpack 5.108.4 → 5.109.1

package/lib/optimize/InnerGraphPlugin.js

@@ -80,6 +80,9 @@ class InnerGraphPlugin {
 					 * @param {Expression} sup sup
 					 */
 					const onUsageSuper = (sup) => {
+						// the callback fires after parsing, when the parser can no
+						// longer map offsets — take the location now
+						const loc = parser.getLocation(sup);
 						innerGraph.onUsage(parser.state, (usedByExports, module) => {
 							switch (usedByExports) {
 								case undefined:
@@ -90,7 +93,7 @@ class InnerGraphPlugin {
 										/** @type {Range} */
 										(sup.range)
 									);
-									dep.loc = /** @type {DependencyLocation} */ (sup.loc);
+									dep.loc = loc;
 									dep.usedByExports = usedByExports;
 									addPureDependency(module, dep);
 									break;
@@ -205,30 +208,36 @@ class InnerGraphPlugin {
 
 					// The following hooks are used during prewalking:
 
-					parser.hooks.preStatement.tap(PLUGIN_NAME, (statement) => {
-						if (!innerGraph.isEnabled(parser.state)) return;
+					parser.hooks.preStatementByType
+						.for("FunctionDeclaration")
+						.tap(PLUGIN_NAME, (statement) => {
+							if (!innerGraph.isEnabled(parser.state)) return;
 
-						if (
-							parser.scope.topLevelScope === true &&
-							statement.type === "FunctionDeclaration"
-						) {
-							const name = statement.id ? statement.id.name : "*default*";
-							const symbol = /** @type {TopLevelSymbol} */ (
-								innerGraph.tagTopLevelSymbol(
-									parser,
-									name,
-									parser.isPure(
-										statement,
-										/** @type {Range} */ (statement.range)[0]
+							if (
+								parser.scope.topLevelScope === true &&
+								statement.type === "FunctionDeclaration"
+							) {
+								const name = statement.id ? statement.id.name : "*default*";
+								const symbol = /** @type {TopLevelSymbol} */ (
+									innerGraph.tagTopLevelSymbol(
+										parser,
+										name,
+										parser.isPure(
+											statement,
+											/** @type {Range} */ (statement.range)[0]
+										)
 									)
-								)
-							);
-							statementWithTopLevelSymbol.set(statement, symbol);
-							return true;
-						}
-					});
+								);
+								statementWithTopLevelSymbol.set(statement, symbol);
+								return true;
+							}
+						});
 
-					parser.hooks.blockPreStatement.tap(PLUGIN_NAME, (statement) => {
+					/**
+					 * @param {import("estree").Statement | import("estree").ModuleDeclaration | import("estree").MaybeNamedFunctionDeclaration | import("estree").MaybeNamedClassDeclaration} statement statement
+					 * @returns {boolean | void} true when handled
+					 */
+					const blockPreStatementHandler = (statement) => {
 						if (!innerGraph.isEnabled(parser.state)) return;
 
 						if (parser.scope.topLevelScope === true) {
@@ -288,7 +297,13 @@ class InnerGraphPlugin {
 								}
 							}
 						}
-					});
+					};
+					parser.hooks.blockPreStatementByType
+						.for("ClassDeclaration")
+						.tap(PLUGIN_NAME, blockPreStatementHandler);
+					parser.hooks.blockPreStatementByType
+						.for("ExportDefaultDeclaration")
+						.tap(PLUGIN_NAME, blockPreStatementHandler);
 
 					parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, statement) => {
 						if (!innerGraph.isEnabled(parser.state)) return;
@@ -363,6 +378,9 @@ class InnerGraphPlugin {
 								innerGraph.setTopLevelSymbol(parser.state, symbol);
 								const purePart = statementPurePart.get(statement);
 								if (purePart) {
+									// the callback fires after parsing, when the parser can no
+									// longer map offsets — take the location now
+									const loc = parser.getLocation(statement);
 									innerGraph.onUsage(parser.state, (usedByExports, module) => {
 										switch (usedByExports) {
 											case undefined:
@@ -372,9 +390,7 @@ class InnerGraphPlugin {
 												const dep = new PureExpressionDependency(
 													/** @type {Range} */ (purePart.range)
 												);
-												dep.loc =
-													/** @type {DependencyLocation} */
-													(statement.loc);
+												dep.loc = loc;
 												dep.usedByExports = usedByExports;
 												addPureDependency(module, dep);
 												break;
@@ -439,6 +455,9 @@ class InnerGraphPlugin {
 									) {
 										innerGraph.setTopLevelSymbol(parser.state, symbol);
 										if (element.type !== "MethodDefinition" && element.static) {
+											// the callback fires after parsing, when the parser can
+											// no longer map offsets — take the location now
+											const loc = parser.getLocation(expression);
 											innerGraph.onUsage(
 												parser.state,
 												(usedByExports, module) => {
@@ -450,9 +469,7 @@ class InnerGraphPlugin {
 															const dep = new PureExpressionDependency(
 																/** @type {Range} */ (expression.range)
 															);
-															dep.loc =
-																/** @type {DependencyLocation} */
-																(expression.loc);
+															dep.loc = loc;
 															dep.usedByExports = usedByExports;
 															addPureDependency(module, dep);
 															break;
@@ -484,6 +501,9 @@ class InnerGraphPlugin {
 										onUsageSuper(decl.init.superClass);
 									}
 								} else {
+									// the callback fires after parsing, when the parser can no
+									// longer map offsets — take the location now
+									const loc = parser.getLocation(decl);
 									innerGraph.onUsage(parser.state, (usedByExports, module) => {
 										switch (usedByExports) {
 											case undefined:
@@ -496,7 +516,7 @@ class InnerGraphPlugin {
 														(decl.init).range
 													)
 												);
-												dep.loc = /** @type {DependencyLocation} */ (decl.loc);
+												dep.loc = loc;
 												dep.usedByExports = usedByExports;
 												addPureDependency(module, dep);
 												break;

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -12,6 +12,9 @@ const Module = require("../Module");
 const ModuleGraph = require("../ModuleGraph");
 const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
 const { STAGE_DEFAULT } = require("../OptimizationStages");
+const CommonJsSelfReferenceDependency = require("../dependencies/CommonJsSelfReferenceDependency");
+const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
+const { ImportPhaseUtils } = require("../dependencies/ImportPhase");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const {
 	filterRuntime,
@@ -26,6 +29,7 @@ const ConcatenatedModule = require("./ConcatenatedModule");
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
@@ -66,6 +70,23 @@ const getMergedModuleRuntime = (chunkGraph, cache, module) => {
  * @property {number} added
  */
 
+/**
+ * Record why `module` can't be added (so retried lookups hit the cache), bump
+ * the matching statistic, and return the problem to bubble up the recursion.
+ * Only reached on failure, so it stays off the hot success path.
+ * @param {Map<Module, Problem>} failureCache per-module failure cache
+ * @param {Statistics} statistics running statistics
+ * @param {keyof Statistics} statKey statistic to increment
+ * @param {Module} module the module that couldn't be added
+ * @param {Problem} problem the failure to cache and return
+ * @returns {Problem} the same problem
+ */
+const cacheFailure = (failureCache, statistics, statKey, module, problem) => {
+	statistics[statKey]++;
+	failureCache.set(module, problem);
+	return problem;
+};
+
 /**
  * Format bailout reason.
  * @param {string} msg message
@@ -176,9 +197,16 @@ class ModuleConcatenationPlugin {
 					const relevantModules = [];
 					/** @type {Set<Module>} */
 					const possibleInners = new Set();
+					const concatenateModules =
+						compilation.options.optimization.concatenateModules;
 					const context = {
 						chunkGraph,
-						moduleGraph
+						moduleGraph,
+						// commonjs concatenation defaults to on; { commonjs: false } opts out
+						concatenateCommonJsModules:
+							typeof concatenateModules === "object"
+								? concatenateModules.commonjs !== false
+								: concatenateModules === true
 					};
 					const deferEnabled = compilation.options.experiments.deferImport;
 					logger.time("select relevant modules");
@@ -197,7 +225,6 @@ class ModuleConcatenationPlugin {
 							setBailoutReason(module, "Module is async");
 							continue;
 						}
-
 						// Must be in strict mode
 						if (!(/** @type {BuildInfo} */ (module.buildInfo).strict)) {
 							setBailoutReason(module, "Module is not in strict mode");
@@ -255,6 +282,16 @@ class ModuleConcatenationPlugin {
 							canBeRoot = false;
 						}
 
+						// A concatenated CommonJS module relies on the root's ESM export
+						// rendering, so it can only be an inner module
+						if (
+							module.type.startsWith("javascript/") &&
+							/** @type {BuildMeta} */
+							(module.buildMeta).exportsType !== "namespace"
+						) {
+							canBeRoot = false;
+						}
+
 						// Module must not be an entry point
 						if (chunkGraph.isEntryModule(module)) {
 							setInnerBailoutReason(module, "Module is an entry point");
@@ -561,6 +598,26 @@ class ModuleConcatenationPlugin {
 		});
 	}
 
+	/**
+	 * Checks whether the module `import defer`s a module already in the config.
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {Module} module the candidate module
+	 * @param {ConcatConfiguration} config the concat configuration
+	 * @returns {boolean} true when a deferred import targets a module in the config
+	 */
+	_defersModuleIn(moduleGraph, module, config) {
+		for (const dep of module.dependencies) {
+			if (
+				dep instanceof HarmonyImportDependency &&
+				ImportPhaseUtils.isDefer(dep.phase)
+			) {
+				const target = moduleGraph.getModule(dep);
+				if (target && config.has(target)) return true;
+			}
+		}
+		return false;
+	}
+
 	/**
 	 * Returns the imported modules.
 	 * @param {Compilation} compilation the compilation
@@ -647,9 +704,37 @@ class ModuleConcatenationPlugin {
 
 		// Not possible to add?
 		if (!possibleModules.has(module)) {
-			statistics.invalidModule++;
-			failureCache.set(module, module); // cache failures for performance
-			return module;
+			return cacheFailure(
+				failureCache,
+				statistics,
+				"invalidModule",
+				module,
+				module
+			);
+		}
+
+		// A deferred import must stay a concatenation boundary: concatenating a
+		// module with a module it `import defer`s (a cycle) would erase the
+		// deferred namespace's lazy-evaluation and exotic-object semantics.
+		if (
+			compilation.options.experiments.deferImport &&
+			this._defersModuleIn(compilation.moduleGraph, module, config)
+		) {
+			/**
+			 * @param {RequestShortener} requestShortener request shortener
+			 * @returns {string} problem description
+			 */
+			const problem = (requestShortener) =>
+				`Module ${module.readableIdentifier(
+					requestShortener
+				)} imports a module in this configuration via import defer`;
+			return cacheFailure(
+				failureCache,
+				statistics,
+				"incorrectDependency",
+				module,
+				problem
+			);
 		}
 
 		// Module must be in the correct chunks
@@ -681,9 +766,13 @@ class ModuleConcatenationPlugin {
 					", "
 				)}, module is in chunk(s) ${chunks.join(", ")})`;
 			};
-			statistics.incorrectChunks++;
-			failureCache.set(module, problem); // cache failures for performance
-			return problem;
+			return cacheFailure(
+				failureCache,
+				statistics,
+				"incorrectChunks",
+				module,
+				problem
+			);
 		}
 
 		const moduleGraph = compilation.moduleGraph;
@@ -722,9 +811,13 @@ class ModuleConcatenationPlugin {
 							: "in an unsupported way"
 					}`;
 				};
-				statistics.incorrectDependency++;
-				failureCache.set(module, problem); // cache failures for performance
-				return problem;
+				return cacheFailure(
+					failureCache,
+					statistics,
+					"incorrectDependency",
+					module,
+					problem
+				);
 			}
 		}
 
@@ -781,9 +874,13 @@ class ModuleConcatenationPlugin {
 					", "
 				)}`;
 			};
-			statistics.incorrectChunksOfImporter++;
-			failureCache.set(module, problem); // cache failures for performance
-			return problem;
+			return cacheFailure(
+				failureCache,
+				statistics,
+				"incorrectChunksOfImporter",
+				module,
+				problem
+			);
 		}
 
 		/** @type {Map<Module, ReadonlyArray<ModuleGraph.ModuleGraphConnection>>} */
@@ -792,7 +889,13 @@ class ModuleConcatenationPlugin {
 			const selected = connections.filter(
 				(connection) =>
 					!connection.dependency ||
-					!Dependency.canConcatenate(connection.dependency)
+					(!Dependency.canConcatenate(connection.dependency) &&
+						// exports self-references of a concatenated CommonJS module
+						// are rewritten in place, so they don't block concatenation
+						!(
+							originModule === module &&
+							connection.dependency instanceof CommonJsSelfReferenceDependency
+						))
 			);
 			if (selected.length > 0) {
 				nonHarmonyConnections.set(originModule, connections);
@@ -827,9 +930,13 @@ class ModuleConcatenationPlugin {
 					", "
 				)}`;
 			};
-			statistics.incorrectModuleDependency++;
-			failureCache.set(module, problem); // cache failures for performance
-			return problem;
+			return cacheFailure(
+				failureCache,
+				statistics,
+				"incorrectModuleDependency",
+				module,
+				problem
+			);
 		}
 
 		if (runtime !== undefined && typeof runtime !== "string") {
@@ -880,9 +987,13 @@ class ModuleConcatenationPlugin {
 								/** @type {RuntimeSpec} */ (runtimeCondition)
 							)})`
 					).join(", ")}`;
-				statistics.incorrectRuntimeCondition++;
-				failureCache.set(module, problem); // cache failures for performance
-				return problem;
+				return cacheFailure(
+					failureCache,
+					statistics,
+					"incorrectRuntimeCondition",
+					module,
+					problem
+				);
 			}
 		}
 
@@ -915,9 +1026,13 @@ class ModuleConcatenationPlugin {
 			);
 			if (problem) {
 				if (backup !== undefined) config.rollback(backup);
-				statistics.importerFailed++;
-				failureCache.set(module, problem); // cache failures for performance
-				return problem;
+				return cacheFailure(
+					failureCache,
+					statistics,
+					"importerFailed",
+					module,
+					problem
+				);
 			}
 		}
 

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -13,7 +13,9 @@ const {
 } = require("../ModuleTypeConstants");
 const { STAGE_DEFAULT } = require("../OptimizationStages");
 const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
+const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
 const HarmonyImportSpecifierDependency = require("../dependencies/HarmonyImportSpecifierDependency");
+const { ImportPhaseUtils } = require("../dependencies/ImportPhase");
 const formatLocation = require("../util/formatLocation");
 const { CompilerHintNotationRegExp } = require("../util/magicComment");
 
@@ -48,6 +50,20 @@ const { CompilerHintNotationRegExp } = require("../util/magicComment");
 
 /** @typedef {Map<string, RegExp>} CacheItem */
 
+/**
+ * Whether a resolved re-export target is reached through an `import defer` edge.
+ * Such edges must not be collapsed by the side-effect-free barrel optimization:
+ * the source module has to keep being reached through the barrel's cached
+ * deferred namespace so deferred-namespace identity and evaluation semantics are
+ * preserved.
+ * @param {ModuleGraphConnection | undefined} connection the target connection
+ * @returns {boolean} true when the target connection is a deferred import
+ */
+const isDeferredTargetConnection = (connection) =>
+	connection !== undefined &&
+	connection.dependency instanceof HarmonyImportDependency &&
+	ImportPhaseUtils.isDefer(connection.dependency.phase);
+
 /** @type {WeakMap<Compiler, CacheItem>} */
 const globToRegexpCache = new WeakMap();
 
@@ -305,13 +321,14 @@ class SideEffectsFlagPlugin {
 								/** @type {BuildMeta} */
 								(parser.state.module.buildMeta).sideEffectFree = true;
 							} else {
-								const { loc, type } = sideEffectsStatement;
+								const type = sideEffectsStatement.type;
+								const loc = parser.getLocation(sideEffectsStatement);
 								moduleGraph
 									.getOptimizationBailout(parser.state.module)
 									.push(
 										() =>
 											`Statement (${type}) with side effects in source code at ${formatLocation(
-												/** @type {DependencyLocation} */ (loc)
+												loc
 											)}`
 									);
 							}
@@ -354,32 +371,34 @@ class SideEffectsFlagPlugin {
 						//  2. export function foo
 						//  3. export default function foo
 						// 	4. export default function / export default () => {} (anonymous)
-						parser.hooks.preStatement.tap(PLUGIN_NAME, (statement) => {
-							if (parser.scope.topLevelScope !== true) return;
-							if (statement.type !== "FunctionDeclaration") {
-								return;
-							}
-							const name = statement.id ? statement.id.name : "default";
-							if (
-								pureFunctionsFromOption &&
-								pureFunctionsFromOption.has(name)
-							) {
-								markPure(name);
-								return;
-							}
-							const commentsStart = parser.prevStatement
-								? /** @type {Range} */ (parser.prevStatement.range)[1]
-								: 0;
-							if (
-								hasNoSideEffectsNotation(
-									parser,
-									commentsStart,
-									/** @type {Range} */ (statement.range)[0]
-								)
-							) {
-								markPure(name);
-							}
-						});
+						parser.hooks.preStatementByType
+							.for("FunctionDeclaration")
+							.tap(PLUGIN_NAME, (statement) => {
+								if (parser.scope.topLevelScope !== true) return;
+								if (statement.type !== "FunctionDeclaration") {
+									return;
+								}
+								const name = statement.id ? statement.id.name : "default";
+								if (
+									pureFunctionsFromOption &&
+									pureFunctionsFromOption.has(name)
+								) {
+									markPure(name);
+									return;
+								}
+								const commentsStart = parser.prevStatement
+									? /** @type {Range} */ (parser.prevStatement.range)[1]
+									: 0;
+								if (
+									hasNoSideEffectsNotation(
+										parser,
+										commentsStart,
+										/** @type {Range} */ (statement.range)[0]
+									)
+								) {
+									markPure(name);
+								}
+							});
 
 						// Detect on variable declarations with function init
 						parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, statement) => {
@@ -421,21 +440,23 @@ class SideEffectsFlagPlugin {
 						});
 
 						if (pureFunctionsFromOption) {
-							parser.hooks.blockPreStatement.tap(PLUGIN_NAME, (statement) => {
-								if (parser.scope.topLevelScope !== true) return;
-								if (
-									statement.type === "ExportDefaultDeclaration" &&
-									pureFunctionsFromOption.has("default")
-								) {
-									const decl = statement.declaration;
+							parser.hooks.blockPreStatementByType
+								.for("ExportDefaultDeclaration")
+								.tap(PLUGIN_NAME, (statement) => {
+									if (parser.scope.topLevelScope !== true) return;
 									if (
-										decl.type === "ArrowFunctionExpression" ||
-										decl.type === "FunctionExpression"
+										statement.type === "ExportDefaultDeclaration" &&
+										pureFunctionsFromOption.has("default")
 									) {
-										markPure("default");
+										const decl = statement.declaration;
+										if (
+											decl.type === "ArrowFunctionExpression" ||
+											decl.type === "FunctionExpression"
+										) {
+											markPure("default");
+										}
 									}
-								}
-							});
+								});
 						}
 
 						parser.hooks.isPure
@@ -500,6 +521,11 @@ class SideEffectsFlagPlugin {
 						/** @type {Set<Module>} */
 						const optimizedModules = new Set();
 
+						// Only defer builds must protect deferred re-export barrels;
+						// skip the per-target check entirely otherwise.
+						const deferEnabled =
+							compilation.options.experiments.deferImport === true;
+
 						// Re-export resolution is idempotent within a pass, so cache it
 						// per export info: a shared barrel imported by many modules
 						// resolves each name once instead of once per consumer.
@@ -581,13 +607,18 @@ class SideEffectsFlagPlugin {
 
 												exportInfo.moveTarget(
 													moduleGraph,
-													({ module }) =>
-														module.getSideEffectsConnectionState(
+													(candidate) =>
+														candidate.module.getSideEffectsConnectionState(
 															moduleGraph
 														) === false &&
+														// Keep a deferred re-export's barrel (see below).
+														(!deferEnabled ||
+															!isDeferredTargetConnection(
+																candidate.connection
+															)) &&
 														(Boolean(dep.name) ||
 															hasSingleStarReexport(
-																/** @type {Module} */ (module)
+																/** @type {Module} */ (candidate.module)
 															)),
 													({
 														module: newModule,
@@ -639,6 +670,18 @@ class SideEffectsFlagPlugin {
 											}
 											if (!target) continue;
 
+											// A deferred re-export must keep its side-effect-free
+											// barrel: collapsing it here would turn the cached
+											// deferred namespace (`.z`) into an eager import of the
+											// source module, breaking deferred-namespace identity
+											// and evaluation semantics.
+											if (
+												deferEnabled &&
+												isDeferredTargetConnection(target.connection)
+											) {
+												continue;
+											}
+
 											moduleGraph.updateModule(dep, target.module);
 											moduleGraph.updateParent(
 												dep,