webpack 5.90.3 → 5.92.0

package/lib/javascript/ChunkHelpers.js

@@ -11,8 +11,8 @@ const Entrypoint = require("../Entrypoint");
 
 /**
  * @param {Entrypoint} entrypoint a chunk group
- * @param {Chunk=} excludedChunk1 current chunk which is excluded
- * @param {Chunk=} excludedChunk2 runtime chunk which is excluded
+ * @param {(Chunk | null)=} excludedChunk1 current chunk which is excluded
+ * @param {(Chunk | null)=} excludedChunk2 runtime chunk which is excluded
  * @returns {Set<Chunk>} chunks
  */
 const getAllChunks = (entrypoint, excludedChunk1, excludedChunk2) => {

package/lib/javascript/CommonJsChunkFormatPlugin.js

@@ -32,7 +32,7 @@ class CommonJsChunkFormatPlugin {
 			"CommonJsChunkFormatPlugin",
 			compilation => {
 				compilation.hooks.additionalChunkRuntimeRequirements.tap(
-					"CommonJsChunkLoadingPlugin",
+					"CommonJsChunkFormatPlugin",
 					(chunk, set, { chunkGraph }) => {
 						if (chunk.hasRuntime()) return;
 						if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {

package/lib/javascript/JavascriptGenerator.js

@@ -199,7 +199,6 @@ class JavascriptGenerator extends Generator {
 			chunkGraph: generateContext.chunkGraph,
 			module,
 			runtime: generateContext.runtime,
-			runtimes: generateContext.runtimes,
 			runtimeRequirements: generateContext.runtimeRequirements,
 			concatenationScope: generateContext.concatenationScope,
 			codeGenerationResults: generateContext.codeGenerationResults,

package/lib/javascript/JavascriptModulesPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const eslintScope = require("eslint-scope");
 const { SyncWaterfallHook, SyncHook, SyncBailHook } = require("tapable");
 const vm = require("vm");
 const {
@@ -12,7 +13,8 @@ const {
 	OriginalSource,
 	PrefixSource,
 	RawSource,
-	CachedSource
+	CachedSource,
+	ReplaceSource
 } = require("webpack-sources");
 const Compilation = require("../Compilation");
 const { tryRunOrWebpackError } = require("../HookWebpackError");
@@ -30,11 +32,13 @@ const { last, someInIterable } = require("../util/IterableHelpers");
 const StringXor = require("../util/StringXor");
 const { compareModulesByIdentifier } = require("../util/comparators");
 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").Variable} Variable */
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
@@ -85,7 +89,7 @@ const printGeneratedCodeForStack = (module, code) => {
 };
 
 /**
- * @typedef {Object} RenderContext
+ * @typedef {object} RenderContext
  * @property {Chunk} chunk the chunk
  * @property {DependencyTemplates} dependencyTemplates the dependency templates
  * @property {RuntimeTemplate} runtimeTemplate the runtime template
@@ -96,7 +100,7 @@ const printGeneratedCodeForStack = (module, code) => {
  */
 
 /**
- * @typedef {Object} MainRenderContext
+ * @typedef {object} MainRenderContext
  * @property {Chunk} chunk the chunk
  * @property {DependencyTemplates} dependencyTemplates the dependency templates
  * @property {RuntimeTemplate} runtimeTemplate the runtime template
@@ -108,7 +112,7 @@ const printGeneratedCodeForStack = (module, code) => {
  */
 
 /**
- * @typedef {Object} ChunkRenderContext
+ * @typedef {object} ChunkRenderContext
  * @property {Chunk} chunk the chunk
  * @property {DependencyTemplates} dependencyTemplates the dependency templates
  * @property {RuntimeTemplate} runtimeTemplate the runtime template
@@ -120,7 +124,7 @@ const printGeneratedCodeForStack = (module, code) => {
  */
 
 /**
- * @typedef {Object} RenderBootstrapContext
+ * @typedef {object} RenderBootstrapContext
  * @property {Chunk} chunk the chunk
  * @property {CodeGenerationResults} codeGenerationResults results of code generation
  * @property {RuntimeTemplate} runtimeTemplate the runtime template
@@ -132,7 +136,7 @@ const printGeneratedCodeForStack = (module, code) => {
 /** @typedef {RenderContext & { inlined: boolean }} StartupRenderContext */
 
 /**
- * @typedef {Object} CompilationHooks
+ * @typedef {object} CompilationHooks
  * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContent
  * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContainer
  * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModulePackage
@@ -818,13 +822,19 @@ class JavascriptModulesPlugin {
 			const lastInlinedModule = last(inlinedModules);
 			const startupSource = new ConcatSource();
 			startupSource.add(`var ${RuntimeGlobals.exports} = {};\n`);
+			const renamedInlinedModule = this.renameInlineModule(
+				allModules,
+				renderContext,
+				inlinedModules,
+				chunkRenderContext,
+				hooks
+			);
+
 			for (const m of inlinedModules) {
-				const renderedModule = this.renderModule(
-					m,
-					chunkRenderContext,
-					hooks,
-					false
-				);
+				const renderedModule =
+					renamedInlinedModule.get(m) ||
+					this.renderModule(m, chunkRenderContext, hooks, false);
+
 				if (renderedModule) {
 					const innerStrict = !allStrict && m.buildInfo.strict;
 					const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
@@ -840,11 +850,9 @@ class JavascriptModulesPlugin {
 							? // 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."
-							: chunkModules
-								? "it need 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);
+							: 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(
@@ -1383,6 +1391,155 @@ class JavascriptModulesPlugin {
 			"JavascriptModulesPlugin.getCompilationHooks().renderRequire"
 		);
 	}
+
+	/**
+	 * @param {Module[]} allModules allModules
+	 * @param {MainRenderContext} renderContext renderContext
+	 * @param {Set<Module>} inlinedModules inlinedModules
+	 * @param {ChunkRenderContext} chunkRenderContext chunkRenderContext
+	 * @param {CompilationHooks} hooks hooks
+	 * @returns {Map<Module, Source>} renamed inlined modules
+	 */
+	renameInlineModule(
+		allModules,
+		renderContext,
+		inlinedModules,
+		chunkRenderContext,
+		hooks
+	) {
+		const { runtimeTemplate } = renderContext;
+
+		/** @type {Map<Module, { source: Source, ast: any, variables: Set<Variable>, usedInNonInlined: Set<Variable>}>} */
+		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);
+			const moduleSource = this.renderModule(
+				m,
+				chunkRenderContext,
+				hooks,
+				isInlinedModule ? false : true
+			);
+
+			if (!moduleSource) continue;
+			const code = /** @type {string} */ (moduleSource.source());
+			const ast = JavascriptParser._parse(code, {
+				sourceType: "auto"
+			});
+
+			const scopeManager = eslintScope.analyze(ast, {
+				ecmaVersion: 6,
+				sourceType: "module",
+				optimistic: true,
+				ignoreEval: true
+			});
+
+			const globalScope = scopeManager.acquire(ast);
+			if (inlinedModules && inlinedModules.has(m)) {
+				const moduleScope = globalScope.childScopes[0];
+				inlinedModulesToInfo.set(m, {
+					source: moduleSource,
+					ast,
+					variables: new Set(moduleScope.variables),
+					usedInNonInlined: new Set()
+				});
+			} else {
+				for (const ref of globalScope.through) {
+					nonInlinedModuleThroughIdentifiers.add(ref.identifier.name);
+				}
+			}
+		}
+
+		for (const [, { variables, usedInNonInlined }] of inlinedModulesToInfo) {
+			for (const variable of variables) {
+				if (nonInlinedModuleThroughIdentifiers.has(variable.name)) {
+					usedInNonInlined.add(variable);
+				}
+			}
+		}
+
+		for (const [m, moduleInfo] of inlinedModulesToInfo) {
+			const { ast, source: _source, usedInNonInlined } = moduleInfo;
+			const source = new ReplaceSource(_source);
+			if (usedInNonInlined.size === 0) {
+				renamedInlinedModules.set(m, source);
+				continue;
+			}
+
+			const usedNames = new Set(
+				Array.from(inlinedModulesToInfo.get(m).variables).map(v => v.name)
+			);
+
+			for (const variable of usedInNonInlined) {
+				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)
+				);
+				usedNames.add(newName);
+				for (const identifier of allIdentifiers) {
+					const r = 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);
+				}
+			}
+
+			renamedInlinedModules.set(m, source);
+		}
+
+		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;