webpack 5.54.0 → 5.56.1

package/lib/Compilation.js

@@ -25,6 +25,7 @@ const ChunkRenderError = require("./ChunkRenderError");
 const ChunkTemplate = require("./ChunkTemplate");
 const CodeGenerationError = require("./CodeGenerationError");
 const CodeGenerationResults = require("./CodeGenerationResults");
+const Dependency = require("./Dependency");
 const DependencyTemplates = require("./DependencyTemplates");
 const Entrypoint = require("./Entrypoint");
 const ErrorHelpers = require("./ErrorHelpers");
@@ -38,7 +39,6 @@ const {
 	tryRunOrWebpackError
 } = require("./HookWebpackError");
 const MainTemplate = require("./MainTemplate");
-const MemCache = require("./MemCache");
 const Module = require("./Module");
 const ModuleDependencyError = require("./ModuleDependencyError");
 const ModuleDependencyWarning = require("./ModuleDependencyWarning");
@@ -61,6 +61,7 @@ const { equals: arrayEquals } = require("./util/ArrayHelpers");
 const AsyncQueue = require("./util/AsyncQueue");
 const LazySet = require("./util/LazySet");
 const { provide } = require("./util/MapHelpers");
+const WeakTupleMap = require("./util/WeakTupleMap");
 const { cachedCleverMerge } = require("./util/cleverMerge");
 const {
 	compareLocations,
@@ -77,7 +78,7 @@ const {
 	createFakeHook
 } = require("./util/deprecation");
 const processAsyncTree = require("./util/processAsyncTree");
-const { getRuntimeKey, RuntimeSpecMap } = require("./util/runtime");
+const { getRuntimeKey } = require("./util/runtime");
 const { isSourceEqual } = require("./util/source");
 
 /** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
@@ -92,8 +93,8 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./CacheFacade")} CacheFacade */
 /** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Compiler").CompilationParams} CompilationParams */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("./DependencyTemplate")} DependencyTemplate */
@@ -101,6 +102,7 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./ModuleFactory")} ModuleFactory */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */
+/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./RuntimeModule")} RuntimeModule */
 /** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry */
@@ -125,6 +127,20 @@ const { isSourceEqual } = require("./util/source");
  * @returns {void}
  */
 
+/**
+ * @callback ModuleFactoryResultCallback
+ * @param {WebpackError=} err
+ * @param {ModuleFactoryResult=} result
+ * @returns {void}
+ */
+
+/**
+ * @callback ModuleOrFactoryResultCallback
+ * @param {WebpackError=} err
+ * @param {Module | ModuleFactoryResult=} result
+ * @returns {void}
+ */
+
 /**
  * @callback ExecuteModuleCallback
  * @param {WebpackError=} err
@@ -400,12 +416,19 @@ const byLocation = compareSelect(err => err.loc, compareLocations);
 
 const compareErrors = concatComparators(byModule, byLocation, byMessage);
 
+/** @type {WeakMap<Dependency, Module & { restoreFromUnsafeCache: Function }>} */
+const unsafeCacheDependencies = new WeakMap();
+
+/** @type {WeakMap<Module, object>} */
+const unsafeCacheData = new WeakMap();
+
 class Compilation {
 	/**
 	 * Creates an instance of Compilation.
 	 * @param {Compiler} compiler the compiler which created the compilation
+	 * @param {CompilationParams} params the compilation parameters
 	 */
-	constructor(compiler) {
+	constructor(compiler, params) {
 		const getNormalModuleLoader = () => deprecatedNormalModuleLoaderHook(this);
 		/** @typedef {{ additionalAssets?: true | Function }} ProcessAssetsAdditionalOptions */
 		/** @type {AsyncSeriesHook<[CompilationAssets], ProcessAssetsAdditionalOptions>} */
@@ -880,6 +903,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		/** @type {boolean} */
 		this.profile = (options && options.profile) || false;
 
+		this.params = params;
 		this.mainTemplate = new MainTemplate(this.outputOptions, this);
 		this.chunkTemplate = new ChunkTemplate(this.outputOptions, this);
 		this.runtimeTemplate = new RuntimeTemplate(
@@ -893,9 +917,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		};
 		defineRemovedModuleTemplates(this.moduleTemplates);
 
-		/** @type {MemCache | undefined} */
-		this.memCache = undefined;
-		/** @type {WeakMap<Module, MemCache> | undefined} */
+		/** @type {WeakMap<Module, WeakTupleMap<any, any>> | undefined} */
 		this.moduleMemCaches = undefined;
 		this.moduleGraph = new ModuleGraph();
 		/** @type {ChunkGraph} */
@@ -916,7 +938,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			getKey: module => module.identifier(),
 			processor: this._addModule.bind(this)
 		});
-		/** @type {AsyncQueue<FactorizeModuleOptions, string, Module>} */
+		/** @type {AsyncQueue<FactorizeModuleOptions, string, Module | ModuleFactoryResult>} */
 		this.factorizeQueue = new AsyncQueue({
 			name: "factorize",
 			parent: this.addModuleQueue,
@@ -999,6 +1021,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.usedModuleIds = null;
 		/** @type {boolean} */
 		this.needAdditionalPass = false;
+		/** @type {Set<Module>} */
+		this._restoredUnsafeCacheEntries = new Set();
 		/** @type {WeakSet<Module>} */
 		this.builtModules = new WeakSet();
 		/** @type {WeakSet<Module>} */
@@ -1031,6 +1055,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this._modulesCache = this.getCache("Compilation/modules");
 		this._assetsCache = this.getCache("Compilation/assets");
 		this._codeGenerationCache = this.getCache("Compilation/codeGeneration");
+
+		const unsafeCache = options.module.unsafeCache;
+		this._unsafeCache = !!unsafeCache;
+		this._unsafeCachePredicate =
+			typeof unsafeCache === "function" ? unsafeCache : () => true;
 	}
 
 	getStats() {
@@ -1415,12 +1444,44 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		/** @type {Dependency[]} */
 		let listCacheValue;
 
+		const unsafeRestoredModules = new Set();
+
 		/**
 		 * @param {Dependency} dep dependency
 		 * @returns {void}
 		 */
 		const processDependency = dep => {
 			this.moduleGraph.setParents(dep, currentBlock, module);
+			if (this._unsafeCache) {
+				try {
+					const cachedModule = unsafeCacheDependencies.get(dep);
+					if (cachedModule === null) return;
+					if (cachedModule !== undefined) {
+						if (!this._restoredUnsafeCacheEntries.has(cachedModule)) {
+							const data = unsafeCacheData.get(cachedModule);
+							cachedModule.restoreFromUnsafeCache(
+								data,
+								this.params.normalModuleFactory,
+								this.params
+							);
+							this._restoredUnsafeCacheEntries.add(cachedModule);
+							if (!this.modules.has(cachedModule)) {
+								this._handleNewModuleFromUnsafeCache(module, dep, cachedModule);
+								unsafeRestoredModules.add(cachedModule);
+								return;
+							}
+						}
+						this._handleExistingModuleFromUnsafeCache(
+							module,
+							dep,
+							cachedModule
+						);
+						return;
+					}
+				} catch (e) {
+					console.error(e);
+				}
+			}
 			const resourceIdent = dep.getResourceIdentifier();
 			if (resourceIdent !== undefined && resourceIdent !== null) {
 				const category = dep.category;
@@ -1504,7 +1565,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			return callback(e);
 		}
 
-		if (sortedDependencies.length === 0) {
+		if (sortedDependencies.length === 0 && unsafeRestoredModules.size === 0) {
 			callback();
 			return;
 		}
@@ -1512,27 +1573,78 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		// This is nested so we need to allow one additional task
 		this.processDependenciesQueue.increaseParallelism();
 
-		asyncLib.forEach(
-			sortedDependencies,
-			(item, callback) => {
-				this.handleModuleCreation(item, err => {
-					// In V8, the Error objects keep a reference to the functions on the stack. These warnings &
-					// errors are created inside closures that keep a reference to the Compilation, so errors are
-					// leaking the Compilation object.
-					if (err && this.bail) {
-						// eslint-disable-next-line no-self-assign
-						err.stack = err.stack;
-						return callback(err);
-					}
-					callback();
-				});
-			},
-			err => {
-				this.processDependenciesQueue.decreaseParallelism();
+		const processSortedDependency = (item, callback) => {
+			this.handleModuleCreation(item, err => {
+				// In V8, the Error objects keep a reference to the functions on the stack. These warnings &
+				// errors are created inside closures that keep a reference to the Compilation, so errors are
+				// leaking the Compilation object.
+				if (err && this.bail) {
+					// eslint-disable-next-line no-self-assign
+					err.stack = err.stack;
+					return callback(err);
+				}
+				callback();
+			});
+		};
 
-				return callback(err);
-			}
+		const processUnsafeRestoredModule = (item, callback) => {
+			this._handleModuleBuildAndDependencies(module, item, true, callback);
+		};
+
+		const finalCallback = err => {
+			this.processDependenciesQueue.decreaseParallelism();
+
+			return callback(err);
+		};
+
+		if (sortedDependencies.length === 0) {
+			asyncLib.forEach(
+				unsafeRestoredModules,
+				processUnsafeRestoredModule,
+				finalCallback
+			);
+		} else if (unsafeRestoredModules.size === 0) {
+			asyncLib.forEach(
+				sortedDependencies,
+				processSortedDependency,
+				finalCallback
+			);
+		} else {
+			asyncLib.parallel(
+				[
+					cb =>
+						asyncLib.forEach(
+							unsafeRestoredModules,
+							processUnsafeRestoredModule,
+							cb
+						),
+					cb =>
+						asyncLib.forEach(sortedDependencies, processSortedDependency, cb)
+				],
+				finalCallback
+			);
+		}
+	}
+
+	_handleNewModuleFromUnsafeCache(originModule, dependency, module) {
+		const moduleGraph = this.moduleGraph;
+
+		moduleGraph.setResolvedModule(originModule, dependency, module);
+
+		moduleGraph.setIssuerIfUnset(
+			module,
+			originModule !== undefined ? originModule : null
 		);
+
+		this._modules.set(module.identifier(), module);
+		this.modules.add(module);
+		ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+	}
+
+	_handleExistingModuleFromUnsafeCache(originModule, dependency, module) {
+		const moduleGraph = this.moduleGraph;
+
+		moduleGraph.setResolvedModule(originModule, dependency, module);
 	}
 
 	/**
@@ -1572,12 +1684,27 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				currentProfile,
 				factory,
 				dependencies,
+				factoryResult: true,
 				originModule,
 				contextInfo,
 				context
 			},
-			(err, newModule) => {
+			(err, factoryResult) => {
+				const applyFactoryResultDependencies = () => {
+					const { fileDependencies, contextDependencies, missingDependencies } =
+						factoryResult;
+					if (fileDependencies) {
+						this.fileDependencies.addAll(fileDependencies);
+					}
+					if (contextDependencies) {
+						this.contextDependencies.addAll(contextDependencies);
+					}
+					if (missingDependencies) {
+						this.missingDependencies.addAll(missingDependencies);
+					}
+				};
 				if (err) {
+					if (factoryResult) applyFactoryResultDependencies();
 					if (dependencies.every(d => d.optional)) {
 						this.warnings.push(err);
 						return callback();
@@ -1587,7 +1714,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					}
 				}
 
+				const newModule = factoryResult.module;
+
 				if (!newModule) {
+					applyFactoryResultDependencies();
 					return callback();
 				}
 
@@ -1597,6 +1727,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 				this.addModule(newModule, (err, module) => {
 					if (err) {
+						applyFactoryResultDependencies();
 						if (!err.module) {
 							err.module = module;
 						}
@@ -1605,13 +1736,37 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						return callback(err);
 					}
 
-					for (let i = 0; i < dependencies.length; i++) {
-						const dependency = dependencies[i];
-						moduleGraph.setResolvedModule(
-							connectOrigin ? originModule : null,
-							dependency,
-							module
-						);
+					if (
+						this._unsafeCache &&
+						factoryResult.cacheable !== false &&
+						/** @type {any} */ (module).restoreFromUnsafeCache &&
+						this._unsafeCachePredicate(module)
+					) {
+						for (let i = 0; i < dependencies.length; i++) {
+							const dependency = dependencies[i];
+							moduleGraph.setResolvedModule(
+								connectOrigin ? originModule : null,
+								dependency,
+								module
+							);
+							unsafeCacheDependencies.set(
+								dependency,
+								/** @type {any} */ (module)
+							);
+						}
+						if (!unsafeCacheData.has(module)) {
+							unsafeCacheData.set(module, module.getUnsafeCacheData());
+						}
+					} else {
+						applyFactoryResultDependencies();
+						for (let i = 0; i < dependencies.length; i++) {
+							const dependency = dependencies[i];
+							moduleGraph.setResolvedModule(
+								connectOrigin ? originModule : null,
+								dependency,
+								module
+							);
+						}
 					}
 
 					moduleGraph.setIssuerIfUnset(
@@ -1629,99 +1784,89 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						}
 					}
 
-					// Check for cycles when build is trigger inside another build
-					let creatingModuleDuringBuildSet = undefined;
-					if (!recursive && this.buildQueue.isProcessing(originModule)) {
-						// Track build dependency
-						creatingModuleDuringBuildSet =
-							this.creatingModuleDuringBuild.get(originModule);
-						if (creatingModuleDuringBuildSet === undefined) {
-							creatingModuleDuringBuildSet = new Set();
-							this.creatingModuleDuringBuild.set(
-								originModule,
-								creatingModuleDuringBuildSet
-							);
-						}
-						creatingModuleDuringBuildSet.add(originModule);
-
-						// When building is blocked by another module
-						// search for a cycle, cancel the cycle by throwing
-						// an error (otherwise this would deadlock)
-						const blockReasons = this.creatingModuleDuringBuild.get(module);
-						if (blockReasons !== undefined) {
-							const set = new Set(blockReasons);
-							for (const item of set) {
-								const blockReasons = this.creatingModuleDuringBuild.get(item);
-								if (blockReasons !== undefined) {
-									for (const m of blockReasons) {
-										if (m === module) {
-											return callback(new BuildCycleError(module));
-										}
-										set.add(m);
-									}
-								}
-							}
-						}
-					}
+					this._handleModuleBuildAndDependencies(
+						originModule,
+						module,
+						recursive,
+						callback
+					);
+				});
+			}
+		);
+	}
 
-					this.buildModule(module, err => {
-						if (creatingModuleDuringBuildSet !== undefined) {
-							creatingModuleDuringBuildSet.delete(module);
-						}
-						if (err) {
-							if (!err.module) {
-								err.module = module;
+	_handleModuleBuildAndDependencies(originModule, module, recursive, callback) {
+		// Check for cycles when build is trigger inside another build
+		let creatingModuleDuringBuildSet = undefined;
+		if (!recursive && this.buildQueue.isProcessing(originModule)) {
+			// Track build dependency
+			creatingModuleDuringBuildSet =
+				this.creatingModuleDuringBuild.get(originModule);
+			if (creatingModuleDuringBuildSet === undefined) {
+				creatingModuleDuringBuildSet = new Set();
+				this.creatingModuleDuringBuild.set(
+					originModule,
+					creatingModuleDuringBuildSet
+				);
+			}
+			creatingModuleDuringBuildSet.add(originModule);
+
+			// When building is blocked by another module
+			// search for a cycle, cancel the cycle by throwing
+			// an error (otherwise this would deadlock)
+			const blockReasons = this.creatingModuleDuringBuild.get(module);
+			if (blockReasons !== undefined) {
+				const set = new Set(blockReasons);
+				for (const item of set) {
+					const blockReasons = this.creatingModuleDuringBuild.get(item);
+					if (blockReasons !== undefined) {
+						for (const m of blockReasons) {
+							if (m === module) {
+								return callback(new BuildCycleError(module));
 							}
-							this.errors.push(err);
-
-							return callback(err);
+							set.add(m);
 						}
+					}
+				}
+			}
+		}
 
-						if (!recursive) {
-							this.processModuleDependenciesNonRecursive(module);
-							callback(null, module);
-							return;
-						}
+		this.buildModule(module, err => {
+			if (creatingModuleDuringBuildSet !== undefined) {
+				creatingModuleDuringBuildSet.delete(module);
+			}
+			if (err) {
+				if (!err.module) {
+					err.module = module;
+				}
+				this.errors.push(err);
 
-						// This avoids deadlocks for circular dependencies
-						if (this.processDependenciesQueue.isProcessing(module)) {
-							return callback();
-						}
+				return callback(err);
+			}
 
-						this.processModuleDependencies(module, err => {
-							if (err) {
-								return callback(err);
-							}
-							callback(null, module);
-						});
-					});
-				});
+			if (!recursive) {
+				this.processModuleDependenciesNonRecursive(module);
+				callback(null, module);
+				return;
 			}
-		);
-	}
 
-	/**
-	 * @typedef {Object} FactorizeModuleOptions
-	 * @property {ModuleProfile} currentProfile
-	 * @property {ModuleFactory} factory
-	 * @property {Dependency[]} dependencies
-	 * @property {Module | null} originModule
-	 * @property {Partial<ModuleFactoryCreateDataContextInfo>=} contextInfo
-	 * @property {string=} context
-	 */
+			// This avoids deadlocks for circular dependencies
+			if (this.processDependenciesQueue.isProcessing(module)) {
+				return callback();
+			}
 
-	/**
-	 * @param {FactorizeModuleOptions} options options object
-	 * @param {ModuleCallback} callback callback
-	 * @returns {void}
-	 */
-	factorizeModule(options, callback) {
-		this.factorizeQueue.add(options, callback);
+			this.processModuleDependencies(module, err => {
+				if (err) {
+					return callback(err);
+				}
+				callback(null, module);
+			});
+		});
 	}
 
 	/**
 	 * @param {FactorizeModuleOptions} options options object
-	 * @param {ModuleCallback} callback callback
+	 * @param {ModuleOrFactoryResultCallback} callback callback
 	 * @returns {void}
 	 */
 	_factorizeModule(
@@ -1730,6 +1875,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			factory,
 			dependencies,
 			originModule,
+			factoryResult,
 			contextInfo,
 			context
 		},
@@ -1763,16 +1909,21 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 							module: result
 						};
 					}
-					const { fileDependencies, contextDependencies, missingDependencies } =
-						result;
-					if (fileDependencies) {
-						this.fileDependencies.addAll(fileDependencies);
-					}
-					if (contextDependencies) {
-						this.contextDependencies.addAll(contextDependencies);
-					}
-					if (missingDependencies) {
-						this.missingDependencies.addAll(missingDependencies);
+					if (!factoryResult) {
+						const {
+							fileDependencies,
+							contextDependencies,
+							missingDependencies
+						} = result;
+						if (fileDependencies) {
+							this.fileDependencies.addAll(fileDependencies);
+						}
+						if (contextDependencies) {
+							this.contextDependencies.addAll(contextDependencies);
+						}
+						if (missingDependencies) {
+							this.missingDependencies.addAll(missingDependencies);
+						}
 					}
 				}
 				if (err) {
@@ -1781,20 +1932,17 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						err,
 						dependencies.map(d => d.loc).filter(Boolean)[0]
 					);
-					return callback(notFoundError);
+					return callback(notFoundError, factoryResult ? result : undefined);
 				}
 				if (!result) {
 					return callback();
 				}
-				const newModule = result.module;
-				if (!newModule) {
-					return callback();
-				}
+
 				if (currentProfile !== undefined) {
 					currentProfile.markFactoryEnd();
 				}
 
-				callback(null, newModule);
+				callback(null, factoryResult ? result : result.module);
 			}
 		);
 	}
@@ -2020,64 +2168,143 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	_computeAffectedModules(modules) {
 		const moduleMemCacheCache = this.compiler.moduleMemCaches;
 		if (!moduleMemCacheCache) return;
-		if (!this.moduleMemCaches) this.moduleMemCaches = new WeakMap();
-		if (!this.memCache) this.memCache = new MemCache();
-		const { moduleGraph, memCache, moduleMemCaches } = this;
+		if (!this.moduleMemCaches) {
+			this.moduleMemCaches = new WeakMap();
+			this.moduleGraph.setModuleMemCaches(this.moduleMemCaches);
+		}
+		const { moduleGraph, moduleMemCaches } = this;
 		const affectedModules = new Set();
 		const infectedModules = new Set();
 		let statNew = 0;
 		let statChanged = 0;
 		let statUnchanged = 0;
+		let statReferencesChanged = 0;
 		let statWithoutHash = 0;
+
+		const computeReferences = module => {
+			/** @type {WeakMap<Dependency, Module>} */
+			let references = undefined;
+			for (const connection of moduleGraph.getOutgoingConnections(module)) {
+				const d = connection.dependency;
+				const m = connection.module;
+				if (!d || !m || unsafeCacheDependencies.has(d)) continue;
+				if (references === undefined) references = new WeakMap();
+				references.set(d, m);
+			}
+			return references;
+		};
+
+		/**
+		 * @param {Module} module the module
+		 * @param {WeakMap<Dependency, Module>} references references
+		 * @returns {boolean} true, when the references differ
+		 */
+		const compareReferences = (module, references) => {
+			if (references === undefined) return true;
+			for (const connection of moduleGraph.getOutgoingConnections(module)) {
+				const d = connection.dependency;
+				if (!d) continue;
+				const entry = references.get(d);
+				if (entry === undefined) continue;
+				if (entry !== connection.module) return false;
+			}
+			return true;
+		};
+
 		for (const module of modules) {
 			const hash = module.buildInfo && module.buildInfo.hash;
 			if (typeof hash === "string") {
 				const cachedMemCache = moduleMemCacheCache.get(module);
 				if (cachedMemCache === undefined) {
 					// create a new entry
+					const memCache = new WeakTupleMap();
 					moduleMemCacheCache.set(module, {
 						hash: hash,
+						references: computeReferences(module),
 						memCache
 					});
 					moduleMemCaches.set(module, memCache);
 					affectedModules.add(module);
 					statNew++;
-				} else if (cachedMemCache.hash === hash) {
-					// keep the old mem cache
-					moduleMemCaches.set(module, cachedMemCache.memCache);
-					statUnchanged++;
-				} else {
+				} else if (cachedMemCache.hash !== hash) {
 					// use a new one
+					const memCache = new WeakTupleMap();
 					moduleMemCaches.set(module, memCache);
 					affectedModules.add(module);
 					cachedMemCache.hash = hash;
+					cachedMemCache.references = computeReferences(module);
 					cachedMemCache.memCache = memCache;
 					statChanged++;
+				} else if (!compareReferences(module, cachedMemCache.references)) {
+					// use a new one
+					const memCache = new WeakTupleMap();
+					moduleMemCaches.set(module, memCache);
+					affectedModules.add(module);
+					cachedMemCache.references = computeReferences(module);
+					cachedMemCache.memCache = memCache;
+					statReferencesChanged++;
+				} else {
+					// keep the old mem cache
+					moduleMemCaches.set(module, cachedMemCache.memCache);
+					statUnchanged++;
 				}
 			} else {
 				infectedModules.add(module);
 				statWithoutHash++;
 			}
 		}
+		const reduceAffectType = connections => {
+			let affected = false;
+			for (const { dependency } of connections) {
+				if (!dependency) continue;
+				const type = dependency.couldAffectReferencingModule();
+				if (type === Dependency.TRANSITIVE) return Dependency.TRANSITIVE;
+				if (type === false) continue;
+				affected = true;
+			}
+			return affected;
+		};
+		const directOnlyInfectedModules = new Set();
 		for (const module of infectedModules) {
-			for (const referencingModule of moduleGraph
-				.getIncomingConnectionsByOriginModule(module)
-				.keys()) {
+			for (const [
+				referencingModule,
+				connections
+			] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+				if (!referencingModule) continue;
 				if (infectedModules.has(referencingModule)) continue;
-				infectedModules.add(referencingModule);
+				const type = reduceAffectType(connections);
+				if (!type) continue;
+				if (type === true) {
+					directOnlyInfectedModules.add(referencingModule);
+				} else {
+					infectedModules.add(referencingModule);
+				}
 			}
 		}
+		for (const module of directOnlyInfectedModules) infectedModules.add(module);
+		const directOnlyAffectModules = new Set();
 		for (const module of affectedModules) {
-			for (const referencingModule of moduleGraph
-				.getIncomingConnectionsByOriginModule(module)
-				.keys()) {
+			for (const [
+				referencingModule,
+				connections
+			] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
 				if (!referencingModule) continue;
 				if (infectedModules.has(referencingModule)) continue;
 				if (affectedModules.has(referencingModule)) continue;
-				affectedModules.add(referencingModule);
+				const type = reduceAffectType(connections);
+				if (!type) continue;
+				if (type === true) {
+					directOnlyAffectModules.add(referencingModule);
+				} else {
+					affectedModules.add(referencingModule);
+				}
+				const memCache = new WeakTupleMap();
+				const cache = moduleMemCacheCache.get(referencingModule);
+				cache.memCache = memCache;
 				moduleMemCaches.set(referencingModule, memCache);
 			}
 		}
+		for (const module of directOnlyAffectModules) affectedModules.add(module);
 		this.logger.log(
 			`${Math.round(
 				(100 * (affectedModules.size + infectedModules.size)) /
@@ -2086,7 +2313,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				infectedModules.size
 			} infected of ${
 				this.modules.size
-			}) modules flagged as affected (${statNew} new modules, ${statChanged} changed, ${statUnchanged} unchanged, ${statWithoutHash} without hash)`
+			}) modules flagged as affected (${statNew} new modules, ${statChanged} changed, ${statReferencesChanged} references changed, ${statUnchanged} unchanged, ${statWithoutHash} without hash)`
 		);
 	}
 
@@ -2280,7 +2507,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			if (err) return callback(err);
 
 			// extract warnings and errors from modules
-			this.moduleGraph.freeze();
+			this.moduleGraph.freeze("dependency errors");
 			// TODO keep a cacheToken (= {}) for each module in the graph
 			// create a new one per compilation and flag all updated files
 			// and parents with it
@@ -2289,7 +2516,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				// TODO only run for modules with changed cacheToken
 				// global WeakMap<CacheToken, WeakSet<Module>> to keep modules without errors/warnings
 				const memCache = moduleMemCaches && moduleMemCaches.get(module);
-				if (memCache && memCache.get(module, "noWarningsOrErrors")) continue;
+				if (memCache && memCache.get("noWarningsOrErrors")) continue;
 				let hasProblems = this.reportDependencyErrorsAndWarnings(module, [
 					module
 				]);
@@ -2313,8 +2540,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						hasProblems = true;
 					}
 				}
-				if (!hasProblems && memCache)
-					memCache.set(module, "noWarningsOrErrors", true);
+				if (!hasProblems && memCache) memCache.set("noWarningsOrErrors", true);
 			}
 			this.moduleGraph.unfreeze();
 			this.logger.timeEnd("report dependency errors and warnings");
@@ -2371,7 +2597,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 		this.logger.time("create chunks");
 		this.hooks.beforeChunks.call();
-		this.moduleGraph.freeze();
+		this.moduleGraph.freeze("seal");
 		/** @type {Map<Entrypoint, Module[]>} */
 		const chunkGraphInit = new Map();
 		for (const [name, { dependencies, includeDependencies, options }] of this
@@ -2907,17 +3133,11 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					// modules with async blocks depend on the chunk graph and can't be cached that way
 					module.blocks.length === 0 &&
 					moduleMemCaches.get(module);
-				/** @type {RuntimeSpecMap<Set<string>>} */
-				const moduleRuntimeRequirementsMemCache =
-					memCache &&
-					memCache.provide(
-						module,
-						"moduleRuntimeRequirements",
-						() => new RuntimeSpecMap()
-					);
 				for (const runtime of chunkGraph.getModuleRuntimes(module)) {
-					if (moduleRuntimeRequirementsMemCache) {
-						const cached = moduleRuntimeRequirementsMemCache.get(runtime);
+					if (memCache) {
+						const cached = memCache.get(
+							`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`
+						);
 						if (cached !== undefined) {
 							if (cached !== null) {
 								chunkGraph.addModuleRuntimeRequirements(
@@ -2938,8 +3158,11 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					} else if (additionalModuleRuntimeRequirements.isUsed()) {
 						set = new Set();
 					} else {
-						if (moduleRuntimeRequirementsMemCache) {
-							moduleRuntimeRequirementsMemCache.set(runtime, null);
+						if (memCache) {
+							memCache.set(
+								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
+								null
+							);
 						}
 						continue;
 					}
@@ -2950,12 +3173,18 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						if (hook !== undefined) hook.call(module, set, context);
 					}
 					if (set.size === 0) {
-						if (moduleRuntimeRequirementsMemCache) {
-							moduleRuntimeRequirementsMemCache.set(runtime, null);
+						if (memCache) {
+							memCache.set(
+								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
+								null
+							);
 						}
 					} else {
-						if (moduleRuntimeRequirementsMemCache) {
-							moduleRuntimeRequirementsMemCache.set(runtime, set);
+						if (memCache) {
+							memCache.set(
+								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
+								set
+							);
 							chunkGraph.addModuleRuntimeRequirements(
 								module,
 								runtime,
@@ -3368,13 +3597,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				// modules with async blocks depend on the chunk graph and can't be cached that way
 				module.blocks.length === 0 &&
 				moduleMemCaches.get(module);
-			/** @type {RuntimeSpecMap<string>} */
-			const moduleHashesMemCache =
-				memCache &&
-				memCache.provide(module, "moduleHashes", () => new RuntimeSpecMap());
 			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
-				if (moduleHashesMemCache) {
-					const digest = moduleHashesMemCache.get(runtime);
+				if (memCache) {
+					const digest = memCache.get(`moduleHash-${getRuntimeKey(runtime)}`);
 					if (digest !== undefined) {
 						chunkGraph.setModuleHashes(
 							module,
@@ -3396,8 +3621,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					hashDigest,
 					hashDigestLength
 				);
-				if (moduleHashesMemCache) {
-					moduleHashesMemCache.set(runtime, digest);
+				if (memCache) {
+					memCache.set(`moduleHash-${getRuntimeKey(runtime)}`, digest);
 				}
 			}
 		}
@@ -4609,6 +4834,33 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 }
 
+/**
+ * @typedef {Object} FactorizeModuleOptions
+ * @property {ModuleProfile} currentProfile
+ * @property {ModuleFactory} factory
+ * @property {Dependency[]} dependencies
+ * @property {boolean=} factoryResult return full ModuleFactoryResult instead of only module
+ * @property {Module | null} originModule
+ * @property {Partial<ModuleFactoryCreateDataContextInfo>=} contextInfo
+ * @property {string=} context
+ */
+
+/**
+ * @param {FactorizeModuleOptions} options options object
+ * @param {ModuleCallback | ModuleFactoryResultCallback} callback callback
+ * @returns {void}
+ */
+
+// Workaround for typescript as it doesn't support function overloading in jsdoc within a class
+Compilation.prototype.factorizeModule = /** @type {{
+	(options: FactorizeModuleOptions & { factoryResult?: false }, callback: ModuleCallback): void;
+	(options: FactorizeModuleOptions & { factoryResult: true }, callback: ModuleFactoryResultCallback): void;
+}} */ (
+	function (options, callback) {
+		this.factorizeQueue.add(options, callback);
+	}
+);
+
 // Hide from typescript
 const compilationPrototype = Compilation.prototype;