webpack 5.14.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}
 	 */
@@ -2683,18 +2740,6 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	 * @returns {void}
 	 */
 	removeReasonsOfDependencyBlock(module, block) {
-		const chunkGraph = this.chunkGraph;
-		const iteratorDependency = d => {
-			if (!d.module) {
-				return;
-			}
-			if (d.module.removeReason(module, d)) {
-				for (const chunk of chunkGraph.getModuleChunksIterable(d.module)) {
-					this.patchChunksAfterReasonRemoval(d.module, chunk);
-				}
-			}
-		};
-
 		if (block.blocks) {
 			for (const b of block.blocks) {
 				this.removeReasonsOfDependencyBlock(module, b);
@@ -2702,7 +2747,20 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		}
 
 		if (block.dependencies) {
-			for (const dep of block.dependencies) iteratorDependency(dep);
+			for (const dep of block.dependencies) {
+				const originalModule = this.moduleGraph.getModule(dep);
+				if (originalModule) {
+					this.moduleGraph.removeConnection(dep);
+
+					if (this.chunkGraph) {
+						for (const chunk of this.chunkGraph.getModuleChunks(
+							originalModule
+						)) {
+							this.patchChunksAfterReasonRemoval(originalModule, chunk);
+						}
+					}
+				}
+			}
 		}
 	}
 
@@ -2730,11 +2788,15 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	 * @returns {void}
 	 */
 	removeChunkFromDependencies(block, chunk) {
+		/**
+		 * @param {Dependency} d dependency to (maybe) patch up
+		 */
 		const iteratorDependency = d => {
-			if (!d.module) {
+			const depModule = this.moduleGraph.getModule(d);
+			if (!depModule) {
 				return;
 			}
-			this.patchChunksAfterReasonRemoval(d.module, chunk);
+			this.patchChunksAfterReasonRemoval(depModule, chunk);
 		};
 
 		const blocks = block.blocks;
@@ -2813,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
 				);
 			}
 		}
@@ -2837,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;
@@ -2917,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);
@@ -2994,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);
@@ -3012,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/Compiler.js

@@ -168,6 +168,8 @@ class Compiler {
 			invalid: new SyncHook(["filename", "changeTime"]),
 			/** @type {SyncHook<[]>} */
 			watchClose: new SyncHook([]),
+			/** @type {AsyncSeriesHook<[]>} */
+			shutdown: new AsyncSeriesHook([]),
 
 			/** @type {SyncBailHook<[string, string, any[]], true>} */
 			infrastructureLog: new SyncBailHook(["origin", "type", "args"]),
@@ -997,7 +999,7 @@ ${other}`);
 			context: this.options.context,
 			fs: this.inputFileSystem,
 			resolverFactory: this.resolverFactory,
-			options: this.options.module || {},
+			options: this.options.module,
 			associatedObjectForCache: this.root,
 			layers: this.options.experiments.layers
 		});
@@ -1075,7 +1077,10 @@ ${other}`);
 	 * @returns {void}
 	 */
 	close(callback) {
-		this.cache.shutdown(callback);
+		this.hooks.shutdown.callAsync(err => {
+			if (err) return callback(err);
+			this.cache.shutdown(callback);
+		});
 	}
 }
 

package/lib/ContextModule.js

@@ -16,9 +16,9 @@ const {
 	compareLocations,
 	concatComparators,
 	compareSelect,
-	keepOriginalOrder
+	keepOriginalOrder,
+	compareModulesById
 } = require("./util/comparators");
-const { compareModulesById } = require("./util/comparators");
 const { contextify, parseResource } = require("./util/identifier");
 const makeSerializable = require("./util/makeSerializable");
 

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

@@ -457,7 +457,6 @@ class ExportsInfo {
 				case UsageState.NoInfo:
 					return null;
 				case UsageState.Unknown:
-					return true;
 				case UsageState.OnlyPropertiesUsed:
 				case UsageState.Used:
 					return true;
@@ -685,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);
 		}
 	}
 
@@ -1339,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() {