webpack 5.57.0 → 5.58.2

package/lib/AsyncDependenciesBlock.js

@@ -33,8 +33,6 @@ class AsyncDependenciesBlock extends DependenciesBlock {
 		this.groupOptions = groupOptions;
 		this.loc = loc;
 		this.request = request;
-		/** @type {DependenciesBlock} */
-		this.parent = undefined;
 		this._stringifiedGroupOptions = undefined;
 	}
 

package/lib/ChunkGraph.js

@@ -235,16 +235,6 @@ class ChunkGraph {
 		this._hashFunction = hashFunction;
 
 		this._getGraphRoots = this._getGraphRoots.bind(this);
-
-		// Caching
-		this._cacheChunkGraphModuleKey1 = undefined;
-		this._cacheChunkGraphModuleValue1 = undefined;
-		this._cacheChunkGraphModuleKey2 = undefined;
-		this._cacheChunkGraphModuleValue2 = undefined;
-		this._cacheChunkGraphChunkKey1 = undefined;
-		this._cacheChunkGraphChunkValue1 = undefined;
-		this._cacheChunkGraphChunkKey2 = undefined;
-		this._cacheChunkGraphChunkValue2 = undefined;
 	}
 
 	/**
@@ -253,19 +243,11 @@ class ChunkGraph {
 	 * @returns {ChunkGraphModule} internal module
 	 */
 	_getChunkGraphModule(module) {
-		if (this._cacheChunkGraphModuleKey1 === module)
-			return this._cacheChunkGraphModuleValue1;
-		if (this._cacheChunkGraphModuleKey2 === module)
-			return this._cacheChunkGraphModuleValue2;
 		let cgm = this._modules.get(module);
 		if (cgm === undefined) {
 			cgm = new ChunkGraphModule();
 			this._modules.set(module, cgm);
 		}
-		this._cacheChunkGraphModuleKey2 = this._cacheChunkGraphModuleKey1;
-		this._cacheChunkGraphModuleValue2 = this._cacheChunkGraphModuleValue1;
-		this._cacheChunkGraphModuleKey1 = module;
-		this._cacheChunkGraphModuleValue1 = cgm;
 		return cgm;
 	}
 
@@ -275,19 +257,11 @@ class ChunkGraph {
 	 * @returns {ChunkGraphChunk} internal chunk
 	 */
 	_getChunkGraphChunk(chunk) {
-		if (this._cacheChunkGraphChunkKey1 === chunk)
-			return this._cacheChunkGraphChunkValue1;
-		if (this._cacheChunkGraphChunkKey2 === chunk)
-			return this._cacheChunkGraphChunkValue2;
 		let cgc = this._chunks.get(chunk);
 		if (cgc === undefined) {
 			cgc = new ChunkGraphChunk();
 			this._chunks.set(chunk, cgc);
 		}
-		this._cacheChunkGraphChunkKey2 = this._cacheChunkGraphChunkKey1;
-		this._cacheChunkGraphChunkValue2 = this._cacheChunkGraphChunkValue1;
-		this._cacheChunkGraphChunkKey1 = chunk;
-		this._cacheChunkGraphChunkValue1 = cgc;
 		return cgc;
 	}
 

package/lib/Compilation.js

@@ -416,10 +416,10 @@ const byLocation = compareSelect(err => err.loc, compareLocations);
 
 const compareErrors = concatComparators(byModule, byLocation, byMessage);
 
-/** @type {WeakMap<Dependency, Module & { restoreFromUnsafeCache: Function }>} */
+/** @type {WeakMap<Dependency, Module & { restoreFromUnsafeCache: Function } | null>} */
 const unsafeCacheDependencies = new WeakMap();
 
-/** @type {WeakMap<Module, object>} */
+/** @type {WeakMap<Module & { restoreFromUnsafeCache: Function }, object>} */
 const unsafeCacheData = new WeakMap();
 
 class Compilation {
@@ -1023,8 +1023,10 @@ 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 {Set<Module & { restoreFromUnsafeCache: Function }>} */
+		this._restoredUnsafeCacheModuleEntries = new Set();
+		/** @type {Map<string, Module & { restoreFromUnsafeCache: Function }>} */
+		this._restoredUnsafeCacheEntries = new Map();
 		/** @type {WeakSet<Module>} */
 		this.builtModules = new WeakSet();
 		/** @type {WeakSet<Module>} */
@@ -1405,8 +1407,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	processModuleDependenciesNonRecursive(module) {
 		const processDependenciesBlock = block => {
 			if (block.dependencies) {
+				let i = 0;
 				for (const dep of block.dependencies) {
-					this.moduleGraph.setParents(dep, block, module);
+					this.moduleGraph.setParents(dep, block, module, i++);
 				}
 			}
 			if (block.blocks) {
@@ -1423,9 +1426,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 * @returns {void}
 	 */
 	_processModuleDependencies(module, callback) {
-		/**
-		 * @type {Array<{factory: ModuleFactory, dependencies: Dependency[], originModule: Module|null}>}
-		 */
+		/** @type {Array<{factory: ModuleFactory, dependencies: Dependency[], originModule: Module|null}>} */
 		const sortedDependencies = [];
 
 		/** @type {DependenciesBlock} */
@@ -1446,44 +1447,161 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		/** @type {Dependency[]} */
 		let listCacheValue;
 
-		const unsafeRestoredModules = new Set();
+		let inProgressSorting = 1;
+		let inProgressTransitive = 1;
+
+		const onDependenciesSorted = err => {
+			if (err) return callback(err);
+
+			// early exit without changing parallelism back and forth
+			if (sortedDependencies.length === 0 && inProgressTransitive === 1) {
+				return callback();
+			}
+
+			// This is nested so we need to allow one additional task
+			this.processDependenciesQueue.increaseParallelism();
+
+			for (const item of sortedDependencies) {
+				inProgressTransitive++;
+				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) {
+						if (inProgressTransitive <= 0) return;
+						inProgressTransitive = -1;
+						// eslint-disable-next-line no-self-assign
+						err.stack = err.stack;
+						onTransitiveTasksFinished(err);
+						return;
+					}
+					if (--inProgressTransitive === 0) onTransitiveTasksFinished();
+				});
+			}
+			if (--inProgressTransitive === 0) onTransitiveTasksFinished();
+		};
+
+		const onTransitiveTasksFinished = err => {
+			if (err) return callback(err);
+			this.processDependenciesQueue.decreaseParallelism();
+
+			return callback();
+		};
 
 		/**
 		 * @param {Dependency} dep dependency
+		 * @param {number} index index in block
 		 * @returns {void}
 		 */
-		const processDependency = dep => {
-			this.moduleGraph.setParents(dep, currentBlock, module);
+		const processDependency = (dep, index) => {
+			this.moduleGraph.setParents(dep, currentBlock, module, index);
 			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
+					const unsafeCachedModule = unsafeCacheDependencies.get(dep);
+					if (unsafeCachedModule === null) return;
+					if (unsafeCachedModule !== undefined) {
+						if (
+							this._restoredUnsafeCacheModuleEntries.has(unsafeCachedModule)
+						) {
+							this._handleExistingModuleFromUnsafeCache(
+								module,
+								dep,
+								unsafeCachedModule
 							);
-							this._restoredUnsafeCacheEntries.add(cachedModule);
-							if (!this.modules.has(cachedModule)) {
-								this._handleNewModuleFromUnsafeCache(module, dep, cachedModule);
-								unsafeRestoredModules.add(cachedModule);
+							return;
+						}
+						const identifier = unsafeCachedModule.identifier();
+						const cachedModule =
+							this._restoredUnsafeCacheEntries.get(identifier);
+						if (cachedModule !== undefined) {
+							// update unsafe cache to new module
+							unsafeCacheDependencies.set(dep, cachedModule);
+							this._handleExistingModuleFromUnsafeCache(
+								module,
+								dep,
+								cachedModule
+							);
+							return;
+						}
+						inProgressSorting++;
+						this._modulesCache.get(identifier, null, (err, cachedModule) => {
+							if (err) {
+								if (inProgressSorting <= 0) return;
+								inProgressSorting = -1;
+								onDependenciesSorted(err);
 								return;
 							}
-						}
-						this._handleExistingModuleFromUnsafeCache(
-							module,
-							dep,
-							cachedModule
-						);
+							try {
+								if (!this._restoredUnsafeCacheEntries.has(identifier)) {
+									const data = unsafeCacheData.get(cachedModule);
+									if (data === undefined) {
+										processDependencyForResolving(dep);
+										if (--inProgressSorting === 0) onDependenciesSorted();
+										return;
+									}
+									if (cachedModule !== unsafeCachedModule) {
+										unsafeCacheDependencies.set(dep, cachedModule);
+									}
+									cachedModule.restoreFromUnsafeCache(
+										data,
+										this.params.normalModuleFactory,
+										this.params
+									);
+									this._restoredUnsafeCacheEntries.set(
+										identifier,
+										cachedModule
+									);
+									this._restoredUnsafeCacheModuleEntries.add(cachedModule);
+									if (!this.modules.has(cachedModule)) {
+										inProgressTransitive++;
+										this._handleNewModuleFromUnsafeCache(
+											module,
+											dep,
+											cachedModule,
+											err => {
+												if (err) {
+													if (inProgressTransitive <= 0) return;
+													inProgressTransitive = -1;
+													onTransitiveTasksFinished(err);
+												}
+												if (--inProgressTransitive === 0)
+													return onTransitiveTasksFinished();
+											}
+										);
+										if (--inProgressSorting === 0) onDependenciesSorted();
+										return;
+									}
+								}
+								if (unsafeCachedModule !== cachedModule) {
+									unsafeCacheDependencies.set(dep, cachedModule);
+								}
+								this._handleExistingModuleFromUnsafeCache(
+									module,
+									dep,
+									cachedModule
+								); // a3
+							} catch (err) {
+								if (inProgressSorting <= 0) return;
+								inProgressSorting = -1;
+								onDependenciesSorted(err);
+								return;
+							}
+							if (--inProgressSorting === 0) onDependenciesSorted();
+						});
 						return;
 					}
 				} catch (e) {
 					console.error(e);
 				}
 			}
+			processDependencyForResolving(dep);
+		};
+
+		/**
+		 * @param {Dependency} dep dependency
+		 * @returns {void}
+		 */
+		const processDependencyForResolving = dep => {
 			const resourceIdent = dep.getResourceIdentifier();
 			if (resourceIdent !== undefined && resourceIdent !== null) {
 				const category = dep.category;
@@ -1557,7 +1675,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				const block = queue.pop();
 				if (block.dependencies) {
 					currentBlock = block;
-					for (const dep of block.dependencies) processDependency(dep);
+					let i = 0;
+					for (const dep of block.dependencies) processDependency(dep, i++);
 				}
 				if (block.blocks) {
 					for (const b of block.blocks) queue.push(b);
@@ -1567,68 +1686,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			return callback(e);
 		}
 
-		if (sortedDependencies.length === 0 && unsafeRestoredModules.size === 0) {
-			callback();
-			return;
-		}
-
-		// This is nested so we need to allow one additional task
-		this.processDependenciesQueue.increaseParallelism();
-
-		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();
-			});
-		};
-
-		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
-			);
-		}
+		if (--inProgressSorting === 0) onDependenciesSorted();
 	}
 
-	_handleNewModuleFromUnsafeCache(originModule, dependency, module) {
+	_handleNewModuleFromUnsafeCache(originModule, dependency, module, callback) {
 		const moduleGraph = this.moduleGraph;
 
 		moduleGraph.setResolvedModule(originModule, dependency, module);
@@ -1641,6 +1702,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this._modules.set(module.identifier(), module);
 		this.modules.add(module);
 		ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+
+		this._handleModuleBuildAndDependencies(
+			originModule,
+			module,
+			true,
+			callback
+		);
 	}
 
 	_handleExistingModuleFromUnsafeCache(originModule, dependency, module) {
@@ -1744,20 +1812,24 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						/** @type {any} */ (module).restoreFromUnsafeCache &&
 						this._unsafeCachePredicate(module)
 					) {
+						const unsafeCacheableModule =
+							/** @type {Module & { restoreFromUnsafeCache: Function }} */ (
+								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)
+								unsafeCacheableModule
 							);
+							unsafeCacheDependencies.set(dependency, unsafeCacheableModule);
 						}
-						if (!unsafeCacheData.has(module)) {
-							unsafeCacheData.set(module, module.getUnsafeCacheData());
+						if (!unsafeCacheData.has(unsafeCacheableModule)) {
+							unsafeCacheData.set(
+								unsafeCacheableModule,
+								unsafeCacheableModule.getUnsafeCacheData()
+							);
 						}
 					} else {
 						applyFactoryResultDependencies();
@@ -2252,7 +2324,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		}
 
 		for (const module of modulesWithoutCache) {
-			const buildInfo = module.buildInfo && module.buildInfo.buildInfo;
+			const buildInfo = module.buildInfo;
 			if (buildInfo) {
 				// create a new entry
 				const memCache = new WeakTupleMap();
@@ -2334,12 +2406,15 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		);
 	}
 
-	_updateAffectedModulesWithIds() {
+	_computeAffectedModulesWithChunkGraph() {
 		const { moduleMemCaches } = this;
 		if (!moduleMemCaches) return;
 		const moduleMemCaches2 = (this.moduleMemCaches2 = new Map());
 		const { moduleGraph, chunkGraph } = this;
 		const key = "memCache2";
+		let statUnchanged = 0;
+		let statChanged = 0;
+		let statNew = 0;
 		/**
 		 * @param {Module} module module
 		 * @returns {{ modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[] }} references
@@ -2354,7 +2429,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				for (const m of outgoing.keys()) {
 					if (!m) continue;
 					if (modules === undefined) modules = new Map();
-					modules.set(m, chunkGraph.getModuleId(module));
+					modules.set(m, chunkGraph.getModuleId(m));
 				}
 			}
 			if (module.blocks.length > 0) {
@@ -2416,15 +2491,24 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					memCache: memCache2
 				});
 				moduleMemCaches2.set(module, memCache2);
+				statNew++;
 			} else if (!compareReferences(module, cache.references)) {
 				const memCache = new WeakTupleMap();
 				cache.references = computeReferences(module);
 				cache.memCache = memCache;
 				moduleMemCaches2.set(module, memCache);
+				statChanged++;
 			} else {
 				moduleMemCaches2.set(module, cache.memCache);
+				statUnchanged++;
 			}
 		}
+
+		this.logger.log(
+			`${Math.round(
+				(100 * statChanged) / (statNew + statChanged + statUnchanged)
+			)}% modules flagged as affected by chunk graph (${statNew} new modules, ${statChanged} changed, ${statUnchanged} unchanged)`
+		);
 	}
 
 	finish(callback) {
@@ -2727,13 +2811,14 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			this.chunkGroups.push(entrypoint);
 			connectChunkGroupAndChunk(entrypoint, chunk);
 
+			const entryModules = new Set();
 			for (const dep of [...this.globalEntry.dependencies, ...dependencies]) {
 				entrypoint.addOrigin(null, { name }, /** @type {any} */ (dep).request);
 
 				const module = this.moduleGraph.getModule(dep);
 				if (module) {
 					chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint);
-					this.assignDepth(module);
+					entryModules.add(module);
 					const modulesList = chunkGraphInit.get(entrypoint);
 					if (modulesList === undefined) {
 						chunkGraphInit.set(entrypoint, [module]);
@@ -2743,6 +2828,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				}
 			}
 
+			this.assignDepths(entryModules);
+
 			const mapAndSort = deps =>
 				deps
 					.map(dep => this.moduleGraph.getModule(dep))
@@ -2889,7 +2976,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 					this.assignRuntimeIds();
 
-					this._updateAffectedModulesWithIds();
+					this.logger.time("compute affected modules with chunk graph");
+					this._computeAffectedModulesWithChunkGraph();
+					this.logger.timeEnd("compute affected modules with chunk graph");
 
 					this.sortItemsWithChunkIds();
 
@@ -3510,6 +3599,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
+	 * @deprecated
 	 * @param {Module} module module to assign depth
 	 * @returns {void}
 	 */
@@ -3543,6 +3633,38 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		}
 	}
 
+	/**
+	 * @param {Set<Module>} modules module to assign depth
+	 * @returns {void}
+	 */
+	assignDepths(modules) {
+		const moduleGraph = this.moduleGraph;
+
+		/** @type {Set<Module | number>} */
+		const queue = new Set(modules);
+		queue.add(1);
+		let depth = 0;
+
+		let i = 0;
+		for (const module of queue) {
+			i++;
+			if (typeof module === "number") {
+				depth = module;
+				if (queue.size === i) return;
+				queue.add(depth + 1);
+			} else {
+				moduleGraph.setDepth(module, depth);
+				for (const { module: refModule } of moduleGraph.getOutgoingConnections(
+					module
+				)) {
+					if (refModule) {
+						queue.add(refModule);
+					}
+				}
+			}
+		}
+	}
+
 	/**
 	 * @param {Dependency} dependency the dependency
 	 * @param {RuntimeSpec} runtime the runtime

package/lib/DependenciesBlock.js

@@ -22,6 +22,15 @@ class DependenciesBlock {
 		this.dependencies = [];
 		/** @type {AsyncDependenciesBlock[]} */
 		this.blocks = [];
+		/** @type {DependenciesBlock} */
+		this.parent = undefined;
+	}
+
+	getRootBlock() {
+		/** @type {DependenciesBlock} */
+		let current = this;
+		while (current.parent) current = current.parent;
+		return current;
 	}
 
 	/**

package/lib/Dependency.js

@@ -91,6 +91,8 @@ class Dependency {
 		this._parentModule = undefined;
 		/** @type {DependenciesBlock} */
 		this._parentDependenciesBlock = undefined;
+		/** @type {number} */
+		this._parentDependenciesBlockIndex = -1;
 		// TODO check if this can be moved into ModuleDependency
 		/** @type {boolean} */
 		this.weak = false;