webpack 5.107.2 → 5.108.0

package/lib/javascript/JavascriptModulesPlugin.js

@@ -42,10 +42,11 @@ const {
 	getUsedNamesInScopeInfo
 } = require("../util/concatenate");
 const createHash = require("../util/createHash");
-const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
+const { digestNonNumericOnlyWithFull } = require("../util/nonNumericOnlyHash");
 const removeBOM = require("../util/removeBOM");
 const { intersectRuntime } = require("../util/runtime");
 const JavascriptGenerator = require("./JavascriptGenerator");
+const JavascriptModule = require("./JavascriptModule");
 const JavascriptParser = require("./JavascriptParser");
 
 /** @typedef {import("estree").Program} Program */
@@ -347,6 +348,75 @@ const printGeneratedCodeForStack = (module, code) => {
 /** @type {WeakMap<Compilation, CompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
+/**
+ * Renames an inlined module's top-level declaration (and all its references) when
+ * its name is already taken in the shared startup scope, recording the chosen name
+ * in `allUsedNames`. Lets inlined modules be emitted without a per-entry/per-chunk
+ * IIFE by resolving name collisions instead of isolating each module.
+ * @param {InstanceType<typeof import("webpack-sources").ReplaceSource>} source the module source to edit
+ * @param {Program} ast the parsed module AST
+ * @param {Variable} variable the top-level variable to check/rename
+ * @param {string} moduleIdentifier the module identifier (for scope caching)
+ * @param {string} readableIdentifier the readable module identifier (for new names)
+ * @param {Set<string>} allUsedNames names already used in the shared scope (mutated)
+ * @returns {void}
+ */
+const renameInlinedModuleVariable = (
+	source,
+	ast,
+	variable,
+	moduleIdentifier,
+	readableIdentifier,
+	allUsedNames
+) => {
+	/** @type {UsedNamesInScopeInfo} */
+	const usedNamesInScopeInfo = new Map();
+	/** @type {ScopeSet} */
+	const ignoredScopes = new Set();
+
+	const name = variable.name;
+	const { usedNames, alreadyCheckedScopes } = getUsedNamesInScopeInfo(
+		usedNamesInScopeInfo,
+		moduleIdentifier,
+		name
+	);
+
+	if (allUsedNames.has(name) || usedNames.has(name)) {
+		const references = getAllReferences(variable);
+		const allIdentifiers = new Set([
+			...references.map((r) => r.identifier),
+			...variable.identifiers
+		]);
+		for (const ref of references) {
+			addScopeSymbols(ref.from, usedNames, alreadyCheckedScopes, ignoredScopes);
+		}
+
+		const newName = findNewName(
+			name,
+			allUsedNames,
+			usedNames,
+			readableIdentifier
+		);
+		allUsedNames.add(newName);
+		for (const identifier of allIdentifiers) {
+			const r = /** @type {Range} */ (identifier.range);
+			const path = getPathInAst(ast, identifier);
+			if (path && path.length > 1) {
+				const maybeProperty =
+					path[1].type === "AssignmentPattern" && path[1].left === path[0]
+						? path[2]
+						: path[1];
+				if (maybeProperty.type === "Property" && maybeProperty.shorthand) {
+					source.insert(r[1], `: ${newName}`);
+					continue;
+				}
+			}
+			source.replace(r[0], r[1] - 1, newName);
+		}
+	}
+	allUsedNames.add(name);
+};
+
 const PLUGIN_NAME = "JavascriptModulesPlugin";
 
 /** @typedef {{ header: string[], beforeStartup: string[], startup: string[], afterStartup: string[], allowInlineStartup: boolean }} Bootstrap */
@@ -424,6 +494,12 @@ class JavascriptModulesPlugin {
 					JAVASCRIPT_MODULE_TYPE_DYNAMIC,
 					JAVASCRIPT_MODULE_TYPE_ESM
 				]) {
+					normalModuleFactory.hooks.createModuleClass
+						.for(type)
+						.tap(
+							PLUGIN_NAME,
+							(createData, _resolveData) => new JavascriptModule(createData)
+						);
 					normalModuleFactory.hooks.createParser
 						.for(type)
 						.tap(PLUGIN_NAME, (options) => {
@@ -641,11 +717,8 @@ class JavascriptModulesPlugin {
 						}
 						xor.updateHash(hash);
 					}
-					const digest = hash.digest(hashDigest);
-					chunk.contentHash.javascript = nonNumericOnlyHash(
-						digest,
-						hashDigestLength
-					);
+					[chunk.contentHash.javascript, chunk.contentHashFull.javascript] =
+						digestNonNumericOnlyWithFull(hash, hashDigest, hashDigestLength);
 				});
 				compilation.hooks.additionalTreeRuntimeRequirements.tap(
 					PLUGIN_NAME,
@@ -739,6 +812,12 @@ class JavascriptModulesPlugin {
 			return chunk.filenameTemplate;
 		} else if (chunk instanceof HotUpdateChunk) {
 			return outputOptions.hotUpdateChunkFilename;
+		}
+		const entryOptions = chunk.getEntryOptions();
+		// A worker entry (`new Worker` or `entry.worker`) uses workerChunkFilename;
+		// chunks it loads internally keep `chunkFilename`
+		if (entryOptions !== undefined && entryOptions.worker) {
+			return outputOptions.workerChunkFilename;
 		} else if (chunk.canBeInitial()) {
 			return outputOptions.filename;
 		}
@@ -1143,10 +1222,8 @@ class JavascriptModulesPlugin {
 
 				const iife = innerStrict
 					? "it needs to be in strict mode."
-					: inlinedModules.size > 1
-						? // TODO check globals and top-level declarations of other entries and chunk modules
-							// to make a better decision
-							"it needs to be isolated against other entry modules."
+					: inlinedModules.size > 1 && !renamedInlinedModule
+						? "it needs to be isolated against other entry modules."
 						: chunkModules && !renamedInlinedModule
 							? "it needs to be isolated against other modules in the chunk."
 							: exports && !webpackExports
@@ -1190,10 +1267,12 @@ class JavascriptModulesPlugin {
 					}
 					if (exports) {
 						if (m !== lastInlinedModule) {
-							startupSource.add(`var ${m.exportsArgument} = {};\n`);
+							startupSource.add(
+								`${runtimeTemplate.renderLet()} ${m.exportsArgument} = {};\n`
+							);
 						} else if (m.exportsArgument !== RuntimeGlobals.exports) {
 							startupSource.add(
-								`var ${m.exportsArgument} = ${RuntimeGlobals.exports};\n`
+								`${runtimeTemplate.renderLet()} ${m.exportsArgument} = ${RuntimeGlobals.exports};\n`
 							);
 						}
 					}
@@ -1236,7 +1315,7 @@ class JavascriptModulesPlugin {
 			}
 			if (startupRenderContext.needExportsDeclaration) {
 				renderedStartup = new ConcatSource(
-					`var ${RuntimeGlobals.exports} = {};\n`,
+					`${runtimeTemplate.renderLet()} ${RuntimeGlobals.exports} = {};\n`,
 					renderedStartup
 				);
 			}
@@ -1414,9 +1493,10 @@ class JavascriptModulesPlugin {
 			result.allowInlineStartup = false;
 		}
 
+		const bootstrapCst = runtimeTemplate.renderConst();
 		if (useRequire || moduleCache) {
 			buf.push("// The module cache");
-			buf.push("var __webpack_module_cache__ = {};");
+			buf.push(`${bootstrapCst} __webpack_module_cache__ = {};`);
 			buf.push("");
 		}
 
@@ -1426,14 +1506,16 @@ class JavascriptModulesPlugin {
 			// This requires all deferred imports to a module can get the module export object before the module
 			// is evaluated.
 			buf.push("// The deferred module cache");
-			buf.push("var __webpack_module_deferred_exports__ = {};");
+			buf.push(`${bootstrapCst} __webpack_module_deferred_exports__ = {};`);
 			// Per the TC39 import-defer spec, every defer-import call site for
 			// the same module must yield the same Deferred Module Namespace
 			// Exotic Object (and a distinct one from any eager namespace).
 			// Cache the deferred namespace proxy here so calls from different
 			// files share identity.
 			buf.push("// The deferred namespace cache");
-			buf.push("var __webpack_module_deferred_namespace_cache__ = {};");
+			buf.push(
+				`${bootstrapCst} __webpack_module_deferred_namespace_cache__ = {};`
+			);
 			buf.push("");
 		}
 
@@ -1445,7 +1527,7 @@ class JavascriptModulesPlugin {
 			buf.push("");
 		} else if (runtimeRequirements.has(RuntimeGlobals.requireScope)) {
 			buf.push("// The require scope");
-			buf.push(`var ${RuntimeGlobals.require} = {};`);
+			buf.push(`${bootstrapCst} ${RuntimeGlobals.require} = {};`);
 			buf.push("");
 		}
 
@@ -1581,9 +1663,17 @@ class JavascriptModulesPlugin {
 						result.allowInlineStartup = false;
 					}
 
+					// `__webpack_exports__` may be reassigned later — by the
+					// `onChunksLoaded` wrapper below, by an inlined entry
+					// module that uses top-level `await` (the emitted
+					// bridge reassigns `__webpack_exports__` to the awaited
+					// value), or by other downstream codegen. Always declare
+					// with `let` (or `var` if `let` is unsupported) so
+					// reassignment is allowed.
+					const exportsDecl = runtimeTemplate.renderLet();
 					if (chunks.length > 0) {
 						buf2.push(
-							`${i === 0 ? `var ${RuntimeGlobals.exports} = ` : ""}${
+							`${i === 0 ? `${exportsDecl} ${RuntimeGlobals.exports} = ` : ""}${
 								RuntimeGlobals.onChunksLoaded
 							}(undefined, ${JSON.stringify(
 								chunks.map((c) => c.id)
@@ -1593,12 +1683,14 @@ class JavascriptModulesPlugin {
 						);
 					} else if (useRequire) {
 						buf2.push(
-							`${i === 0 ? `var ${RuntimeGlobals.exports} = ` : ""}${
+							`${i === 0 ? `${exportsDecl} ${RuntimeGlobals.exports} = ` : ""}${
 								RuntimeGlobals.require
 							}(${moduleIdExpr});`
 						);
 					} else {
-						if (i === 0) buf2.push(`var ${RuntimeGlobals.exports} = {};`);
+						if (i === 0) {
+							buf2.push(`${exportsDecl} ${RuntimeGlobals.exports} = {};`);
+						}
 						const needThisAsExports = entryRuntimeRequirements.has(
 							RuntimeGlobals.thisAsExports
 						);
@@ -1711,11 +1803,10 @@ class JavascriptModulesPlugin {
 	 * @returns {string} the generated source of the require function
 	 */
 	renderRequire(renderContext, hooks) {
-		const {
-			chunk,
-			chunkGraph,
-			runtimeTemplate: { outputOptions }
-		} = renderContext;
+		const { chunk, chunkGraph, runtimeTemplate } = renderContext;
+		const { outputOptions } = runtimeTemplate;
+		const cst = runtimeTemplate.renderConst();
+		const lt = runtimeTemplate.renderLet();
 		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
 
 		/**
@@ -1724,12 +1815,12 @@ class JavascriptModulesPlugin {
 		 * @returns {string[]} source
 		 */
 		const renderMissingModuleError = (condition) =>
-			outputOptions.pathinfo
+			outputOptions.strictModuleResolution
 				? [
 						`if (${condition}) {`,
 						Template.indent([
 							"delete __webpack_module_cache__[moduleId];",
-							'var e = new Error("Cannot find module \'" + moduleId + "\'");',
+							`${cst} e = new Error("Cannot find module '" + moduleId + "'");`,
 							"e.code = 'MODULE_NOT_FOUND';",
 							"throw e;"
 						]),
@@ -1741,7 +1832,7 @@ class JavascriptModulesPlugin {
 			RuntimeGlobals.interceptModuleExecution
 		)
 			? Template.asString([
-					`var execOptions = { id: moduleId, module: module, factory: __webpack_modules__[moduleId], require: ${RuntimeGlobals.require} };`,
+					`${cst} execOptions = { id: moduleId, module: module, factory: __webpack_modules__[moduleId], require: ${RuntimeGlobals.require} };`,
 					`${RuntimeGlobals.interceptModuleExecution}.forEach(function(handler) { handler(execOptions); });`,
 					...renderMissingModuleError("!execOptions.factory"),
 					"module = execOptions.module;",
@@ -1763,9 +1854,15 @@ class JavascriptModulesPlugin {
 		const needModuleDefer = runtimeRequirements.has(
 			RuntimeGlobals.makeDeferredNamespaceObject
 		);
+		// `module` is reassigned by the interceptModuleExecution path; use `let`.
+		const moduleDecl = runtimeRequirements.has(
+			RuntimeGlobals.interceptModuleExecution
+		)
+			? lt
+			: cst;
 		const content = Template.asString([
 			"// Check if module is in cache",
-			"var cachedModule = __webpack_module_cache__[moduleId];",
+			`${cst} cachedModule = __webpack_module_cache__[moduleId];`,
 			"if (cachedModule !== undefined) {",
 			outputOptions.strictModuleErrorHandling
 				? Template.indent([
@@ -1775,7 +1872,7 @@ class JavascriptModulesPlugin {
 				: Template.indent("return cachedModule.exports;"),
 			"}",
 			"// Create a new module (and put it into the cache)",
-			"var module = __webpack_module_cache__[moduleId] = {",
+			`${moduleDecl} module = __webpack_module_cache__[moduleId] = {`,
 			Template.indent([
 				needModuleId ? "id: moduleId," : "// no module.id needed",
 				needModuleLoaded ? "loaded: false," : "// no module.loaded needed",
@@ -1788,7 +1885,7 @@ class JavascriptModulesPlugin {
 			outputOptions.strictModuleExceptionHandling
 				? Template.asString([
 						"// Execute the module function",
-						"var threw = true;",
+						`${lt} threw = true;`,
 						"try {",
 						Template.indent([
 							moduleExecution,
@@ -1870,11 +1967,11 @@ class JavascriptModulesPlugin {
 			allModules.every((m) => /** @type {BuildInfo} */ (m.buildInfo).strict);
 		const isMultipleEntries = inlinedModules.size > 1;
 		const singleEntryWithModules = inlinedModules.size === 1 && hasChunkModules;
-		// TODO:
-		// This step is before the IIFE reason calculation. Ideally, it should only be executed when this function can optimize the
-		// IIFE reason. Otherwise, it should directly return false. There are four reasons now, we have skipped two already, the left
-		// one is 'it uses a non-standard name for the exports'.
-		if (isMultipleEntries || innerStrict || !singleEntryWithModules) {
+		// This step is before the IIFE reason calculation; it only runs for the
+		// cases whose IIFE reason it can remove: multiple inlined entry modules, or a
+		// single inlined entry alongside other chunk modules. The remaining reason
+		// ('it uses a non-standard name for the exports') is not handled here.
+		if (innerStrict || (!isMultipleEntries && !singleEntryWithModules)) {
 			return false;
 		}
 
@@ -1887,6 +1984,8 @@ class JavascriptModulesPlugin {
 		const inlinedModulesToInfo = new Map();
 		/** @type {Set<string>} */
 		const nonInlinedModuleThroughIdentifiers = new Set();
+		/** @type {Map<Module, Source>} */
+		const inlinedModuleSources = new Map();
 
 		for (const m of allModules) {
 			const isInlinedModule = inlinedModules && inlinedModules.has(m);
@@ -1901,6 +2000,12 @@ class JavascriptModulesPlugin {
 			);
 
 			if (!moduleSource) continue;
+			if (isInlinedModule) {
+				// Parsing the inlined entry (often the whole concatenated app) is
+				// expensive; defer it until we know renaming is actually needed.
+				inlinedModuleSources.set(m, moduleSource);
+				continue;
+			}
 			const code = /** @type {string} */ (moduleSource.source());
 
 			const { ast } = JavascriptParser._parse(
@@ -1920,22 +2025,88 @@ class JavascriptModulesPlugin {
 			});
 
 			const globalScope = /** @type {Scope} */ (scopeManager.acquire(ast));
-			if (inlinedModules && inlinedModules.has(m)) {
-				const moduleScope = globalScope.childScopes[0];
-				inlinedModulesToInfo.set(m, {
-					source: moduleSource,
-					ast,
-					module: m,
-					variables: new Set(moduleScope.variables),
-					through: new Set(moduleScope.through),
-					usedInNonInlined: new Set(),
-					moduleScope
-				});
-			} else {
-				for (const ref of globalScope.through) {
-					nonInlinedModuleThroughIdentifiers.add(ref.identifier.name);
+			for (const ref of globalScope.through) {
+				nonInlinedModuleThroughIdentifiers.add(ref.identifier.name);
+			}
+		}
+
+		// Fast path: codegen reports each inlined entry's rendered top-level
+		// declarations and free names (post-concatenation), so when no declaration
+		// collides with a free name of any other module, another entry's
+		// declarations, or a reserved name, no renaming is needed and the entries
+		// don't have to be parsed at all.
+		fastPath: {
+			const { codeGenerationResults, chunk } = renderContext;
+			/** @type {Set<string>} */
+			const usedNames = new Set(nonInlinedModuleThroughIdentifiers);
+			for (const name of RESERVED_NAMES) usedNames.add(name);
+			/** @type {Set<string>[]} */
+			const declarationsList = [];
+			for (const m of inlinedModuleSources.keys()) {
+				if (!codeGenerationResults.has(m, chunk.runtime)) break fastPath;
+				const result = codeGenerationResults.get(m, chunk.runtime);
+				const data = result.data;
+				if (!data) break fastPath;
+				const declarations = data.get("topLevelDeclarations");
+				if (!declarations) break fastPath;
+				declarationsList.push(declarations);
+				if (!isMultipleEntries) continue;
+				// Entries share the startup scope: an entry's free names and runtime
+				// globals must not be shadowed by another entry's declarations.
+				const freeNames = data.get("freeNames");
+				if (!freeNames) break fastPath;
+				for (const name of freeNames) usedNames.add(name);
+				if (result.runtimeRequirements) {
+					for (const req of result.runtimeRequirements) {
+						const dot = req.indexOf(".");
+						usedNames.add(dot === -1 ? req : req.slice(0, dot));
+					}
+				}
+			}
+			for (const declarations of declarationsList) {
+				for (const name of declarations) {
+					if (usedNames.has(name)) break fastPath;
 				}
+				// earlier entries' declarations join the used set so later entries
+				// are checked against them
+				for (const name of declarations) usedNames.add(name);
 			}
+			for (const [m, moduleSource] of inlinedModuleSources) {
+				renamedInlinedModules.set(m, moduleSource);
+			}
+			return renamedInlinedModules;
+		}
+
+		for (const [m, moduleSource] of inlinedModuleSources) {
+			const code = /** @type {string} */ (moduleSource.source());
+
+			const { ast } = JavascriptParser._parse(
+				code,
+				{
+					sourceType: "auto",
+					ranges: true
+				},
+				JavascriptParser._getModuleParseFunction(compilation, m)
+			);
+
+			const scopeManager = eslintScope.analyze(ast, {
+				ecmaVersion: 6,
+				sourceType: "module",
+				optimistic: true,
+				ignoreEval: true
+			});
+
+			const globalScope = /** @type {Scope} */ (scopeManager.acquire(ast));
+			const moduleScope = globalScope.childScopes[0];
+			inlinedModulesToInfo.set(m, {
+				source: moduleSource,
+				ast,
+				module: m,
+				variables: new Set(moduleScope.variables),
+				through: new Set(moduleScope.through),
+				usedInNonInlined: new Set(),
+				moduleScope
+			});
 		}
 
 		for (const [, { variables, usedInNonInlined }] of inlinedModulesToInfo) {
@@ -1949,6 +2120,36 @@ class JavascriptModulesPlugin {
 			}
 		}
 
+		// Multiple inlined entry modules share the chunk's startup scope. Rename any
+		// top-level declaration that would collide with another inlined module's
+		// declaration, with any inlined or non-inlined module's free (global)
+		// reference, or with a reserved name, so the modules can be emitted without a
+		// per-entry IIFE.
+		if (isMultipleEntries) {
+			/** @type {Set<string>} */
+			const allUsedNames = new Set(nonInlinedModuleThroughIdentifiers);
+			for (const name of RESERVED_NAMES) allUsedNames.add(name);
+			for (const { through } of inlinedModulesToInfo.values()) {
+				for (const ref of through) allUsedNames.add(ref.identifier.name);
+			}
+			for (const [m, moduleInfo] of inlinedModulesToInfo) {
+				const { ast, source: _source } = moduleInfo;
+				const source = new ReplaceSource(_source);
+				for (const variable of moduleInfo.variables) {
+					renameInlinedModuleVariable(
+						source,
+						ast,
+						variable,
+						moduleInfo.module.identifier(),
+						m.readableIdentifier(runtimeTemplate.requestShortener),
+						allUsedNames
+					);
+				}
+				renamedInlinedModules.set(m, source);
+			}
+			return renamedInlinedModules;
+		}
+
 		for (const [m, moduleInfo] of inlinedModulesToInfo) {
 			const { ast, source: _source, usedInNonInlined } = moduleInfo;
 			const source = new ReplaceSource(_source);
@@ -1967,60 +2168,14 @@ class JavascriptModulesPlugin {
 			}
 
 			for (const variable of info.variables) {
-				/** @type {UsedNamesInScopeInfo} */
-				const usedNamesInScopeInfo = new Map();
-				/** @type {ScopeSet} */
-				const ignoredScopes = new Set();
-
-				const name = variable.name;
-				const { usedNames, alreadyCheckedScopes } = getUsedNamesInScopeInfo(
-					usedNamesInScopeInfo,
+				renameInlinedModuleVariable(
+					source,
+					ast,
+					variable,
 					info.module.identifier(),
-					name
+					m.readableIdentifier(runtimeTemplate.requestShortener),
+					allUsedNames
 				);
-
-				if (allUsedNames.has(name) || usedNames.has(name)) {
-					const references = getAllReferences(variable);
-					const allIdentifiers = new Set([
-						...references.map((r) => r.identifier),
-						...variable.identifiers
-					]);
-					for (const ref of references) {
-						addScopeSymbols(
-							ref.from,
-							usedNames,
-							alreadyCheckedScopes,
-							ignoredScopes
-						);
-					}
-
-					const newName = findNewName(
-						variable.name,
-						allUsedNames,
-						usedNames,
-						m.readableIdentifier(runtimeTemplate.requestShortener)
-					);
-					allUsedNames.add(newName);
-					for (const identifier of allIdentifiers) {
-						const r = /** @type {Range} */ (identifier.range);
-						const path = getPathInAst(ast, identifier);
-						if (path && path.length > 1) {
-							const maybeProperty =
-								path[1].type === "AssignmentPattern" && path[1].left === path[0]
-									? path[2]
-									: path[1];
-							if (
-								maybeProperty.type === "Property" &&
-								maybeProperty.shorthand
-							) {
-								source.insert(r[1], `: ${newName}`);
-								continue;
-							}
-						}
-						source.replace(r[0], r[1] - 1, newName);
-					}
-				}
-				allUsedNames.add(name);
 			}
 
 			renamedInlinedModules.set(m, source);