webpack 5.56.0 → 5.58.0

package/lib/Compilation.js

@@ -917,8 +917,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		};
 		defineRemovedModuleTemplates(this.moduleTemplates);
 
-		/** @type {WeakMap<Module, WeakTupleMap<any, any>> | undefined} */
+		/** @type {Map<Module, WeakTupleMap<any, any>> | undefined} */
 		this.moduleMemCaches = undefined;
+		/** @type {Map<Module, WeakTupleMap<any, any>> | undefined} */
+		this.moduleMemCaches2 = undefined;
 		this.moduleGraph = new ModuleGraph();
 		/** @type {ChunkGraph} */
 		this.chunkGraph = undefined;
@@ -1403,8 +1405,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) {
@@ -1448,10 +1451,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 		/**
 		 * @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);
@@ -1555,7 +1559,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);
@@ -2169,7 +2174,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		const moduleMemCacheCache = this.compiler.moduleMemCaches;
 		if (!moduleMemCacheCache) return;
 		if (!this.moduleMemCaches) {
-			this.moduleMemCaches = new WeakMap();
+			this.moduleMemCaches = new Map();
 			this.moduleGraph.setModuleMemCaches(this.moduleMemCaches);
 		}
 		const { moduleGraph, moduleMemCaches } = this;
@@ -2179,7 +2184,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		let statChanged = 0;
 		let statUnchanged = 0;
 		let statReferencesChanged = 0;
-		let statWithoutHash = 0;
+		let statWithoutBuild = 0;
 
 		const computeReferences = module => {
 			/** @type {WeakMap<Dependency, Module>} */
@@ -2211,48 +2216,63 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			return true;
 		};
 
-		for (const module of modules) {
-			const hash = module.buildInfo && module.buildInfo.hash;
-			if (typeof hash === "string") {
-				const cachedMemCache = moduleMemCacheCache.get(module);
-				if (cachedMemCache === undefined) {
-					// create a new entry
-					const memCache = new WeakTupleMap();
-					moduleMemCacheCache.set(module, {
-						hash: hash,
-						references: computeReferences(module),
-						memCache
-					});
-					moduleMemCaches.set(module, memCache);
-					affectedModules.add(module);
-					statNew++;
-				} else if (cachedMemCache.hash !== hash) {
-					// use a new one
-					const memCache = new WeakTupleMap();
-					moduleMemCaches.set(module, memCache);
-					affectedModules.add(module);
-					cachedMemCache.hash = hash;
-					cachedMemCache.references = computeReferences(module);
-					cachedMemCache.memCache = memCache;
-					statChanged++;
-				} else if (!compareReferences(module, cachedMemCache.references)) {
-					// use a new one
-					const memCache = new WeakTupleMap();
-					moduleMemCaches.set(module, memCache);
-					affectedModules.add(module);
-					cachedMemCache.references = computeReferences(module);
-					cachedMemCache.memCache = memCache;
-					statReferencesChanged++;
+		const modulesWithoutCache = new Set(modules);
+		for (const [module, cachedMemCache] of moduleMemCacheCache) {
+			if (modulesWithoutCache.has(module)) {
+				const buildInfo = module.buildInfo;
+				if (buildInfo) {
+					if (cachedMemCache.buildInfo !== buildInfo) {
+						// use a new one
+						const memCache = new WeakTupleMap();
+						moduleMemCaches.set(module, memCache);
+						affectedModules.add(module);
+						cachedMemCache.buildInfo = buildInfo;
+						cachedMemCache.references = computeReferences(module);
+						cachedMemCache.memCache = memCache;
+						statChanged++;
+					} else if (!compareReferences(module, cachedMemCache.references)) {
+						// use a new one
+						const memCache = new WeakTupleMap();
+						moduleMemCaches.set(module, memCache);
+						affectedModules.add(module);
+						cachedMemCache.references = computeReferences(module);
+						cachedMemCache.memCache = memCache;
+						statReferencesChanged++;
+					} else {
+						// keep the old mem cache
+						moduleMemCaches.set(module, cachedMemCache.memCache);
+						statUnchanged++;
+					}
 				} else {
-					// keep the old mem cache
-					moduleMemCaches.set(module, cachedMemCache.memCache);
-					statUnchanged++;
+					infectedModules.add(module);
+					moduleMemCacheCache.delete(module);
+					statWithoutBuild++;
 				}
+				modulesWithoutCache.delete(module);
+			} else {
+				moduleMemCacheCache.delete(module);
+			}
+		}
+
+		for (const module of modulesWithoutCache) {
+			const buildInfo = module.buildInfo;
+			if (buildInfo) {
+				// create a new entry
+				const memCache = new WeakTupleMap();
+				moduleMemCacheCache.set(module, {
+					buildInfo,
+					references: computeReferences(module),
+					memCache
+				});
+				moduleMemCaches.set(module, memCache);
+				affectedModules.add(module);
+				statNew++;
 			} else {
 				infectedModules.add(module);
-				statWithoutHash++;
+				statWithoutBuild++;
 			}
 		}
+
 		const reduceAffectType = connections => {
 			let affected = false;
 			for (const { dependency } of connections) {
@@ -2313,7 +2333,112 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				infectedModules.size
 			} infected of ${
 				this.modules.size
-			}) modules flagged as affected (${statNew} new modules, ${statChanged} changed, ${statReferencesChanged} references changed, ${statUnchanged} unchanged, ${statWithoutHash} without hash)`
+			}) modules flagged as affected (${statNew} new modules, ${statChanged} changed, ${statReferencesChanged} references changed, ${statUnchanged} unchanged, ${statWithoutBuild} were not built)`
+		);
+	}
+
+	_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
+		 */
+		const computeReferences = module => {
+			/** @type {Map<Module, string | number | undefined>} */
+			let modules = undefined;
+			/** @type {(string | number)[] | undefined} */
+			let blocks = undefined;
+			const outgoing = moduleGraph.getOutgoingConnectionsByModule(module);
+			if (outgoing !== undefined) {
+				for (const m of outgoing.keys()) {
+					if (!m) continue;
+					if (modules === undefined) modules = new Map();
+					modules.set(m, chunkGraph.getModuleId(m));
+				}
+			}
+			if (module.blocks.length > 0) {
+				blocks = [];
+				const queue = Array.from(module.blocks);
+				for (const block of queue) {
+					const chunkGroup = chunkGraph.getBlockChunkGroup(block);
+					if (chunkGroup) {
+						for (const chunk of chunkGroup.chunks) {
+							blocks.push(chunk.id);
+						}
+					} else {
+						blocks.push(null);
+					}
+					queue.push.apply(queue, block.blocks);
+				}
+			}
+			return { modules, blocks };
+		};
+		/**
+		 * @param {Module} module module
+		 * @param {Object} references references
+		 * @param {Map<Module, string | number>=} references.modules modules
+		 * @param {(string | number)[]=} references.blocks blocks
+		 * @returns {boolean} ok?
+		 */
+		const compareReferences = (module, { modules, blocks }) => {
+			if (modules !== undefined) {
+				for (const [module, id] of modules) {
+					if (chunkGraph.getModuleId(module) !== id) return false;
+				}
+			}
+			if (blocks !== undefined) {
+				const queue = Array.from(module.blocks);
+				let i = 0;
+				for (const block of queue) {
+					const chunkGroup = chunkGraph.getBlockChunkGroup(block);
+					if (chunkGroup) {
+						for (const chunk of chunkGroup.chunks) {
+							if (i >= blocks.length || blocks[i++] !== chunk.id) return false;
+						}
+					} else {
+						if (i >= blocks.length || blocks[i++] !== null) return false;
+					}
+					queue.push.apply(queue, block.blocks);
+				}
+				if (i !== blocks.length) return false;
+			}
+			return true;
+		};
+
+		for (const [module, memCache] of moduleMemCaches) {
+			/** @type {{ references: { modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[]}, memCache: WeakTupleMap<any[], any> }} */
+			const cache = memCache.get(key);
+			if (cache === undefined) {
+				const memCache2 = new WeakTupleMap();
+				memCache.set(key, {
+					references: computeReferences(module),
+					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)`
 		);
 	}
 
@@ -2561,6 +2686,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.assetsInfo.clear();
 		this.moduleGraph.removeAllModuleAttributes();
 		this.moduleGraph.unfreeze();
+		this.moduleMemCaches2 = undefined;
 	}
 
 	/**
@@ -2616,13 +2742,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]);
@@ -2632,6 +2759,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))
@@ -2778,6 +2907,10 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 					this.assignRuntimeIds();
 
+					this.logger.time("compute affected modules with chunk graph");
+					this._computeAffectedModulesWithChunkGraph();
+					this.logger.timeEnd("compute affected modules with chunk graph");
+
 					this.sortItemsWithChunkIds();
 
 					if (shouldRecord) {
@@ -3121,18 +3254,14 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		chunkGraphEntries = this._getChunkGraphEntries()
 	} = {}) {
 		const context = { chunkGraph, codeGenerationResults };
-		const { moduleMemCaches } = this;
+		const { moduleMemCaches2 } = 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);
+				const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
 				for (const runtime of chunkGraph.getModuleRuntimes(module)) {
 					if (memCache) {
 						const cached = memCache.get(
@@ -3401,6 +3530,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
+	 * @deprecated
 	 * @param {Module} module module to assign depth
 	 * @returns {void}
 	 */
@@ -3434,6 +3564,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
@@ -3471,7 +3633,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					this.moduleGraph.removeConnection(dep);
 
 					if (this.chunkGraph) {
-						for (const chunk of this.chunkGraph.getModuleChunks(
+						for (const chunk of this.chunkGraph.getModuleChunksIterable(
 							originalModule
 						)) {
 							this.patchChunksAfterReasonRemoval(originalModule, chunk);
@@ -3589,14 +3751,10 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	createModuleHashes() {
 		let statModulesHashed = 0;
 		let statModulesFromCache = 0;
-		const { chunkGraph, runtimeTemplate, moduleMemCaches } = this;
+		const { chunkGraph, runtimeTemplate, moduleMemCaches2 } = 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);
+			const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
 			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
 				if (memCache) {
 					const digest = memCache.get(`moduleHash-${getRuntimeKey(runtime)}`);

package/lib/Compiler.js

@@ -249,7 +249,7 @@ class Compiler {
 
 		this.cache = new Cache();
 
-		/** @type {WeakMap<Module, { hash: string, references: WeakMap<Dependency, Module>, memCache: WeakTupleMap }> | undefined} */
+		/** @type {Map<Module, { buildInfo: object, references: WeakMap<Dependency, Module>, memCache: WeakTupleMap }> | undefined} */
 		this.moduleMemCaches = undefined;
 
 		this.compilerPath = "";

package/lib/DefinePlugin.js

@@ -250,7 +250,7 @@ const toCacheVersion = code => {
 };
 
 const VALUE_DEP_PREFIX = "webpack/DefinePlugin ";
-const VALUE_DEP_MAIN = "webpack/DefinePlugin";
+const VALUE_DEP_MAIN = "webpack/DefinePlugin_hash";
 
 class DefinePlugin {
 	/**

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;

package/lib/DependencyTemplates.js

@@ -48,8 +48,7 @@ class DependencyTemplates {
 	 */
 	updateHash(part) {
 		const hash = createHash(this._hashFunction);
-		hash.update(this._hash);
-		hash.update(part);
+		hash.update(`${this._hash}${part}`);
 		this._hash = /** @type {string} */ (hash.digest("hex"));
 	}
 

package/lib/DllModule.js

@@ -117,8 +117,7 @@ class DllModule extends Module {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update("dll module");
-		hash.update(this.name || "");
+		hash.update(`dll module${this.name || ""}`);
 		super.updateHash(hash, context);
 	}
 

package/lib/ExportsInfo.js

@@ -1412,10 +1412,11 @@ class ExportInfo {
 	}
 
 	_updateHash(hash, runtime, alreadyVisitedExportsInfo) {
-		hash.update(`${this._usedName || this.name}`);
-		hash.update(`${this.getUsed(runtime)}`);
-		hash.update(`${this.provided}`);
-		hash.update(`${this.terminalBinding}`);
+		hash.update(
+			`${this._usedName || this.name}${this.getUsed(runtime)}${this.provided}${
+				this.terminalBinding
+			}`
+		);
 		if (this.exportsInfo && !alreadyVisitedExportsInfo.has(this.exportsInfo)) {
 			this.exportsInfo._updateHash(hash, runtime, alreadyVisitedExportsInfo);
 		}

package/lib/ExternalModule.js

@@ -32,6 +32,7 @@ const { register } = require("./util/serialization");
 /** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
@@ -497,6 +498,10 @@ class ExternalModule extends Module {
 		callback();
 	}
 
+	restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
+		this._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
+	}
+
 	/**
 	 * @param {ConcatenationBailoutReasonContext} context context
 	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
@@ -679,10 +684,10 @@ class ExternalModule extends Module {
 	 */
 	updateHash(hash, context) {
 		const { chunkGraph } = context;
-		hash.update(this.externalType);
-		hash.update(JSON.stringify(this.request));
 		hash.update(
-			JSON.stringify(Boolean(this.isOptional(chunkGraph.moduleGraph)))
+			`${this.externalType}${JSON.stringify(this.request)}${this.isOptional(
+				chunkGraph.moduleGraph
+			)}`
 		);
 		super.updateHash(hash, context);
 	}

package/lib/FlagDependencyUsagePlugin.js

@@ -46,10 +46,15 @@ class FlagDependencyUsagePlugin {
 					stage: STAGE_DEFAULT
 				},
 				modules => {
+					if (compilation.moduleMemCaches) {
+						throw new Error(
+							"optimization.usedExports can't be used with cacheUnaffected as export usage is a global effect"
+						);
+					}
+
 					const logger = compilation.getLogger(
 						"webpack.FlagDependencyUsagePlugin"
 					);
-
 					/** @type {Map<ExportsInfo, Module>} */
 					const exportInfoToModuleMap = new Map();
 

package/lib/Module.js

@@ -885,6 +885,10 @@ class Module extends DependenciesBlock {
 		return true;
 	}
 
+	hasChunkCondition() {
+		return this.chunkCondition !== Module.prototype.chunkCondition;
+	}
+
 	/**
 	 * Assuming this module is in the cache. Update the (cached) module with
 	 * the fresh module from the factory. Usually updates internal references