webpack 5.17.0 → 5.18.0

package/lib/Compilation.js

@@ -2173,77 +2173,83 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 						this.logger.time("hashing");
 						this.hooks.beforeHash.call();
-						this.createHash();
+						const codeGenerationJobs = this.createHash();
 						this.hooks.afterHash.call();
 						this.logger.timeEnd("hashing");
 
-						if (shouldRecord) {
-							this.logger.time("record hash");
-							this.hooks.recordHash.call(this.records);
-							this.logger.timeEnd("record hash");
-						}
-
-						this.logger.time("module assets");
-						this.clearAssets();
+						this._runCodeGenerationJobs(codeGenerationJobs, err => {
+							if (err) {
+								return callback(err);
+							}
 
-						this.hooks.beforeModuleAssets.call();
-						this.createModuleAssets();
-						this.logger.timeEnd("module assets");
+							if (shouldRecord) {
+								this.logger.time("record hash");
+								this.hooks.recordHash.call(this.records);
+								this.logger.timeEnd("record hash");
+							}
 
-						const cont = () => {
-							this.logger.time("process assets");
-							this.hooks.processAssets.callAsync(this.assets, err => {
-								if (err) {
-									return callback(
-										makeWebpackError(err, "Compilation.hooks.processAssets")
-									);
-								}
-								this.hooks.afterProcessAssets.call(this.assets);
-								this.logger.timeEnd("process assets");
-								this.assets = soonFrozenObjectDeprecation(
-									this.assets,
-									"Compilation.assets",
-									"DEP_WEBPACK_COMPILATION_ASSETS",
-									`BREAKING CHANGE: No more changes should happen to Compilation.assets after sealing the Compilation.
-	Do changes to assets earlier, e. g. in Compilation.hooks.processAssets.
-	Make sure to select an appropriate stage from Compilation.PROCESS_ASSETS_STAGE_*.`
-								);
+							this.logger.time("module assets");
+							this.clearAssets();
 
-								this.summarizeDependencies();
-								if (shouldRecord) {
-									this.hooks.record.call(this, this.records);
-								}
+							this.hooks.beforeModuleAssets.call();
+							this.createModuleAssets();
+							this.logger.timeEnd("module assets");
 
-								if (this.hooks.needAdditionalSeal.call()) {
-									this.unseal();
-									return this.seal(callback);
-								}
-								return this.hooks.afterSeal.callAsync(err => {
+							const cont = () => {
+								this.logger.time("process assets");
+								this.hooks.processAssets.callAsync(this.assets, err => {
 									if (err) {
 										return callback(
-											makeWebpackError(err, "Compilation.hooks.afterSeal")
+											makeWebpackError(err, "Compilation.hooks.processAssets")
 										);
 									}
-									this.fileSystemInfo.logStatistics();
-									callback();
+									this.hooks.afterProcessAssets.call(this.assets);
+									this.logger.timeEnd("process assets");
+									this.assets = soonFrozenObjectDeprecation(
+										this.assets,
+										"Compilation.assets",
+										"DEP_WEBPACK_COMPILATION_ASSETS",
+										`BREAKING CHANGE: No more changes should happen to Compilation.assets after sealing the Compilation.
+	Do changes to assets earlier, e. g. in Compilation.hooks.processAssets.
+	Make sure to select an appropriate stage from Compilation.PROCESS_ASSETS_STAGE_*.`
+									);
+
+									this.summarizeDependencies();
+									if (shouldRecord) {
+										this.hooks.record.call(this, this.records);
+									}
+
+									if (this.hooks.needAdditionalSeal.call()) {
+										this.unseal();
+										return this.seal(callback);
+									}
+									return this.hooks.afterSeal.callAsync(err => {
+										if (err) {
+											return callback(
+												makeWebpackError(err, "Compilation.hooks.afterSeal")
+											);
+										}
+										this.fileSystemInfo.logStatistics();
+										callback();
+									});
 								});
-							});
-						};
+							};
 
-						this.logger.time("create chunk assets");
-						if (this.hooks.shouldGenerateChunkAssets.call() !== false) {
-							this.hooks.beforeChunkAssets.call();
-							this.createChunkAssets(err => {
+							this.logger.time("create chunk assets");
+							if (this.hooks.shouldGenerateChunkAssets.call() !== false) {
+								this.hooks.beforeChunkAssets.call();
+								this.createChunkAssets(err => {
+									this.logger.timeEnd("create chunk assets");
+									if (err) {
+										return callback(err);
+									}
+									cont();
+								});
+							} else {
 								this.logger.timeEnd("create chunk assets");
-								if (err) {
-									return callback(err);
-								}
 								cont();
-							});
-						} else {
-							this.logger.timeEnd("create chunk assets");
-							cont();
-						}
+							}
+						});
 					});
 				}
 			);
@@ -2288,16 +2294,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	codeGeneration(callback) {
-		let statModulesFromCache = 0;
-		let statModulesGenerated = 0;
-		const {
-			chunkGraph,
-			moduleGraph,
-			dependencyTemplates,
-			runtimeTemplate
-		} = this;
-		const results = (this.codeGenerationResults = new CodeGenerationResults());
-		const errors = [];
+		const { chunkGraph } = this;
+		this.codeGenerationResults = new CodeGenerationResults();
 		/** @type {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} */
 		const jobs = [];
 		for (const module of this.modules) {
@@ -2324,52 +2322,41 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			}
 		}
 
+		this._runCodeGenerationJobs(jobs, callback);
+	}
+
+	_runCodeGenerationJobs(jobs, callback) {
+		let statModulesFromCache = 0;
+		let statModulesGenerated = 0;
+		const {
+			chunkGraph,
+			moduleGraph,
+			dependencyTemplates,
+			runtimeTemplate
+		} = this;
+		const results = this.codeGenerationResults;
+		const errors = [];
 		asyncLib.eachLimit(
 			jobs,
 			this.options.parallelism,
 			({ module, hash, runtime, runtimes }, callback) => {
-				const cache = new MultiItemCache(
-					runtimes.map(runtime =>
-						this._codeGenerationCache.getItemCache(
-							`${module.identifier()}|${getRuntimeKey(runtime)}`,
-							`${hash}|${dependencyTemplates.getHash()}`
-						)
-					)
-				);
-				cache.get((err, cachedResult) => {
-					if (err) return callback(err);
-					let result;
-					if (!cachedResult) {
-						statModulesGenerated++;
-						try {
-							this.codeGeneratedModules.add(module);
-							result = module.codeGeneration({
-								chunkGraph,
-								moduleGraph,
-								dependencyTemplates,
-								runtimeTemplate,
-								runtime
-							});
-						} catch (err) {
-							errors.push(new CodeGenerationError(module, err));
-							result = cachedResult = {
-								sources: new Map(),
-								runtimeRequirements: null
-							};
-						}
-					} else {
-						statModulesFromCache++;
-						result = cachedResult;
-					}
-					for (const runtime of runtimes) {
-						results.add(module, runtime, result);
-					}
-					if (!cachedResult) {
-						cache.store(result, callback);
-					} else {
-						callback();
+				this._codeGenerationModule(
+					module,
+					runtime,
+					runtimes,
+					hash,
+					dependencyTemplates,
+					chunkGraph,
+					moduleGraph,
+					runtimeTemplate,
+					errors,
+					results,
+					(err, codeGenerated) => {
+						if (codeGenerated) statModulesGenerated++;
+						else statModulesFromCache++;
+						callback(err);
 					}
-				});
+				);
 			},
 			err => {
 				if (err) return callback(err);
@@ -2392,6 +2379,76 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		);
 	}
 
+	/**
+	 * @param {Module} module module
+	 * @param {RuntimeSpec} runtime runtime
+	 * @param {RuntimeSpec[]} runtimes runtimes
+	 * @param {string} hash hash
+	 * @param {DependencyTemplates} dependencyTemplates dependencyTemplates
+	 * @param {ChunkGraph} chunkGraph chunkGraph
+	 * @param {ModuleGraph} moduleGraph moduleGraph
+	 * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate
+	 * @param {WebpackError[]} errors errors
+	 * @param {CodeGenerationResults} results results
+	 * @param {function(WebpackError=, boolean=): void} callback callback
+	 */
+	_codeGenerationModule(
+		module,
+		runtime,
+		runtimes,
+		hash,
+		dependencyTemplates,
+		chunkGraph,
+		moduleGraph,
+		runtimeTemplate,
+		errors,
+		results,
+		callback
+	) {
+		let codeGenerated = false;
+		const cache = new MultiItemCache(
+			runtimes.map(runtime =>
+				this._codeGenerationCache.getItemCache(
+					`${module.identifier()}|${getRuntimeKey(runtime)}`,
+					`${hash}|${dependencyTemplates.getHash()}`
+				)
+			)
+		);
+		cache.get((err, cachedResult) => {
+			if (err) return callback(err);
+			let result;
+			if (!cachedResult) {
+				try {
+					codeGenerated = true;
+					this.codeGeneratedModules.add(module);
+					result = module.codeGeneration({
+						chunkGraph,
+						moduleGraph,
+						dependencyTemplates,
+						runtimeTemplate,
+						runtime
+					});
+				} catch (err) {
+					errors.push(new CodeGenerationError(module, err));
+					result = cachedResult = {
+						sources: new Map(),
+						runtimeRequirements: null
+					};
+				}
+			} else {
+				result = cachedResult;
+			}
+			for (const runtime of runtimes) {
+				results.add(module, runtime, result);
+			}
+			if (!cachedResult) {
+				cache.store(result, err => callback(err, codeGenerated));
+			} else {
+				callback(null, codeGenerated);
+			}
+		});
+	}
+
 	/**
 	 * @returns {void}
 	 */
@@ -2818,20 +2875,14 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		for (const module of this.modules) {
 			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
 				statModulesHashed++;
-				const moduleHash = createHash(hashFunction);
-				module.updateHash(moduleHash, {
-					chunkGraph,
-					runtime,
-					runtimeTemplate
-				});
-				const moduleHashDigest = /** @type {string} */ (moduleHash.digest(
-					hashDigest
-				));
-				chunkGraph.setModuleHashes(
+				this._createModuleHash(
 					module,
+					chunkGraph,
 					runtime,
-					moduleHashDigest,
-					moduleHashDigest.substr(0, hashDigestLength)
+					hashFunction,
+					runtimeTemplate,
+					hashDigest,
+					hashDigestLength
 				);
 			}
 		}
@@ -2842,6 +2893,33 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		);
 	}
 
+	_createModuleHash(
+		module,
+		chunkGraph,
+		runtime,
+		hashFunction,
+		runtimeTemplate,
+		hashDigest,
+		hashDigestLength
+	) {
+		const moduleHash = createHash(hashFunction);
+		module.updateHash(moduleHash, {
+			chunkGraph,
+			runtime,
+			runtimeTemplate
+		});
+		const moduleHashDigest = /** @type {string} */ (moduleHash.digest(
+			hashDigest
+		));
+		chunkGraph.setModuleHashes(
+			module,
+			runtime,
+			moduleHashDigest,
+			moduleHashDigest.substr(0, hashDigestLength)
+		);
+		return moduleHashDigest;
+	}
+
 	createHash() {
 		this.logger.time("hashing: initialize hash");
 		const chunkGraph = this.chunkGraph;
@@ -2922,31 +3000,49 @@ This prevents using hashes of each other and should be avoided.`
 		});
 		this.logger.timeEnd("hashing: sort chunks");
 		const fullHashChunks = new Set();
+		/** @type {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} */
+		const codeGenerationJobs = [];
+		/** @type {Map<string, Map<Module, {module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}>>} */
+		const codeGenerationJobsMap = new Map();
 		const processChunk = chunk => {
 			// Last minute module hash generation for modules that depend on chunk hashes
 			this.logger.time("hashing: hash runtime modules");
+			const runtime = chunk.runtime;
 			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-				if (!chunkGraph.hasModuleHashes(module, chunk.runtime)) {
-					const moduleHash = createHash(hashFunction);
-					module.updateHash(moduleHash, {
-						chunkGraph,
-						runtime: chunk.runtime,
-						runtimeTemplate
-					});
-					const moduleHashDigest = /** @type {string} */ (moduleHash.digest(
-						hashDigest
-					));
-					chunkGraph.setModuleHashes(
+				if (!chunkGraph.hasModuleHashes(module, runtime)) {
+					const hash = this._createModuleHash(
 						module,
-						chunk.runtime,
-						moduleHashDigest,
-						moduleHashDigest.substr(0, hashDigestLength)
+						chunkGraph,
+						runtime,
+						hashFunction,
+						runtimeTemplate,
+						hashDigest,
+						hashDigestLength
 					);
+					let hashMap = codeGenerationJobsMap.get(hash);
+					if (hashMap) {
+						const moduleJob = hashMap.get(module);
+						if (moduleJob) {
+							moduleJob.runtimes.push(runtime);
+							continue;
+						}
+					} else {
+						hashMap = new Map();
+						codeGenerationJobsMap.set(hash, hashMap);
+					}
+					const job = {
+						module,
+						hash,
+						runtime,
+						runtimes: [runtime]
+					};
+					hashMap.set(module, job);
+					codeGenerationJobs.push(job);
 				}
 			}
 			this.logger.timeAggregate("hashing: hash runtime modules");
-			const chunkHash = createHash(hashFunction);
 			this.logger.time("hashing: hash chunks");
+			const chunkHash = createHash(hashFunction);
 			try {
 				if (outputOptions.hashSalt) {
 					chunkHash.update(outputOptions.hashSalt);
@@ -2999,12 +3095,14 @@ This prevents using hashes of each other and should be avoided.`
 				const moduleHashDigest = /** @type {string} */ (moduleHash.digest(
 					hashDigest
 				));
+				const oldHash = chunkGraph.getModuleHash(module, chunk.runtime);
 				chunkGraph.setModuleHashes(
 					module,
 					chunk.runtime,
 					moduleHashDigest,
 					moduleHashDigest.substr(0, hashDigestLength)
 				);
+				codeGenerationJobsMap.get(oldHash).get(module).hash = moduleHashDigest;
 			}
 			const chunkHash = createHash(hashFunction);
 			chunkHash.update(chunk.hash);
@@ -3017,6 +3115,7 @@ This prevents using hashes of each other and should be avoided.`
 			this.hooks.contentHash.call(chunk);
 		}
 		this.logger.timeEnd("hashing: process full hash modules");
+		return codeGenerationJobs;
 	}
 
 	/**

package/lib/Dependency.js

@@ -167,13 +167,7 @@ class Dependency {
 	 * @param {UpdateHashContext} context context
 	 * @returns {void}
 	 */
-	updateHash(hash, context) {
-		const { chunkGraph } = context;
-		const module = chunkGraph.moduleGraph.getModule(this);
-		if (module) {
-			hash.update(chunkGraph.getModuleId(module) + "");
-		}
-	}
+	updateHash(hash, context) {}
 
 	/**
 	 * implement this method to allow the occurrence order plugin to count correctly

package/lib/ExportsInfo.js

@@ -684,15 +684,27 @@ class ExportsInfo {
 	 * @returns {void}
 	 */
 	updateHash(hash, runtime) {
+		this._updateHash(hash, runtime, new Set());
+	}
+
+	/**
+	 * @param {Hash} hash the hash
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {Set<ExportsInfo>} alreadyVisitedExportsInfo for circular references
+	 * @returns {void}
+	 */
+	_updateHash(hash, runtime, alreadyVisitedExportsInfo) {
+		const set = new Set(alreadyVisitedExportsInfo);
+		set.add(this);
 		for (const exportInfo of this.orderedExports) {
 			if (exportInfo.hasInfo(this._otherExportsInfo, runtime)) {
-				exportInfo.updateHash(hash, runtime);
+				exportInfo._updateHash(hash, runtime, set);
 			}
 		}
-		this._sideEffectsOnlyInfo.updateHash(hash, runtime);
-		this._otherExportsInfo.updateHash(hash, runtime);
+		this._sideEffectsOnlyInfo._updateHash(hash, runtime, set);
+		this._otherExportsInfo._updateHash(hash, runtime, set);
 		if (this._redirectTo !== undefined) {
-			this._redirectTo.updateHash(hash, runtime);
+			this._redirectTo._updateHash(hash, runtime, set);
 		}
 	}
 
@@ -1338,10 +1350,17 @@ class ExportInfo {
 	}
 
 	updateHash(hash, runtime) {
+		this._updateHash(hash, runtime, new Set());
+	}
+
+	_updateHash(hash, runtime, alreadyVisitedExportsInfo) {
 		hash.update(`${this._usedName || this.name}`);
 		hash.update(`${this.getUsed(runtime)}`);
 		hash.update(`${this.provided}`);
 		hash.update(`${this.terminalBinding}`);
+		if (this.exportsInfo && !alreadyVisitedExportsInfo.has(this.exportsInfo)) {
+			this.exportsInfo._updateHash(hash, runtime, alreadyVisitedExportsInfo);
+		}
 	}
 
 	getUsedInfo() {

package/lib/HotModuleReplacementPlugin.js

@@ -39,6 +39,7 @@ const {
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./RuntimeModule")} RuntimeModule */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
  * @typedef {Object} HMRJavascriptParserHooks
@@ -316,37 +317,61 @@ class HotModuleReplacementPlugin {
 				/** @type {TupleSet<[Module, Chunk]>} */
 				const updatedModules = new TupleSet();
 				/** @type {TupleSet<[Module, Chunk]>} */
-				const lazyHashedModules = new TupleSet();
+				const fullHashModules = new TupleSet();
+				/** @type {TupleSet<[Module, RuntimeSpec]>} */
+				const nonCodeGeneratedModules = new TupleSet();
 				compilation.hooks.fullHash.tap("HotModuleReplacementPlugin", hash => {
 					const chunkGraph = compilation.chunkGraph;
 					const records = compilation.records;
 					for (const chunk of compilation.chunks) {
-						/** @type {Set<Module>} */
-						const lazyHashedModulesInThisChunk = new Set();
-						const fullHashModules = chunkGraph.getChunkFullHashModulesIterable(
+						const getModuleHash = module => {
+							if (
+								compilation.codeGenerationResults.has(module, chunk.runtime)
+							) {
+								return compilation.codeGenerationResults.getHash(
+									module,
+									chunk.runtime
+								);
+							} else {
+								nonCodeGeneratedModules.add(module, chunk.runtime);
+								return chunkGraph.getModuleHash(module, chunk.runtime);
+							}
+						};
+						const fullHashModulesInThisChunk = chunkGraph.getChunkFullHashModulesSet(
 							chunk
 						);
-						if (fullHashModules !== undefined) {
-							for (const module of fullHashModules) {
-								lazyHashedModules.add(module, chunk);
-								lazyHashedModulesInThisChunk.add(module);
+						if (fullHashModulesInThisChunk !== undefined) {
+							for (const module of fullHashModulesInThisChunk) {
+								fullHashModules.add(module, chunk);
 							}
 						}
 						const modules = chunkGraph.getChunkModulesIterable(chunk);
 						if (modules !== undefined) {
-							if (
-								records.chunkModuleHashes &&
-								records.fullHashChunkModuleHashes
-							) {
-								for (const module of modules) {
-									const key = `${chunk.id}|${module.identifier()}`;
-									const hash = chunkGraph.getModuleHash(module, chunk.runtime);
-									if (lazyHashedModulesInThisChunk.has(module)) {
-										if (records.fullHashChunkModuleHashes[key] !== hash) {
-											updatedModules.add(module, chunk);
+							if (records.chunkModuleHashes) {
+								if (fullHashModulesInThisChunk !== undefined) {
+									for (const module of modules) {
+										const key = `${chunk.id}|${module.identifier()}`;
+										const hash = getModuleHash(module);
+										if (
+											fullHashModulesInThisChunk.has(
+												/** @type {RuntimeModule} */ (module)
+											)
+										) {
+											if (records.fullHashChunkModuleHashes[key] !== hash) {
+												updatedModules.add(module, chunk);
+											}
+											fullHashChunkModuleHashes[key] = hash;
+										} else {
+											if (records.chunkModuleHashes[key] !== hash) {
+												updatedModules.add(module, chunk);
+											}
+											chunkModuleHashes[key] = hash;
 										}
-										fullHashChunkModuleHashes[key] = hash;
-									} else {
+									}
+								} else {
+									for (const module of modules) {
+										const key = `${chunk.id}|${module.identifier()}`;
+										const hash = getModuleHash(module);
 										if (records.chunkModuleHashes[key] !== hash) {
 											updatedModules.add(module, chunk);
 										}
@@ -354,12 +379,24 @@ class HotModuleReplacementPlugin {
 									}
 								}
 							} else {
-								for (const module of modules) {
-									const key = `${chunk.id}|${module.identifier()}`;
-									const hash = chunkGraph.getModuleHash(module, chunk.runtime);
-									if (lazyHashedModulesInThisChunk.has(module)) {
-										fullHashChunkModuleHashes[key] = hash;
-									} else {
+								if (fullHashModulesInThisChunk !== undefined) {
+									for (const module of modules) {
+										const key = `${chunk.id}|${module.identifier()}`;
+										const hash = getModuleHash(module);
+										if (
+											fullHashModulesInThisChunk.has(
+												/** @type {RuntimeModule} */ (module)
+											)
+										) {
+											fullHashChunkModuleHashes[key] = hash;
+										} else {
+											chunkModuleHashes[key] = hash;
+										}
+									}
+								} else {
+									for (const module of modules) {
+										const key = `${chunk.id}|${module.identifier()}`;
+										const hash = getModuleHash(module);
 										chunkModuleHashes[key] = hash;
 									}
 								}
@@ -388,9 +425,14 @@ class HotModuleReplacementPlugin {
 						) {
 							return;
 						}
-						for (const [module, chunk] of lazyHashedModules) {
+						for (const [module, chunk] of fullHashModules) {
 							const key = `${chunk.id}|${module.identifier()}`;
-							const hash = chunkGraph.getModuleHash(module, chunk.runtime);
+							const hash = nonCodeGeneratedModules.has(module, chunk.runtime)
+								? chunkGraph.getModuleHash(module, chunk.runtime)
+								: compilation.codeGenerationResults.getHash(
+										module,
+										chunk.runtime
+								  );
 							if (records.chunkModuleHashes[key] !== hash) {
 								updatedModules.add(module, chunk);
 							}
@@ -500,7 +542,12 @@ class HotModuleReplacementPlugin {
 									const runtimes = chunkGraph.getModuleRuntimes(module);
 									if (oldRuntime === newRuntime && runtimes.has(newRuntime)) {
 										// Module is still in the same runtime combination
-										const hash = chunkGraph.getModuleHash(module, newRuntime);
+										const hash = nonCodeGeneratedModules.has(module, newRuntime)
+											? chunkGraph.getModuleHash(module, newRuntime)
+											: compilation.codeGenerationResults.getHash(
+													module,
+													newRuntime
+											  );
 										if (hash !== oldHash) {
 											if (module.type === "runtime") {
 												newRuntimeModules = newRuntimeModules || [];