webpack 5.52.0 → 5.55.0

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");
@@ -60,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,
@@ -76,7 +78,7 @@ const {
 	createFakeHook
 } = require("./util/deprecation");
 const processAsyncTree = require("./util/processAsyncTree");
-const { getRuntimeKey } = require("./util/runtime");
+const { getRuntimeKey, RuntimeSpecMap } = require("./util/runtime");
 const { isSourceEqual } = require("./util/source");
 
 /** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
@@ -91,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 */
@@ -100,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 */
@@ -124,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
@@ -399,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>} */
@@ -852,7 +876,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.fileSystemInfo = new FileSystemInfo(this.inputFileSystem, {
 			managedPaths: compiler.managedPaths,
 			immutablePaths: compiler.immutablePaths,
-			logger: this.getLogger("webpack.FileSystemInfo")
+			logger: this.getLogger("webpack.FileSystemInfo"),
+			hashFunction: compiler.options.output.hashFunction
 		});
 		if (compiler.fileTimestamps) {
 			this.fileSystemInfo.addFileTimestamps(compiler.fileTimestamps, true);
@@ -878,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(
@@ -891,6 +917,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		};
 		defineRemovedModuleTemplates(this.moduleTemplates);
 
+		/** @type {WeakMap<Module, WeakTupleMap<any, any>> | undefined} */
+		this.moduleMemCaches = undefined;
 		this.moduleGraph = new ModuleGraph();
 		/** @type {ChunkGraph} */
 		this.chunkGraph = undefined;
@@ -910,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,
@@ -993,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>} */
@@ -1025,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() {
@@ -1409,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;
@@ -1498,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;
 		}
@@ -1506,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);
 	}
 
 	/**
@@ -1566,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();
@@ -1581,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();
 				}
 
@@ -1591,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;
 						}
@@ -1599,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(
@@ -1623,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(
@@ -1724,6 +1875,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			factory,
 			dependencies,
 			originModule,
+			factoryResult,
 			contextInfo,
 			context
 		},
@@ -1757,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) {
@@ -1775,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);
 			}
 		);
 	}
@@ -2011,6 +2165,120 @@ 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();
+			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 statWithoutHash = 0;
+		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,
+						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 {
+					// use a new one
+					const memCache = new WeakTupleMap();
+					moduleMemCacheCache.set(module, {
+						hash: hash,
+						memCache
+					});
+					moduleMemCaches.set(module, memCache);
+					affectedModules.add(module);
+					cachedMemCache.hash = hash;
+					cachedMemCache.memCache = memCache;
+					statChanged++;
+				}
+			} 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,
+				connections
+			] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+				if (!referencingModule) continue;
+				if (infectedModules.has(referencingModule)) continue;
+				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,
+				connections
+			] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+				if (!referencingModule) continue;
+				if (infectedModules.has(referencingModule)) continue;
+				if (affectedModules.has(referencingModule)) continue;
+				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(module);
+				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)) /
+					this.modules.size
+			)}% (${affectedModules.size} affected + ${
+				infectedModules.size
+			} infected of ${
+				this.modules.size
+			}) modules flagged as affected (${statNew} new modules, ${statChanged} changed, ${statUnchanged} unchanged, ${statWithoutHash} without hash)`
+		);
+	}
+
 	finish(callback) {
 		this.factorizeQueue.clear();
 		if (this.profile) {
@@ -2191,17 +2459,29 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			);
 			this.logger.timeEnd("finish module profiles");
 		}
+		this.logger.time("compute affected modules");
+		this._computeAffectedModules(this.modules);
+		this.logger.timeEnd("compute affected modules");
 		this.logger.time("finish modules");
-		const { modules } = this;
+		const { modules, moduleMemCaches } = this;
 		this.hooks.finishModules.callAsync(modules, err => {
 			this.logger.timeEnd("finish modules");
 			if (err) return callback(err);
 
 			// extract warnings and errors from modules
+			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
 			this.logger.time("report dependency errors and warnings");
-			this.moduleGraph.freeze();
 			for (const module of modules) {
-				this.reportDependencyErrorsAndWarnings(module, [module]);
+				// 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("noWarningsOrErrors")) continue;
+				let hasProblems = this.reportDependencyErrorsAndWarnings(module, [
+					module
+				]);
 				const errors = module.getErrors();
 				if (errors !== undefined) {
 					for (const error of errors) {
@@ -2209,6 +2489,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 							error.module = module;
 						}
 						this.errors.push(error);
+						hasProblems = true;
 					}
 				}
 				const warnings = module.getWarnings();
@@ -2218,8 +2499,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 							warning.module = module;
 						}
 						this.warnings.push(warning);
+						hasProblems = true;
 					}
 				}
+				if (!hasProblems && memCache) memCache.set("noWarningsOrErrors", true);
 			}
 			this.moduleGraph.unfreeze();
 			this.logger.timeEnd("report dependency errors and warnings");
@@ -2255,7 +2538,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			this.addModuleQueue.clear();
 			return callback(err);
 		};
-		const chunkGraph = new ChunkGraph(this.moduleGraph);
+		const chunkGraph = new ChunkGraph(
+			this.moduleGraph,
+			this.outputOptions.hashFunction
+		);
 		this.chunkGraph = chunkGraph;
 
 		for (const module of this.modules) {
@@ -2273,7 +2559,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
@@ -2573,9 +2859,10 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	/**
 	 * @param {Module} module module to report from
 	 * @param {DependenciesBlock[]} blocks blocks to report from
-	 * @returns {void}
+	 * @returns {boolean} true, when it has warnings or errors
 	 */
 	reportDependencyErrorsAndWarnings(module, blocks) {
+		let hasProblems = false;
 		for (let indexBlock = 0; indexBlock < blocks.length; indexBlock++) {
 			const block = blocks[indexBlock];
 			const dependencies = block.dependencies;
@@ -2590,6 +2877,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 						const warning = new ModuleDependencyWarning(module, w, d.loc);
 						this.warnings.push(warning);
+						hasProblems = true;
 					}
 				}
 				const errors = d.getErrors(this.moduleGraph);
@@ -2599,17 +2887,22 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 						const error = new ModuleDependencyError(module, e, d.loc);
 						this.errors.push(error);
+						hasProblems = true;
 					}
 				}
 			}
 
-			this.reportDependencyErrorsAndWarnings(module, block.blocks);
+			if (this.reportDependencyErrorsAndWarnings(module, block.blocks))
+				hasProblems = true;
 		}
+		return hasProblems;
 	}
 
 	codeGeneration(callback) {
 		const { chunkGraph } = this;
-		this.codeGenerationResults = new CodeGenerationResults();
+		this.codeGenerationResults = new CodeGenerationResults(
+			this.outputOptions.hashFunction
+		);
 		/** @type {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} */
 		const jobs = [];
 		for (const module of this.modules) {
@@ -2790,12 +3083,40 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		chunkGraphEntries = this._getChunkGraphEntries()
 	} = {}) {
 		const context = { chunkGraph, codeGenerationResults };
+		const { moduleMemCaches } = this;
+		this.logger.time("runtime requirements.modules");
 		const additionalModuleRuntimeRequirements =
 			this.hooks.additionalModuleRuntimeRequirements;
 		const runtimeRequirementInModule = this.hooks.runtimeRequirementInModule;
 		for (const module of modules) {
 			if (chunkGraph.getNumberOfModuleChunks(module) > 0) {
+				const memCache =
+					moduleMemCaches &&
+					// 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(
+						"moduleRuntimeRequirements",
+						() => new RuntimeSpecMap()
+					);
 				for (const runtime of chunkGraph.getModuleRuntimes(module)) {
+					if (moduleRuntimeRequirementsMemCache) {
+						const cached = moduleRuntimeRequirementsMemCache.get(runtime);
+						if (cached !== undefined) {
+							if (cached !== null) {
+								chunkGraph.addModuleRuntimeRequirements(
+									module,
+									runtime,
+									cached,
+									false
+								);
+							}
+							continue;
+						}
+					}
 					let set;
 					const runtimeRequirements =
 						codeGenerationResults.getRuntimeRequirements(module, runtime);
@@ -2804,6 +3125,9 @@ 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);
+						}
 						continue;
 					}
 					additionalModuleRuntimeRequirements.call(module, set, context);
@@ -2812,11 +3136,29 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						const hook = runtimeRequirementInModule.get(r);
 						if (hook !== undefined) hook.call(module, set, context);
 					}
-					chunkGraph.addModuleRuntimeRequirements(module, runtime, set);
+					if (set.size === 0) {
+						if (moduleRuntimeRequirementsMemCache) {
+							moduleRuntimeRequirementsMemCache.set(runtime, null);
+						}
+					} else {
+						if (moduleRuntimeRequirementsMemCache) {
+							moduleRuntimeRequirementsMemCache.set(runtime, set);
+							chunkGraph.addModuleRuntimeRequirements(
+								module,
+								runtime,
+								set,
+								false
+							);
+						} else {
+							chunkGraph.addModuleRuntimeRequirements(module, runtime, set);
+						}
+					}
 				}
 			}
 		}
+		this.logger.timeEnd("runtime requirements.modules");
 
+		this.logger.time("runtime requirements.chunks");
 		for (const chunk of chunks) {
 			const set = new Set();
 			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
@@ -2834,7 +3176,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 			chunkGraph.addChunkRuntimeRequirements(chunk, set);
 		}
+		this.logger.timeEnd("runtime requirements.chunks");
 
+		this.logger.time("runtime requirements.entries");
 		for (const treeEntry of chunkGraphEntries) {
 			const set = new Set();
 			for (const chunk of treeEntry.getAllReferencedChunks()) {
@@ -2857,6 +3201,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 			chunkGraph.addTreeRuntimeRequirements(treeEntry, set);
 		}
+		this.logger.timeEnd("runtime requirements.entries");
 	}
 
 	// TODO webpack 6 make chunkGraph argument non-optional
@@ -3201,12 +3546,35 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 	createModuleHashes() {
 		let statModulesHashed = 0;
-		const { chunkGraph, runtimeTemplate } = this;
+		let statModulesFromCache = 0;
+		const { chunkGraph, runtimeTemplate, moduleMemCaches } = this;
 		const { hashFunction, hashDigest, hashDigestLength } = this.outputOptions;
 		for (const module of this.modules) {
+			const memCache =
+				moduleMemCaches &&
+				// 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("moduleHashes", () => new RuntimeSpecMap());
 			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
+				if (moduleHashesMemCache) {
+					const digest = moduleHashesMemCache.get(runtime);
+					if (digest !== undefined) {
+						chunkGraph.setModuleHashes(
+							module,
+							runtime,
+							digest,
+							digest.substr(0, hashDigestLength)
+						);
+						statModulesFromCache++;
+						continue;
+					}
+				}
 				statModulesHashed++;
-				this._createModuleHash(
+				const digest = this._createModuleHash(
 					module,
 					chunkGraph,
 					runtime,
@@ -3215,11 +3583,16 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					hashDigest,
 					hashDigestLength
 				);
+				if (moduleHashesMemCache) {
+					moduleHashesMemCache.set(runtime, digest);
+				}
 			}
 		}
 		this.logger.log(
-			`${statModulesHashed} modules hashed (${
-				Math.round((100 * statModulesHashed) / this.modules.size) / 100
+			`${statModulesHashed} modules hashed, ${statModulesFromCache} from cache (${
+				Math.round(
+					(100 * (statModulesHashed + statModulesFromCache)) / this.modules.size
+				) / 100
 			} variants per module in average)`
 		);
 	}
@@ -4071,7 +4444,10 @@ This prevents using hashes of each other and should be avoided.`);
 				if (err) return callback(err);
 
 				// Create new chunk graph, chunk and entrypoint for the build time execution
-				const chunkGraph = new ChunkGraph(this.moduleGraph);
+				const chunkGraph = new ChunkGraph(
+					this.moduleGraph,
+					this.outputOptions.hashFunction
+				);
 				const runtime = "build time";
 				const { hashFunction, hashDigest, hashDigestLength } =
 					this.outputOptions;
@@ -4114,7 +4490,9 @@ This prevents using hashes of each other and should be avoided.`);
 					);
 				}
 
-				const codeGenerationResults = new CodeGenerationResults();
+				const codeGenerationResults = new CodeGenerationResults(
+					this.outputOptions.hashFunction
+				);
 				/** @type {WebpackError[]} */
 				const errors = [];
 				/**
@@ -4418,6 +4796,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;