webpack 5.94.0 → 5.96.0

package/lib/javascript/JavascriptModulesPlugin.js

@@ -31,13 +31,21 @@ const Template = require("../Template");
 const { last, someInIterable } = require("../util/IterableHelpers");
 const StringXor = require("../util/StringXor");
 const { compareModulesByIdentifier } = require("../util/comparators");
+const {
+	getPathInAst,
+	getAllReferences,
+	RESERVED_NAMES,
+	findNewName,
+	addScopeSymbols,
+	getUsedNamesInScopeInfo
+} = require("../util/concatenate");
 const createHash = require("../util/createHash");
-const { getPathInAst, getAllReferences } = require("../util/mergeScope");
 const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
 const { intersectRuntime } = require("../util/runtime");
 const JavascriptGenerator = require("./JavascriptGenerator");
 const JavascriptParser = require("./JavascriptParser");
 
+/** @typedef {import("eslint-scope").Reference} Reference */
 /** @typedef {import("eslint-scope").Scope} Scope */
 /** @typedef {import("eslint-scope").Variable} Variable */
 /** @typedef {import("webpack-sources").Source} Source */
@@ -46,6 +54,7 @@ const JavascriptParser = require("./JavascriptParser");
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("../Compilation").ModuleObject} ModuleObject */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../Entrypoint")} Entrypoint */
@@ -54,8 +63,10 @@ const JavascriptParser = require("./JavascriptParser");
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
+/** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/createHash").Algorithm} Algorithm */
 
 /**
  * @param {Chunk} chunk a chunk
@@ -70,6 +81,25 @@ const chunkHasJs = (chunk, chunkGraph) => {
 	);
 };
 
+/**
+ * @param {Chunk} chunk a chunk
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @returns {boolean} true, when a JS file is needed for this chunk
+ */
+const chunkHasRuntimeOrJs = (chunk, chunkGraph) => {
+	if (
+		chunkGraph.getChunkModulesIterableBySourceType(
+			chunk,
+			WEBPACK_MODULE_TYPE_RUNTIME
+		)
+	)
+		return true;
+
+	return Boolean(
+		chunkGraph.getChunkModulesIterableBySourceType(chunk, "javascript")
+	);
+};
+
 /**
  * @param {Module} module a module
  * @param {string} code the code
@@ -152,11 +182,11 @@ const printGeneratedCodeForStack = (module, code) => {
  * @property {SyncWaterfallHook<[Source, RenderContext]>} render
  * @property {SyncWaterfallHook<[Source, Module, StartupRenderContext]>} renderStartup
  * @property {SyncWaterfallHook<[string, RenderBootstrapContext]>} renderRequire
- * @property {SyncBailHook<[Module, RenderBootstrapContext], string>} inlineInRuntimeBailout
+ * @property {SyncBailHook<[Module, RenderBootstrapContext], string | void>} inlineInRuntimeBailout
  * @property {SyncBailHook<[Module, RenderContext], string | void>} embedInRuntimeBailout
  * @property {SyncBailHook<[RenderContext], string | void>} strictRuntimeBailout
  * @property {SyncHook<[Chunk, Hash, ChunkHashContext]>} chunkHash
- * @property {SyncBailHook<[Chunk, RenderContext], boolean>} useSourceMap
+ * @property {SyncBailHook<[Chunk, RenderContext], boolean | void>} useSourceMap
  */
 
 /** @type {WeakMap<Compilation, CompilationHooks>} */
@@ -263,13 +293,14 @@ class JavascriptModulesPlugin {
 					} = options;
 
 					const hotUpdateChunk = chunk instanceof HotUpdateChunk ? chunk : null;
-
-					let render;
 					const filenameTemplate =
 						JavascriptModulesPlugin.getChunkFilenameTemplate(
 							chunk,
 							outputOptions
 						);
+
+					let render;
+
 					if (hotUpdateChunk) {
 						render = () =>
 							this.renderChunk(
@@ -285,6 +316,10 @@ class JavascriptModulesPlugin {
 								hooks
 							);
 					} else if (chunk.hasRuntime()) {
+						if (!chunkHasRuntimeOrJs(chunk, chunkGraph)) {
+							return result;
+						}
+
 						render = () =>
 							this.renderMain(
 								{
@@ -370,7 +405,7 @@ class JavascriptModulesPlugin {
 							hashFunction
 						}
 					} = compilation;
-					const hash = createHash(hashFunction);
+					const hash = createHash(/** @type {Algorithm} */ (hashFunction));
 					if (hashSalt) hash.update(hashSalt);
 					if (chunk.hasRuntime()) {
 						this.updateHashWithBootstrap(
@@ -420,7 +455,8 @@ class JavascriptModulesPlugin {
 					const digest = /** @type {string} */ (hash.digest(hashDigest));
 					chunk.contentHash.javascript = nonNumericOnlyHash(
 						digest,
-						hashDigestLength
+						/** @type {number} */
+						(hashDigestLength)
 					);
 				});
 				compilation.hooks.additionalTreeRuntimeRequirements.tap(
@@ -439,7 +475,7 @@ class JavascriptModulesPlugin {
 				compilation.hooks.executeModule.tap(PLUGIN_NAME, (options, context) => {
 					const source = options.codeGenerationResult.sources.get("javascript");
 					if (source === undefined) return;
-					const { module, moduleObject } = options;
+					const { module } = options;
 					const code = source.source();
 
 					const fn = vm.runInThisContext(
@@ -449,6 +485,11 @@ class JavascriptModulesPlugin {
 							lineOffset: -1
 						}
 					);
+
+					const moduleObject =
+						/** @type {ModuleObject} */
+						(options.moduleObject);
+
 					try {
 						fn.call(
 							moduleObject.exports,
@@ -621,7 +662,8 @@ class JavascriptModulesPlugin {
 				"JavascriptModulesPlugin.getCompilationHooks().renderModulePackage"
 			);
 		} catch (err) {
-			err.module = module;
+			/** @type {WebpackError} */
+			(err).module = module;
 			throw err;
 		}
 	}
@@ -839,18 +881,25 @@ class JavascriptModulesPlugin {
 				startupSource.add(`var ${RuntimeGlobals.exports} = {};\n`);
 			}
 
-			const renamedInlinedModule = this.renameInlineModule(
-				allModules,
-				renderContext,
-				inlinedModules,
-				chunkRenderContext,
-				hooks
-			);
+			const avoidEntryIife = compilation.options.optimization.avoidEntryIife;
+			/** @type {Map<Module, Source> | false} */
+			let renamedInlinedModule = false;
+			if (avoidEntryIife) {
+				renamedInlinedModule = this.getRenamedInlineModule(
+					allModules,
+					renderContext,
+					inlinedModules,
+					chunkRenderContext,
+					hooks,
+					allStrict,
+					Boolean(chunkModules)
+				);
+			}
 
 			for (const m of inlinedModules) {
-				const renderedModule =
-					renamedInlinedModule.get(m) ||
-					this.renderModule(m, chunkRenderContext, hooks, false);
+				const renderedModule = renamedInlinedModule
+					? renamedInlinedModule.get(m)
+					: this.renderModule(m, chunkRenderContext, hooks, false);
 
 				if (renderedModule) {
 					const innerStrict =
@@ -863,18 +912,20 @@ class JavascriptModulesPlugin {
 					const webpackExports =
 						exports && m.exportsArgument === RuntimeGlobals.exports;
 					const iife = innerStrict
-						? "it need to be in strict mode."
+						? "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 need to be isolated against other entry modules."
-							: exports && !webpackExports
-								? `it uses a non-standard name for the exports (${m.exportsArgument}).`
-								: hooks.embedInRuntimeBailout.call(m, renderContext);
+								"it needs to be isolated against other entry modules."
+							: chunkModules && !renamedInlinedModule
+								? "it needs to be isolated against other modules in the chunk."
+								: exports && !webpackExports
+									? `it uses a non-standard name for the exports (${m.exportsArgument}).`
+									: hooks.embedInRuntimeBailout.call(m, renderContext);
 					let footer;
 					if (iife !== undefined) {
 						startupSource.add(
-							`// This entry need to be wrapped in an IIFE because ${iife}\n`
+							`// This entry needs to be wrapped in an IIFE because ${iife}\n`
 						);
 						const arrow = runtimeTemplate.supportsArrowFunction();
 						if (arrow) {
@@ -1132,6 +1183,10 @@ class JavascriptModulesPlugin {
 					entryModule,
 					entrypoint
 				] of chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)) {
+					if (!chunkGraph.getModuleSourceTypes(entryModule).has("javascript")) {
+						i--;
+						continue;
+					}
 					const chunks =
 						/** @type {Entrypoint} */
 						(entrypoint).chunks.filter(c => c !== chunk);
@@ -1420,25 +1475,43 @@ class JavascriptModulesPlugin {
 	 * @param {Set<Module>} inlinedModules inlinedModules
 	 * @param {ChunkRenderContext} chunkRenderContext chunkRenderContext
 	 * @param {CompilationHooks} hooks hooks
-	 * @returns {Map<Module, Source>} renamed inlined modules
+	 * @param {boolean | undefined} allStrict allStrict
+	 * @param {boolean} hasChunkModules hasChunkModules
+	 * @returns {Map<Module, Source> | false} renamed inlined modules
 	 */
-	renameInlineModule(
+	getRenamedInlineModule(
 		allModules,
 		renderContext,
 		inlinedModules,
 		chunkRenderContext,
-		hooks
+		hooks,
+		allStrict,
+		hasChunkModules
 	) {
-		const { runtimeTemplate } = renderContext;
+		const innerStrict =
+			!allStrict &&
+			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) {
+			return false;
+		}
 
-		/** @typedef {{ source: Source, ast: any, variables: Set<Variable>, usedInNonInlined: Set<Variable>}} InlinedModulesInfo */
+		/** @type {Map<Module, Source>} */
+		const renamedInlinedModules = new Map();
+		const { runtimeTemplate } = renderContext;
 
-		/** @type {Map<Module, InlinedModulesInfo>} */
+		/** @typedef {{ source: Source, module: Module, ast: any, variables: Set<Variable>, through: Set<Reference>, usedInNonInlined: Set<Variable>, moduleScope: Scope }} Info */
+		/** @type {Map<Module, Info>} */
 		const inlinedModulesToInfo = new Map();
 		/** @type {Set<string>} */
 		const nonInlinedModuleThroughIdentifiers = new Set();
 		/** @type {Map<Module, Source>} */
-		const renamedInlinedModules = new Map();
 
 		for (const m of allModules) {
 			const isInlinedModule = inlinedModules && inlinedModules.has(m);
@@ -1468,8 +1541,11 @@ class JavascriptModulesPlugin {
 				inlinedModulesToInfo.set(m, {
 					source: moduleSource,
 					ast,
+					module: m,
 					variables: new Set(moduleScope.variables),
-					usedInNonInlined: new Set()
+					through: new Set(moduleScope.through),
+					usedInNonInlined: new Set(),
+					moduleScope
 				});
 			} else {
 				for (const ref of globalScope.through) {
@@ -1480,7 +1556,10 @@ class JavascriptModulesPlugin {
 
 		for (const [, { variables, usedInNonInlined }] of inlinedModulesToInfo) {
 			for (const variable of variables) {
-				if (nonInlinedModuleThroughIdentifiers.has(variable.name)) {
+				if (
+					nonInlinedModuleThroughIdentifiers.has(variable.name) ||
+					RESERVED_NAMES.has(variable.name)
+				) {
 					usedInNonInlined.add(variable);
 				}
 			}
@@ -1494,39 +1573,70 @@ class JavascriptModulesPlugin {
 				continue;
 			}
 
-			const usedNames = new Set(
-				Array.from(
-					/** @type {InlinedModulesInfo} */
-					(inlinedModulesToInfo.get(m)).variables
-				).map(v => v.name)
+			const info = /** @type {Info} */ (inlinedModulesToInfo.get(m));
+			const allUsedNames = new Set(
+				Array.from(info.through, v => v.identifier.name)
 			);
 
 			for (const variable of usedInNonInlined) {
+				allUsedNames.add(variable.name);
+			}
+
+			for (const variable of info.variables) {
+				allUsedNames.add(variable.name);
 				const references = getAllReferences(variable);
 				const allIdentifiers = new Set(
 					references.map(r => r.identifier).concat(variable.identifiers)
 				);
 
-				const newName = this.findNewName(
-					variable.name,
-					usedNames,
-					m.readableIdentifier(runtimeTemplate.requestShortener)
+				const usedNamesInScopeInfo = new Map();
+				const ignoredScopes = new Set();
+
+				const name = variable.name;
+				const { usedNames, alreadyCheckedScopes } = getUsedNamesInScopeInfo(
+					usedNamesInScopeInfo,
+					info.module.identifier(),
+					name
 				);
-				usedNames.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;
+
+				if (allUsedNames.has(name) || usedNames.has(name)) {
+					const references = getAllReferences(variable);
+					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);
 					}
-					source.replace(r[0], r[1] - 1, newName);
+				} else {
+					allUsedNames.add(name);
 				}
 			}
 
@@ -1535,38 +1645,6 @@ class JavascriptModulesPlugin {
 
 		return renamedInlinedModules;
 	}
-
-	/**
-	 * @param {string} oldName oldName
-	 * @param {Set<string>} usedName usedName
-	 * @param {string} extraInfo extraInfo
-	 * @returns {string} extraInfo
-	 */
-	findNewName(oldName, usedName, extraInfo) {
-		let name = oldName;
-
-		// Remove uncool stuff
-		extraInfo = extraInfo.replace(
-			/\.+\/|(\/index)?\.([a-zA-Z0-9]{1,4})($|\s|\?)|\s*\+\s*\d+\s*modules/g,
-			""
-		);
-		const splittedInfo = extraInfo.split("/");
-		while (splittedInfo.length) {
-			name = splittedInfo.pop() + (name ? `_${name}` : "");
-			const nameIdent = Template.toIdentifier(name);
-			if (!usedName.has(nameIdent)) {
-				return nameIdent;
-			}
-		}
-
-		let i = 0;
-		let nameWithNumber = Template.toIdentifier(`${name}_${i}`);
-		while (usedName.has(nameWithNumber)) {
-			i++;
-			nameWithNumber = Template.toIdentifier(`${name}_${i}`);
-		}
-		return nameWithNumber;
-	}
 }
 
 module.exports = JavascriptModulesPlugin;