webpack 5.22.0 → 5.24.2

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -8,11 +8,8 @@
 const asyncLib = require("neo-async");
 const ChunkGraph = require("../ChunkGraph");
 const ModuleGraph = require("../ModuleGraph");
-const ModuleRestoreError = require("../ModuleRestoreError");
-const ModuleStoreError = require("../ModuleStoreError");
 const { STAGE_DEFAULT } = require("../OptimizationStages");
 const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
-const StackedMap = require("../util/StackedMap");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const {
 	intersectRuntime,
@@ -29,6 +26,20 @@ const ConcatenatedModule = require("./ConcatenatedModule");
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
+/**
+ * @typedef {Object} Statistics
+ * @property {number} cached
+ * @property {number} alreadyInConfig
+ * @property {number} invalidModule
+ * @property {number} incorrectChunks
+ * @property {number} incorrectDependency
+ * @property {number} incorrectModuleDependency
+ * @property {number} incorrectChunksOfImporter
+ * @property {number} incorrectRuntimeCondition
+ * @property {number} importerFailed
+ * @property {number} added
+ */
+
 const formatBailoutReason = msg => {
 	return "ModuleConcatenation bailout: " + msg;
 };
@@ -45,414 +56,404 @@ class ModuleConcatenationPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"ModuleConcatenationPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const moduleGraph = compilation.moduleGraph;
-				const bailoutReasonMap = new Map();
-				const cache = compilation.getCache("ModuleConcatenationPlugin");
-
-				const setBailoutReason = (module, reason) => {
-					setInnerBailoutReason(module, reason);
-					moduleGraph
-						.getOptimizationBailout(module)
-						.push(
-							typeof reason === "function"
-								? rs => formatBailoutReason(reason(rs))
-								: formatBailoutReason(reason)
-						);
-				};
-
-				const setInnerBailoutReason = (module, reason) => {
-					bailoutReasonMap.set(module, reason);
-				};
+		compiler.hooks.compilation.tap("ModuleConcatenationPlugin", compilation => {
+			const moduleGraph = compilation.moduleGraph;
+			const bailoutReasonMap = new Map();
+
+			const setBailoutReason = (module, reason) => {
+				setInnerBailoutReason(module, reason);
+				moduleGraph
+					.getOptimizationBailout(module)
+					.push(
+						typeof reason === "function"
+							? rs => formatBailoutReason(reason(rs))
+							: formatBailoutReason(reason)
+					);
+			};
 
-				const getInnerBailoutReason = (module, requestShortener) => {
-					const reason = bailoutReasonMap.get(module);
-					if (typeof reason === "function") return reason(requestShortener);
-					return reason;
-				};
+			const setInnerBailoutReason = (module, reason) => {
+				bailoutReasonMap.set(module, reason);
+			};
 
-				const formatBailoutWarning = (module, problem) => requestShortener => {
-					if (typeof problem === "function") {
-						return formatBailoutReason(
-							`Cannot concat with ${module.readableIdentifier(
-								requestShortener
-							)}: ${problem(requestShortener)}`
-						);
-					}
-					const reason = getInnerBailoutReason(module, requestShortener);
-					const reasonWithPrefix = reason ? `: ${reason}` : "";
-					if (module === problem) {
-						return formatBailoutReason(
-							`Cannot concat with ${module.readableIdentifier(
-								requestShortener
-							)}${reasonWithPrefix}`
-						);
-					} else {
-						return formatBailoutReason(
-							`Cannot concat with ${module.readableIdentifier(
-								requestShortener
-							)} because of ${problem.readableIdentifier(
-								requestShortener
-							)}${reasonWithPrefix}`
-						);
-					}
-				};
+			const getInnerBailoutReason = (module, requestShortener) => {
+				const reason = bailoutReasonMap.get(module);
+				if (typeof reason === "function") return reason(requestShortener);
+				return reason;
+			};
 
-				compilation.hooks.optimizeChunkModules.tapAsync(
-					{
-						name: "ModuleConcatenationPlugin",
-						stage: STAGE_DEFAULT
-					},
-					(allChunks, modules, callback) => {
-						const logger = compilation.getLogger("ModuleConcatenationPlugin");
-						const { chunkGraph, moduleGraph } = compilation;
-						const relevantModules = [];
-						const possibleInners = new Set();
-						const context = {
-							chunkGraph,
-							moduleGraph
-						};
-						logger.time("select relevant modules");
-						for (const module of modules) {
-							let canBeRoot = true;
-							let canBeInner = true;
-
-							const bailoutReason = module.getConcatenationBailoutReason(
-								context
-							);
-							if (bailoutReason) {
-								setBailoutReason(module, bailoutReason);
-								continue;
-							}
+			const formatBailoutWarning = (module, problem) => requestShortener => {
+				if (typeof problem === "function") {
+					return formatBailoutReason(
+						`Cannot concat with ${module.readableIdentifier(
+							requestShortener
+						)}: ${problem(requestShortener)}`
+					);
+				}
+				const reason = getInnerBailoutReason(module, requestShortener);
+				const reasonWithPrefix = reason ? `: ${reason}` : "";
+				if (module === problem) {
+					return formatBailoutReason(
+						`Cannot concat with ${module.readableIdentifier(
+							requestShortener
+						)}${reasonWithPrefix}`
+					);
+				} else {
+					return formatBailoutReason(
+						`Cannot concat with ${module.readableIdentifier(
+							requestShortener
+						)} because of ${problem.readableIdentifier(
+							requestShortener
+						)}${reasonWithPrefix}`
+					);
+				}
+			};
 
-							// Must not be an async module
-							if (moduleGraph.isAsync(module)) {
-								setBailoutReason(module, `Module is async`);
-								continue;
-							}
+			compilation.hooks.optimizeChunkModules.tapAsync(
+				{
+					name: "ModuleConcatenationPlugin",
+					stage: STAGE_DEFAULT
+				},
+				(allChunks, modules, callback) => {
+					const logger = compilation.getLogger(
+						"webpack.ModuleConcatenationPlugin"
+					);
+					const { chunkGraph, moduleGraph } = compilation;
+					const relevantModules = [];
+					const possibleInners = new Set();
+					const context = {
+						chunkGraph,
+						moduleGraph
+					};
+					logger.time("select relevant modules");
+					for (const module of modules) {
+						let canBeRoot = true;
+						let canBeInner = true;
+
+						const bailoutReason = module.getConcatenationBailoutReason(context);
+						if (bailoutReason) {
+							setBailoutReason(module, bailoutReason);
+							continue;
+						}
 
-							// Must be in strict mode
-							if (!module.buildInfo.strict) {
-								setBailoutReason(module, `Module is not in strict mode`);
-								continue;
-							}
+						// Must not be an async module
+						if (moduleGraph.isAsync(module)) {
+							setBailoutReason(module, `Module is async`);
+							continue;
+						}
 
-							// Module must be in any chunk (we don't want to do useless work)
-							if (chunkGraph.getNumberOfModuleChunks(module) === 0) {
-								setBailoutReason(module, "Module is not in any chunk");
-								continue;
-							}
+						// Must be in strict mode
+						if (!module.buildInfo.strict) {
+							setBailoutReason(module, `Module is not in strict mode`);
+							continue;
+						}
 
-							// Exports must be known (and not dynamic)
-							const exportsInfo = moduleGraph.getExportsInfo(module);
-							const relevantExports = exportsInfo.getRelevantExports(undefined);
-							const unknownReexports = relevantExports.filter(exportInfo => {
-								return (
-									exportInfo.isReexport() && !exportInfo.getTarget(moduleGraph)
-								);
-							});
-							if (unknownReexports.length > 0) {
-								setBailoutReason(
-									module,
-									`Reexports in this module do not have a static target (${Array.from(
-										unknownReexports,
-										exportInfo =>
-											`${
-												exportInfo.name || "other exports"
-											}: ${exportInfo.getUsedInfo()}`
-									).join(", ")})`
-								);
-								continue;
-							}
+						// Module must be in any chunk (we don't want to do useless work)
+						if (chunkGraph.getNumberOfModuleChunks(module) === 0) {
+							setBailoutReason(module, "Module is not in any chunk");
+							continue;
+						}
 
-							// Root modules must have a static list of exports
-							const unknownProvidedExports = relevantExports.filter(
-								exportInfo => {
-									return exportInfo.provided !== true;
-								}
+						// Exports must be known (and not dynamic)
+						const exportsInfo = moduleGraph.getExportsInfo(module);
+						const relevantExports = exportsInfo.getRelevantExports(undefined);
+						const unknownReexports = relevantExports.filter(exportInfo => {
+							return (
+								exportInfo.isReexport() && !exportInfo.getTarget(moduleGraph)
 							);
-							if (unknownProvidedExports.length > 0) {
-								setBailoutReason(
-									module,
-									`List of module exports is dynamic (${Array.from(
-										unknownProvidedExports,
-										exportInfo =>
-											`${
-												exportInfo.name || "other exports"
-											}: ${exportInfo.getProvidedInfo()} and ${exportInfo.getUsedInfo()}`
-									).join(", ")})`
-								);
-								canBeRoot = false;
-							}
+						});
+						if (unknownReexports.length > 0) {
+							setBailoutReason(
+								module,
+								`Reexports in this module do not have a static target (${Array.from(
+									unknownReexports,
+									exportInfo =>
+										`${
+											exportInfo.name || "other exports"
+										}: ${exportInfo.getUsedInfo()}`
+								).join(", ")})`
+							);
+							continue;
+						}
 
-							// Module must not be an entry point
-							if (chunkGraph.isEntryModule(module)) {
-								setInnerBailoutReason(module, "Module is an entry point");
-								canBeInner = false;
+						// Root modules must have a static list of exports
+						const unknownProvidedExports = relevantExports.filter(
+							exportInfo => {
+								return exportInfo.provided !== true;
 							}
+						);
+						if (unknownProvidedExports.length > 0) {
+							setBailoutReason(
+								module,
+								`List of module exports is dynamic (${Array.from(
+									unknownProvidedExports,
+									exportInfo =>
+										`${
+											exportInfo.name || "other exports"
+										}: ${exportInfo.getProvidedInfo()} and ${exportInfo.getUsedInfo()}`
+								).join(", ")})`
+							);
+							canBeRoot = false;
+						}
 
-							if (canBeRoot) relevantModules.push(module);
-							if (canBeInner) possibleInners.add(module);
+						// Module must not be an entry point
+						if (chunkGraph.isEntryModule(module)) {
+							setInnerBailoutReason(module, "Module is an entry point");
+							canBeInner = false;
+						}
+
+						if (canBeRoot) relevantModules.push(module);
+						if (canBeInner) possibleInners.add(module);
+					}
+					logger.timeEnd("select relevant modules");
+					logger.debug(
+						`${relevantModules.length} potential root modules, ${possibleInners.size} potential inner modules`
+					);
+					// sort by depth
+					// modules with lower depth are more likely suited as roots
+					// this improves performance, because modules already selected as inner are skipped
+					logger.time("sort relevant modules");
+					relevantModules.sort((a, b) => {
+						return moduleGraph.getDepth(a) - moduleGraph.getDepth(b);
+					});
+					logger.timeEnd("sort relevant modules");
+
+					/** @type {Statistics} */
+					const stats = {
+						cached: 0,
+						alreadyInConfig: 0,
+						invalidModule: 0,
+						incorrectChunks: 0,
+						incorrectDependency: 0,
+						incorrectModuleDependency: 0,
+						incorrectChunksOfImporter: 0,
+						incorrectRuntimeCondition: 0,
+						importerFailed: 0,
+						added: 0
+					};
+					let statsCandidates = 0;
+					let statsSizeSum = 0;
+					let statsEmptyConfigurations = 0;
+
+					logger.time("find modules to concatenate");
+					const concatConfigurations = [];
+					const usedAsInner = new Set();
+					for (const currentRoot of relevantModules) {
+						// when used by another configuration as inner:
+						// the other configuration is better and we can skip this one
+						// TODO reconsider that when it's only used in a different runtime
+						if (usedAsInner.has(currentRoot)) continue;
+
+						let chunkRuntime = undefined;
+						for (const r of chunkGraph.getModuleRuntimes(currentRoot)) {
+							chunkRuntime = mergeRuntimeOwned(chunkRuntime, r);
 						}
-						logger.timeEnd("select relevant modules");
-						logger.debug(
-							`${relevantModules.length} potential root modules, ${possibleInners.size} potential inner modules`
+						const exportsInfo = moduleGraph.getExportsInfo(currentRoot);
+						const filteredRuntime = filterRuntime(chunkRuntime, r =>
+							exportsInfo.isModuleUsed(r)
+						);
+						const activeRuntime =
+							filteredRuntime === true
+								? chunkRuntime
+								: filteredRuntime === false
+								? undefined
+								: filteredRuntime;
+
+						// create a configuration with the root
+						const currentConfiguration = new ConcatConfiguration(
+							currentRoot,
+							activeRuntime
 						);
-						// sort by depth
-						// modules with lower depth are more likely suited as roots
-						// this improves performance, because modules already selected as inner are skipped
-						logger.time("sort relevant modules");
-						relevantModules.sort((a, b) => {
-							return moduleGraph.getDepth(a) - moduleGraph.getDepth(b);
-						});
-						logger.timeEnd("sort relevant modules");
-
-						logger.time("find modules to concatenate");
-						const concatConfigurations = [];
-						const usedAsInner = new Set();
-						for (const currentRoot of relevantModules) {
-							// when used by another configuration as inner:
-							// the other configuration is better and we can skip this one
-							if (usedAsInner.has(currentRoot)) continue;
-
-							let chunkRuntime = undefined;
-							for (const r of chunkGraph.getModuleRuntimes(currentRoot)) {
-								chunkRuntime = mergeRuntimeOwned(chunkRuntime, r);
-							}
-							const exportsInfo = moduleGraph.getExportsInfo(currentRoot);
-							const filteredRuntime = filterRuntime(chunkRuntime, r =>
-								exportsInfo.isModuleUsed(r)
-							);
-							const activeRuntime =
-								filteredRuntime === true
-									? chunkRuntime
-									: filteredRuntime === false
-									? undefined
-									: filteredRuntime;
-
-							// create a configuration with the root
-							const currentConfiguration = new ConcatConfiguration(
-								currentRoot,
-								activeRuntime
-							);
 
-							// cache failures to add modules
-							const failureCache = new Map();
+						// cache failures to add modules
+						const failureCache = new Map();
 
-							// potential optional import candidates
-							/** @type {Set<Module>} */
-							const candidates = new Set();
+						// potential optional import candidates
+						/** @type {Set<Module>} */
+						const candidates = new Set();
 
-							// try to add all imports
-							for (const imp of this._getImports(
-								compilation,
-								currentRoot,
-								activeRuntime
-							)) {
-								candidates.add(imp);
-							}
+						// try to add all imports
+						for (const imp of this._getImports(
+							compilation,
+							currentRoot,
+							activeRuntime
+						)) {
+							candidates.add(imp);
+						}
 
-							for (const imp of candidates) {
-								// _tryToAdd modifies the config even if it fails
-								// so make sure to only accept changes when it succeed
-								const backup = currentConfiguration.snapshot();
-								const impCandidates = new Set();
-								const problem = this._tryToAdd(
-									compilation,
-									currentConfiguration,
-									imp,
-									chunkRuntime,
-									activeRuntime,
-									possibleInners,
-									impCandidates,
-									failureCache,
-									chunkGraph
-								);
-								if (problem) {
-									failureCache.set(imp, problem);
-									currentConfiguration.addWarning(imp, problem);
-
-									// roll back
-									currentConfiguration.rollback(backup);
-								} else {
-									for (const c of impCandidates) {
-										candidates.add(c);
-									}
-								}
-							}
-							if (!currentConfiguration.isEmpty()) {
-								concatConfigurations.push(currentConfiguration);
-								for (const module of currentConfiguration.getModules()) {
-									if (module !== currentConfiguration.rootModule) {
-										usedAsInner.add(module);
-									}
-								}
+						for (const imp of candidates) {
+							const impCandidates = new Set();
+							const problem = this._tryToAdd(
+								compilation,
+								currentConfiguration,
+								imp,
+								chunkRuntime,
+								activeRuntime,
+								possibleInners,
+								impCandidates,
+								failureCache,
+								chunkGraph,
+								true,
+								stats
+							);
+							if (problem) {
+								failureCache.set(imp, problem);
+								currentConfiguration.addWarning(imp, problem);
 							} else {
-								const optimizationBailouts = moduleGraph.getOptimizationBailout(
-									currentRoot
-								);
-								for (const warning of currentConfiguration.getWarningsSorted()) {
-									optimizationBailouts.push(
-										formatBailoutWarning(warning[0], warning[1])
-									);
+								for (const c of impCandidates) {
+									candidates.add(c);
 								}
 							}
 						}
-						logger.timeEnd("find modules to concatenate");
-						logger.debug(
-							`${concatConfigurations.length} concat configurations`
-						);
-						// HACK: Sort configurations by length and start with the longest one
-						// to get the biggest groups possible. Used modules are marked with usedModules
-						// TODO: Allow to reuse existing configuration while trying to add dependencies.
-						// This would improve performance. O(n^2) -> O(n)
-						logger.time(`sort concat configurations`);
-						concatConfigurations.sort((a, b) => {
-							return b.modules.size - a.modules.size;
-						});
-						logger.timeEnd(`sort concat configurations`);
-						const usedModules = new Set();
-
-						logger.time("create concatenated modules");
-						asyncLib.each(
-							concatConfigurations,
-							(concatConfiguration, callback) => {
-								const rootModule = concatConfiguration.rootModule;
-
-								// Avoid overlapping configurations
-								// TODO: remove this when todo above is fixed
-								if (usedModules.has(rootModule)) return callback();
-								const modules = concatConfiguration.getModules();
-								for (const m of modules) {
-									usedModules.add(m);
+						statsCandidates += candidates.size;
+						if (!currentConfiguration.isEmpty()) {
+							const modules = currentConfiguration.getModules();
+							statsSizeSum += modules.size;
+							concatConfigurations.push(currentConfiguration);
+							for (const module of modules) {
+								if (module !== currentConfiguration.rootModule) {
+									usedAsInner.add(module);
 								}
-
-								// Create a new ConcatenatedModule
-								let newModule = ConcatenatedModule.create(
-									rootModule,
-									modules,
-									concatConfiguration.runtime,
-									compiler.root
+							}
+						} else {
+							statsEmptyConfigurations++;
+							const optimizationBailouts = moduleGraph.getOptimizationBailout(
+								currentRoot
+							);
+							for (const warning of currentConfiguration.getWarningsSorted()) {
+								optimizationBailouts.push(
+									formatBailoutWarning(warning[0], warning[1])
 								);
+							}
+						}
+					}
+					logger.timeEnd("find modules to concatenate");
+					logger.debug(
+						`${
+							concatConfigurations.length
+						} successful concat configurations (avg size: ${
+							statsSizeSum / concatConfigurations.length
+						}), ${statsEmptyConfigurations} bailed out completely`
+					);
+					logger.debug(
+						`${statsCandidates} candidates were considered for adding (${stats.cached} cached failure, ${stats.alreadyInConfig} already in config, ${stats.invalidModule} invalid module, ${stats.incorrectChunks} incorrect chunks, ${stats.incorrectDependency} incorrect dependency, ${stats.incorrectChunksOfImporter} incorrect chunks of importer, ${stats.incorrectModuleDependency} incorrect module dependency, ${stats.incorrectRuntimeCondition} incorrect runtime condition, ${stats.importerFailed} importer failed, ${stats.added} added)`
+					);
+					// HACK: Sort configurations by length and start with the longest one
+					// to get the biggest groups possible. Used modules are marked with usedModules
+					// TODO: Allow to reuse existing configuration while trying to add dependencies.
+					// This would improve performance. O(n^2) -> O(n)
+					logger.time(`sort concat configurations`);
+					concatConfigurations.sort((a, b) => {
+						return b.modules.size - a.modules.size;
+					});
+					logger.timeEnd(`sort concat configurations`);
+					const usedModules = new Set();
+
+					logger.time("create concatenated modules");
+					asyncLib.each(
+						concatConfigurations,
+						(concatConfiguration, callback) => {
+							const rootModule = concatConfiguration.rootModule;
+
+							// Avoid overlapping configurations
+							// TODO: remove this when todo above is fixed
+							if (usedModules.has(rootModule)) return callback();
+							const modules = concatConfiguration.getModules();
+							for (const m of modules) {
+								usedModules.add(m);
+							}
 
-								const cacheItem = cache.getItemCache(
-									newModule.identifier(),
-									null
-								);
+							// Create a new ConcatenatedModule
+							let newModule = ConcatenatedModule.create(
+								rootModule,
+								modules,
+								concatConfiguration.runtime,
+								compiler.root
+							);
 
-								const restore = () => {
-									cacheItem.get((err, cacheModule) => {
+							const build = () => {
+								newModule.build(
+									compiler.options,
+									compilation,
+									null,
+									null,
+									err => {
 										if (err) {
-											return callback(new ModuleRestoreError(newModule, err));
-										}
-
-										if (cacheModule) {
-											cacheModule.updateCacheModule(newModule);
-											newModule = cacheModule;
-										}
-
-										build();
-									});
-								};
-
-								const build = () => {
-									newModule.build(
-										compiler.options,
-										compilation,
-										null,
-										null,
-										err => {
-											if (err) {
-												if (!err.module) {
-													err.module = newModule;
-												}
-												return callback(err);
+											if (!err.module) {
+												err.module = newModule;
 											}
-											integrateAndStore();
+											return callback(err);
 										}
-									);
-								};
+										integrate();
+									}
+								);
+							};
 
-								const integrateAndStore = () => {
-									ChunkGraph.setChunkGraphForModule(newModule, chunkGraph);
-									ModuleGraph.setModuleGraphForModule(newModule, moduleGraph);
+							const integrate = () => {
+								ChunkGraph.setChunkGraphForModule(newModule, chunkGraph);
+								ModuleGraph.setModuleGraphForModule(newModule, moduleGraph);
 
-									for (const warning of concatConfiguration.getWarningsSorted()) {
-										moduleGraph
-											.getOptimizationBailout(newModule)
-											.push(formatBailoutWarning(warning[0], warning[1]));
+								for (const warning of concatConfiguration.getWarningsSorted()) {
+									moduleGraph
+										.getOptimizationBailout(newModule)
+										.push(formatBailoutWarning(warning[0], warning[1]));
+								}
+								moduleGraph.cloneModuleAttributes(rootModule, newModule);
+								for (const m of modules) {
+									// add to builtModules when one of the included modules was built
+									if (compilation.builtModules.has(m)) {
+										compilation.builtModules.add(newModule);
 									}
-									moduleGraph.cloneModuleAttributes(rootModule, newModule);
-									for (const m of modules) {
-										// add to builtModules when one of the included modules was built
-										if (compilation.builtModules.has(m)) {
-											compilation.builtModules.add(newModule);
-										}
-										if (m !== rootModule) {
-											// attach external references to the concatenated module too
-											moduleGraph.copyOutgoingModuleConnections(
-												m,
-												newModule,
-												c => {
-													return (
-														c.originModule === m &&
-														!(
-															c.dependency instanceof HarmonyImportDependency &&
-															modules.has(c.module)
-														)
-													);
-												}
-											);
-											// remove module from chunk
-											for (const chunk of chunkGraph.getModuleChunksIterable(
-												rootModule
-											)) {
-												chunkGraph.disconnectChunkAndModule(chunk, m);
+									if (m !== rootModule) {
+										// attach external references to the concatenated module too
+										moduleGraph.copyOutgoingModuleConnections(
+											m,
+											newModule,
+											c => {
+												return (
+													c.originModule === m &&
+													!(
+														c.dependency instanceof HarmonyImportDependency &&
+														modules.has(c.module)
+													)
+												);
 											}
+										);
+										// remove module from chunk
+										for (const chunk of chunkGraph.getModuleChunksIterable(
+											rootModule
+										)) {
+											chunkGraph.disconnectChunkAndModule(chunk, m);
 										}
 									}
-									compilation.modules.delete(rootModule);
-									// remove module from chunk
-									chunkGraph.replaceModule(rootModule, newModule);
-									// replace module references with the concatenated module
-									moduleGraph.moveModuleConnections(
-										rootModule,
-										newModule,
-										c => {
-											const otherModule =
-												c.module === rootModule ? c.originModule : c.module;
-											const innerConnection =
-												c.dependency instanceof HarmonyImportDependency &&
-												modules.has(otherModule);
-											return !innerConnection;
-										}
-									);
-									// add concatenated module to the compilation
-									compilation.modules.add(newModule);
-
-									// TODO check if module needs build to avoid caching it without change
-									cacheItem.store(newModule, err => {
-										if (err) {
-											return callback(new ModuleStoreError(newModule, err));
-										}
-
-										callback();
-									});
-								};
-
-								restore();
-							},
-							err => {
-								logger.timeEnd("create concatenated modules");
-								process.nextTick(() => callback(err));
-							}
-						);
-					}
-				);
-			}
-		);
+								}
+								compilation.modules.delete(rootModule);
+								// remove module from chunk
+								chunkGraph.replaceModule(rootModule, newModule);
+								// replace module references with the concatenated module
+								moduleGraph.moveModuleConnections(rootModule, newModule, c => {
+									const otherModule =
+										c.module === rootModule ? c.originModule : c.module;
+									const innerConnection =
+										c.dependency instanceof HarmonyImportDependency &&
+										modules.has(otherModule);
+									return !innerConnection;
+								});
+								// add concatenated module to the compilation
+								compilation.modules.add(newModule);
+
+								callback();
+							};
+
+							build();
+						},
+						err => {
+							logger.timeEnd("create concatenated modules");
+							process.nextTick(() => callback(err));
+						}
+					);
+				}
+			);
+		});
 	}
 
 	/**
@@ -505,6 +506,8 @@ class ModuleConcatenationPlugin {
 	 * @param {Set<Module>} candidates list of potential candidates (will be added to)
 	 * @param {Map<Module, Module | function(RequestShortener): string>} failureCache cache for problematic modules to be more performant
 	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {boolean} avoidMutateOnFailure avoid mutating the config when adding fails
+	 * @param {Statistics} statistics gathering metrics
 	 * @returns {Module | function(RequestShortener): string} the problematic module
 	 */
 	_tryToAdd(
@@ -516,20 +519,25 @@ class ModuleConcatenationPlugin {
 		possibleModules,
 		candidates,
 		failureCache,
-		chunkGraph
+		chunkGraph,
+		avoidMutateOnFailure,
+		statistics
 	) {
 		const cacheEntry = failureCache.get(module);
 		if (cacheEntry) {
+			statistics.cached++;
 			return cacheEntry;
 		}
 
 		// Already added?
 		if (config.has(module)) {
+			statistics.alreadyInConfig++;
 			return null;
 		}
 
 		// Not possible to add?
 		if (!possibleModules.has(module)) {
+			statistics.invalidModule++;
 			failureCache.set(module, module); // cache failures for performance
 			return module;
 		}
@@ -537,137 +545,106 @@ class ModuleConcatenationPlugin {
 		// Module must be in the correct chunks
 		const missingChunks = Array.from(
 			chunkGraph.getModuleChunksIterable(config.rootModule)
-		)
-			.filter(chunk => !chunkGraph.isModuleInChunk(module, chunk))
-			.map(chunk => chunk.name || "unnamed chunk(s)");
+		).filter(chunk => !chunkGraph.isModuleInChunk(module, chunk));
 		if (missingChunks.length > 0) {
-			const missingChunksList = Array.from(new Set(missingChunks)).sort();
-			const chunks = Array.from(
-				new Set(
-					Array.from(chunkGraph.getModuleChunksIterable(module)).map(
-						chunk => chunk.name || "unnamed chunk(s)"
+			const problem = requestShortener => {
+				const missingChunksList = Array.from(
+					new Set(missingChunks.map(chunk => chunk.name || "unnamed chunk(s)"))
+				).sort();
+				const chunks = Array.from(
+					new Set(
+						Array.from(chunkGraph.getModuleChunksIterable(module)).map(
+							chunk => chunk.name || "unnamed chunk(s)"
+						)
 					)
-				)
-			).sort();
-			const problem = requestShortener =>
-				`Module ${module.readableIdentifier(
+				).sort();
+				return `Module ${module.readableIdentifier(
 					requestShortener
 				)} is not in the same chunk(s) (expected in chunk(s) ${missingChunksList.join(
 					", "
 				)}, module is in chunk(s) ${chunks.join(", ")})`;
+			};
+			statistics.incorrectChunks++;
 			failureCache.set(module, problem); // cache failures for performance
 			return problem;
 		}
 
-		// Add the module
-		config.add(module);
-
 		const moduleGraph = compilation.moduleGraph;
 
-		const incomingConnections = Array.from(
-			moduleGraph.getIncomingConnections(module)
-		).filter(connection => {
-			// We are not interested in inactive connections
-			if (!connection.isActive(runtime)) return false;
-
-			// Include, but do not analyse further, connections from non-modules
-			if (!connection.originModule) return true;
-
-			// Ignore connection from orphan modules
-			if (chunkGraph.getNumberOfModuleChunks(connection.originModule) === 0)
-				return false;
+		const incomingConnections = moduleGraph.getIncomingConnectionsByOriginModule(
+			module
+		);
 
-			// We don't care for connections from other runtimes
-			let originRuntime = undefined;
-			for (const r of chunkGraph.getModuleRuntimes(connection.originModule)) {
-				originRuntime = mergeRuntimeOwned(originRuntime, r);
+		const incomingConnectionsFromNonModules =
+			incomingConnections.get(null) || incomingConnections.get(undefined);
+		if (incomingConnectionsFromNonModules) {
+			const activeNonModulesConnections = incomingConnectionsFromNonModules.filter(
+				connection => {
+					// We are not interested in inactive connections
+					// or connections without dependency
+					return connection.isActive(runtime) || connection.dependency;
+				}
+			);
+			if (activeNonModulesConnections.length > 0) {
+				const problem = requestShortener => {
+					const importingExplanations = new Set(
+						activeNonModulesConnections.map(c => c.explanation).filter(Boolean)
+					);
+					const explanations = Array.from(importingExplanations).sort();
+					return `Module ${module.readableIdentifier(
+						requestShortener
+					)} is referenced ${
+						explanations.length > 0
+							? `by: ${explanations.join(", ")}`
+							: "in an unsupported way"
+					}`;
+				};
+				statistics.incorrectDependency++;
+				failureCache.set(module, problem); // cache failures for performance
+				return problem;
 			}
+		}
 
-			return intersectRuntime(runtime, originRuntime);
-		});
+		/** @type {Map<Module, readonly ModuleGraph.ModuleGraphConnection[]>} */
+		const incomingConnectionsFromModules = new Map();
+		for (const [originModule, connections] of incomingConnections) {
+			if (originModule) {
+				// Ignore connection from orphan modules
+				if (chunkGraph.getNumberOfModuleChunks(originModule) === 0) continue;
+
+				// We don't care for connections from other runtimes
+				let originRuntime = undefined;
+				for (const r of chunkGraph.getModuleRuntimes(originModule)) {
+					originRuntime = mergeRuntimeOwned(originRuntime, r);
+				}
 
-		const nonHarmonyConnections = incomingConnections.filter(
-			connection =>
-				!connection.originModule ||
-				!connection.dependency ||
-				!(connection.dependency instanceof HarmonyImportDependency)
-		);
-		if (nonHarmonyConnections.length > 0) {
-			const problem = requestShortener => {
-				const importingModules = new Set(
-					nonHarmonyConnections.map(c => c.originModule).filter(Boolean)
-				);
-				const importingExplanations = new Set(
-					nonHarmonyConnections.map(c => c.explanation).filter(Boolean)
-				);
-				const importingModuleTypes = new Map(
-					Array.from(importingModules).map(
-						m =>
-							/** @type {[Module, Set<string>]} */ ([
-								m,
-								new Set(
-									nonHarmonyConnections
-										.filter(c => c.originModule === m)
-										.map(c => c.dependency.type)
-										.sort()
-								)
-							])
-					)
+				if (!intersectRuntime(runtime, originRuntime)) continue;
+
+				// We are not interested in inactive connections
+				const activeConnections = connections.filter(connection =>
+					connection.isActive(runtime)
 				);
-				const names = Array.from(importingModules)
-					.map(
-						m =>
-							`${m.readableIdentifier(
-								requestShortener
-							)} (referenced with ${Array.from(
-								importingModuleTypes.get(m)
-							).join(", ")})`
-					)
-					.sort();
-				const explanations = Array.from(importingExplanations).sort();
-				if (names.length > 0 && explanations.length === 0) {
-					return `Module ${module.readableIdentifier(
-						requestShortener
-					)} is referenced from these modules with unsupported syntax: ${names.join(
-						", "
-					)}`;
-				} else if (names.length === 0 && explanations.length > 0) {
-					return `Module ${module.readableIdentifier(
-						requestShortener
-					)} is referenced by: ${explanations.join(", ")}`;
-				} else if (names.length > 0 && explanations.length > 0) {
-					return `Module ${module.readableIdentifier(
-						requestShortener
-					)} is referenced from these modules with unsupported syntax: ${names.join(
-						", "
-					)} and by: ${explanations.join(", ")}`;
-				} else {
-					return `Module ${module.readableIdentifier(
-						requestShortener
-					)} is referenced in a unsupported way`;
-				}
-			};
-			failureCache.set(module, problem); // cache failures for performance
-			return problem;
+				if (activeConnections.length > 0)
+					incomingConnectionsFromModules.set(originModule, activeConnections);
+			}
 		}
 
+		const incomingModules = Array.from(incomingConnectionsFromModules.keys());
+
 		// Module must be in the same chunks like the referencing module
-		const otherChunkConnections = incomingConnections.filter(connection => {
+		const otherChunkModules = incomingModules.filter(originModule => {
 			for (const chunk of chunkGraph.getModuleChunksIterable(
 				config.rootModule
 			)) {
-				if (!chunkGraph.isModuleInChunk(connection.originModule, chunk)) {
+				if (!chunkGraph.isModuleInChunk(originModule, chunk)) {
 					return true;
 				}
 			}
 			return false;
 		});
-		if (otherChunkConnections.length > 0) {
+		if (otherChunkModules.length > 0) {
 			const problem = requestShortener => {
-				const importingModules = new Set(
-					otherChunkConnections.map(c => c.originModule)
-				);
-				const names = Array.from(importingModules)
+				const names = otherChunkModules
 					.map(m => m.readableIdentifier(requestShortener))
 					.sort();
 				return `Module ${module.readableIdentifier(
@@ -676,41 +653,90 @@ class ModuleConcatenationPlugin {
 					", "
 				)}`;
 			};
+			statistics.incorrectChunksOfImporter++;
+			failureCache.set(module, problem); // cache failures for performance
+			return problem;
+		}
+
+		/** @type {Map<Module, readonly ModuleGraph.ModuleGraphConnection[]>} */
+		const nonHarmonyConnections = new Map();
+		for (const [originModule, connections] of incomingConnectionsFromModules) {
+			const selected = connections.filter(
+				connection =>
+					!connection.dependency ||
+					!(connection.dependency instanceof HarmonyImportDependency)
+			);
+			if (selected.length > 0)
+				nonHarmonyConnections.set(originModule, connections);
+		}
+		if (nonHarmonyConnections.size > 0) {
+			const problem = requestShortener => {
+				const names = Array.from(nonHarmonyConnections)
+					.map(([originModule, connections]) => {
+						return `${originModule.readableIdentifier(
+							requestShortener
+						)} (referenced with ${Array.from(
+							new Set(
+								connections
+									.map(c => c.dependency && c.dependency.type)
+									.filter(Boolean)
+							)
+						)
+							.sort()
+							.join(", ")})`;
+					})
+					.sort();
+				return `Module ${module.readableIdentifier(
+					requestShortener
+				)} is referenced from these modules with unsupported syntax: ${names.join(
+					", "
+				)}`;
+			};
+			statistics.incorrectModuleDependency++;
 			failureCache.set(module, problem); // cache failures for performance
 			return problem;
 		}
 
 		if (runtime !== undefined && typeof runtime !== "string") {
 			// Module must be consistently referenced in the same runtimes
-			/** @type {Map<Module, boolean | RuntimeSpec>} */
-			const runtimeConditionMap = new Map();
-			for (const connection of incomingConnections) {
-				const runtimeCondition = filterRuntime(runtime, runtime => {
-					return connection.isTargetActive(runtime);
-				});
-				if (runtimeCondition === false) continue;
-				const old = runtimeConditionMap.get(connection.originModule) || false;
-				if (old === true) continue;
-				if (old !== false && runtimeCondition !== true) {
-					runtimeConditionMap.set(
-						connection.originModule,
-						mergeRuntime(old, runtimeCondition)
-					);
-				} else {
-					runtimeConditionMap.set(connection.originModule, runtimeCondition);
+			/** @type {{ originModule: Module, runtimeCondition: RuntimeSpec }[]} */
+			const otherRuntimeConnections = [];
+			outer: for (const [
+				originModule,
+				connections
+			] of incomingConnectionsFromModules) {
+				/** @type {false | RuntimeSpec} */
+				let currentRuntimeCondition = false;
+				for (const connection of connections) {
+					const runtimeCondition = filterRuntime(runtime, runtime => {
+						return connection.isTargetActive(runtime);
+					});
+					if (runtimeCondition === false) continue;
+					if (runtimeCondition === true) continue outer;
+					if (currentRuntimeCondition !== false) {
+						currentRuntimeCondition = mergeRuntime(
+							currentRuntimeCondition,
+							runtimeCondition
+						);
+					} else {
+						currentRuntimeCondition = runtimeCondition;
+					}
+				}
+				if (currentRuntimeCondition !== false) {
+					otherRuntimeConnections.push({
+						originModule,
+						runtimeCondition: currentRuntimeCondition
+					});
 				}
 			}
-			const otherRuntimeConnections = Array.from(runtimeConditionMap).filter(
-				([, runtimeCondition]) => typeof runtimeCondition !== "boolean"
-			);
 			if (otherRuntimeConnections.length > 0) {
 				const problem = requestShortener => {
 					return `Module ${module.readableIdentifier(
 						requestShortener
 					)} is runtime-dependent referenced by these modules: ${Array.from(
 						otherRuntimeConnections,
-						([module, runtimeCondition]) =>
-							`${module.readableIdentifier(
+						({ originModule, runtimeCondition }) =>
+							`${originModule.readableIdentifier(
 								requestShortener
 							)} (expected runtime ${runtimeToString(
 								runtime
@@ -719,14 +745,21 @@ class ModuleConcatenationPlugin {
 							)})`
 					).join(", ")}`;
 				};
+				statistics.incorrectRuntimeCondition++;
 				failureCache.set(module, problem); // cache failures for performance
 				return problem;
 			}
 		}
 
-		const incomingModules = Array.from(
-			new Set(incomingConnections.map(c => c.originModule))
-		).sort(compareModulesByIdentifier);
+		let backup;
+		if (avoidMutateOnFailure) {
+			backup = config.snapshot();
+		}
+
+		// Add the module
+		config.add(module);
+
+		incomingModules.sort(compareModulesByIdentifier);
 
 		// Every module which depends on the added module must be in the configuration too.
 		for (const originModule of incomingModules) {
@@ -739,9 +772,13 @@ class ModuleConcatenationPlugin {
 				possibleModules,
 				candidates,
 				failureCache,
-				chunkGraph
+				chunkGraph,
+				false,
+				statistics
 			);
 			if (problem) {
+				if (backup !== undefined) config.rollback(backup);
+				statistics.importerFailed++;
 				failureCache.set(module, problem); // cache failures for performance
 				return problem;
 			}
@@ -751,6 +788,7 @@ class ModuleConcatenationPlugin {
 		for (const imp of this._getImports(compilation, module, runtime)) {
 			candidates.add(imp);
 		}
+		statistics.added++;
 		return null;
 	}
 }
@@ -763,15 +801,15 @@ class ConcatConfiguration {
 	constructor(rootModule, runtime) {
 		this.rootModule = rootModule;
 		this.runtime = runtime;
-		/** @type {StackedMap<Module, true>} */
-		this.modules = new StackedMap();
-		this.modules.set(rootModule, true);
-		/** @type {StackedMap<Module, Module | function(RequestShortener): string>} */
-		this.warnings = new StackedMap();
+		/** @type {Set<Module>} */
+		this.modules = new Set();
+		this.modules.add(rootModule);
+		/** @type {Map<Module, Module | function(RequestShortener): string>} */
+		this.warnings = new Map();
 	}
 
 	add(module) {
-		this.modules.set(module, true);
+		this.modules.add(module);
 	}
 
 	has(module) {
@@ -788,7 +826,7 @@ class ConcatConfiguration {
 
 	getWarningsSorted() {
 		return new Map(
-			this.warnings.asPairArray().sort((a, b) => {
+			Array.from(this.warnings).sort((a, b) => {
 				const ai = a[0].identifier();
 				const bi = b[0].identifier();
 				if (ai < bi) return -1;
@@ -802,17 +840,22 @@ class ConcatConfiguration {
 	 * @returns {Set<Module>} modules as set
 	 */
 	getModules() {
-		return this.modules.asSet();
+		return this.modules;
 	}
 
 	snapshot() {
-		const base = this.modules;
-		this.modules = this.modules.createChild();
-		return base;
+		return this.modules.size;
 	}
 
 	rollback(snapshot) {
-		this.modules = snapshot;
+		const modules = this.modules;
+		for (const m of modules) {
+			if (snapshot === 0) {
+				modules.delete(m);
+			} else {
+				snapshot--;
+			}
+		}
 	}
 }