webpack 5.34.0 → 5.36.1

package/lib/ChunkGraph.js

@@ -10,7 +10,6 @@ const Entrypoint = require("./Entrypoint");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
 const { first } = require("./util/SetHelpers");
 const SortableSet = require("./util/SortableSet");
-const StringXor = require("./util/StringXor");
 const {
 	compareModulesById,
 	compareIterables,
@@ -40,6 +39,8 @@ const {
 /** @type {ReadonlySet<string>} */
 const EMPTY_SET = new Set();
 
+const ZERO_BIG_INT = BigInt(0);
+
 const compareModuleIterables = compareIterables(compareModulesByIdentifier);
 
 /** @typedef {(c: Chunk, chunkGraph: ChunkGraph) => boolean} ChunkFilterPredicate */
@@ -1373,8 +1374,41 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		return runtimeRequirements === undefined ? EMPTY_SET : runtimeRequirements;
 	}
 
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {boolean} withConnections include connections
+	 * @returns {string} hash
+	 */
 	getModuleGraphHash(module, runtime, withConnections = true) {
 		const cgm = this._getChunkGraphModule(module);
+		return withConnections
+			? this._getModuleGraphHashWithConnections(cgm, module, runtime)
+			: this._getModuleGraphHashBigInt(cgm, module, runtime).toString(16);
+	}
+
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {boolean} withConnections include connections
+	 * @returns {bigint} hash
+	 */
+	getModuleGraphHashBigInt(module, runtime, withConnections = true) {
+		const cgm = this._getChunkGraphModule(module);
+		return withConnections
+			? BigInt(
+					`0x${this._getModuleGraphHashWithConnections(cgm, module, runtime)}`
+			  )
+			: this._getModuleGraphHashBigInt(cgm, module, runtime);
+	}
+
+	/**
+	 * @param {ChunkGraphModule} cgm the ChunkGraphModule
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {bigint} hash as big int
+	 */
+	_getModuleGraphHashBigInt(cgm, module, runtime) {
 		if (cgm.graphHashes === undefined) {
 			cgm.graphHashes = new RuntimeSpecMap();
 		}
@@ -1383,38 +1417,72 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 			hash.update(`${cgm.id}`);
 			hash.update(`${this.moduleGraph.isAsync(module)}`);
 			this.moduleGraph.getExportsInfo(module).updateHash(hash, runtime);
-			return /** @type {string} */ (hash.digest("hex"));
+			return BigInt(`0x${/** @type {string} */ (hash.digest("hex"))}`);
 		});
-		if (!withConnections) return graphHash;
+		return graphHash;
+	}
+
+	/**
+	 * @param {ChunkGraphModule} cgm the ChunkGraphModule
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {string} hash
+	 */
+	_getModuleGraphHashWithConnections(cgm, module, runtime) {
 		if (cgm.graphHashesWithConnections === undefined) {
 			cgm.graphHashesWithConnections = new RuntimeSpecMap();
 		}
 		const activeStateToString = state => {
-			if (state === false) return "false";
-			if (state === true) return "true";
-			if (state === ModuleGraphConnection.TRANSITIVE_ONLY) return "transitive";
+			if (state === false) return "F";
+			if (state === true) return "T";
+			if (state === ModuleGraphConnection.TRANSITIVE_ONLY) return "O";
 			throw new Error("Not implemented active state");
 		};
 		const strict = module.buildMeta && module.buildMeta.strictHarmonyModule;
 		return cgm.graphHashesWithConnections.provide(runtime, () => {
+			const graphHash = this._getModuleGraphHashBigInt(
+				cgm,
+				module,
+				runtime
+			).toString(16);
 			const connections = this.moduleGraph.getOutgoingConnections(module);
+			/** @type {Set<Module>} */
+			const activeNamespaceModules = new Set();
 			/** @type {Map<string, Module | Set<Module>>} */
 			const connectedModules = new Map();
-			for (const connection of connections) {
-				let stateInfo;
-				if (typeof runtime === "string") {
+			const processConnection = (connection, stateInfo) => {
+				const module = connection.module;
+				stateInfo += module.getExportsType(this.moduleGraph, strict);
+				// cspell:word Tnamespace
+				if (stateInfo === "Tnamespace") activeNamespaceModules.add(module);
+				else {
+					const oldModule = connectedModules.get(stateInfo);
+					if (oldModule === undefined) {
+						connectedModules.set(stateInfo, module);
+					} else if (oldModule instanceof Set) {
+						oldModule.add(module);
+					} else if (oldModule !== module) {
+						connectedModules.set(stateInfo, new Set([oldModule, module]));
+					}
+				}
+			};
+			if (runtime === undefined || typeof runtime === "string") {
+				for (const connection of connections) {
 					const state = connection.getActiveState(runtime);
 					if (state === false) continue;
-					stateInfo = activeStateToString(state);
-				} else {
+					processConnection(connection, state === true ? "T" : "O");
+				}
+			} else {
+				// cspell:word Tnamespace
+				for (const connection of connections) {
 					const states = new Set();
-					stateInfo = "";
+					let stateInfo = "";
 					forEachRuntime(
 						runtime,
 						runtime => {
 							const state = connection.getActiveState(runtime);
 							states.add(state);
-							stateInfo += runtime + activeStateToString(state);
+							stateInfo += activeStateToString(state) + runtime;
 						},
 						true
 					);
@@ -1423,34 +1491,49 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 						if (state === false) continue;
 						stateInfo = activeStateToString(state);
 					}
-				}
-				const module = connection.module;
-				stateInfo += module.getExportsType(this.moduleGraph, strict);
-				const oldModule = connectedModules.get(stateInfo);
-				if (oldModule === undefined) {
-					connectedModules.set(stateInfo, module);
-				} else if (oldModule instanceof Set) {
-					oldModule.add(module);
-				} else if (oldModule !== module) {
-					connectedModules.set(stateInfo, new Set([oldModule, module]));
+					processConnection(connection, stateInfo);
 				}
 			}
-			if (connectedModules.size === 0) return graphHash;
+			// cspell:word Tnamespace
+			if (activeNamespaceModules.size === 0 && connectedModules.size === 0)
+				return graphHash;
 			const connectedModulesInOrder =
 				connectedModules.size > 1
 					? Array.from(connectedModules).sort(([a], [b]) => (a < b ? -1 : 1))
 					: connectedModules;
 			const hash = createHash("md4");
+			const addModuleToHash = module => {
+				hash.update(
+					this._getModuleGraphHashBigInt(
+						this._getChunkGraphModule(module),
+						module,
+						runtime
+					).toString(16)
+				);
+			};
+			const addModulesToHash = modules => {
+				let xor = ZERO_BIG_INT;
+				for (const m of modules) {
+					xor =
+						xor ^
+						this._getModuleGraphHashBigInt(
+							this._getChunkGraphModule(m),
+							m,
+							runtime
+						);
+				}
+				hash.update(xor.toString(16));
+			};
+			if (activeNamespaceModules.size === 1)
+				addModuleToHash(activeNamespaceModules.values().next().value);
+			else if (activeNamespaceModules.size > 1)
+				addModulesToHash(activeNamespaceModules);
 			for (const [stateInfo, modules] of connectedModulesInOrder) {
 				hash.update(stateInfo);
 				if (modules instanceof Set) {
-					const xor = new StringXor();
-					for (const m of modules) {
-						xor.add(this.getModuleGraphHash(m, runtime, false));
-					}
-					xor.updateHash(hash);
+					addModulesToHash(modules);
 				} else {
-					hash.update(this.getModuleGraphHash(modules, runtime, false));
+					addModuleToHash(modules);
 				}
 			}
 			hash.update(graphHash);

package/lib/Compilation.js

@@ -1375,84 +1375,114 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 * @returns {void}
 	 */
 	_processModuleDependencies(module, callback) {
-		const dependencies = new Map();
-
 		/**
 		 * @type {Array<{factory: ModuleFactory, dependencies: Dependency[], originModule: Module|null}>}
 		 */
 		const sortedDependencies = [];
 
-		let currentBlock = module;
+		/** @type {DependenciesBlock} */
+		let currentBlock;
 
+		/** @type {Map<ModuleFactory, Map<string, Dependency[]>>} */
+		let dependencies;
+		/** @type {DepConstructor} */
 		let factoryCacheKey;
+		/** @type {ModuleFactory} */
+		let factoryCacheKey2;
+		/** @type {Map<string, Dependency[]>} */
 		let factoryCacheValue;
-		let factoryCacheValue2;
-		let listCacheKey;
+		/** @type {string} */
+		let listCacheKey1;
+		/** @type {string} */
+		let listCacheKey2;
+		/** @type {Dependency[]} */
 		let listCacheValue;
 
+		/**
+		 * @param {Dependency} dep dependency
+		 * @returns {void}
+		 */
 		const processDependency = dep => {
 			this.moduleGraph.setParents(dep, currentBlock, module);
 			const resourceIdent = dep.getResourceIdentifier();
-			if (resourceIdent) {
-				// Here webpack is using heuristic that assumes
-				// mostly esm dependencies would be used
-				// so we don't allocate extra string for them
+			if (resourceIdent !== undefined && resourceIdent !== null) {
 				const category = dep.category;
-				const cacheKey =
-					category === esmDependencyCategory
-						? resourceIdent
-						: `${category}${resourceIdent}`;
-				const constructor = dep.constructor;
-				let innerMap;
-				let factory;
+				const constructor = /** @type {DepConstructor} */ (dep.constructor);
 				if (factoryCacheKey === constructor) {
-					innerMap = factoryCacheValue;
-					if (listCacheKey === cacheKey) {
+					// Fast path 1: same constructor as prev item
+					if (listCacheKey1 === category && listCacheKey2 === resourceIdent) {
+						// Super fast path 1: also same resource
 						listCacheValue.push(dep);
 						return;
 					}
 				} else {
-					factory = this.dependencyFactories.get(dep.constructor);
+					const factory = this.dependencyFactories.get(constructor);
 					if (factory === undefined) {
 						throw new Error(
-							`No module factory available for dependency type: ${dep.constructor.name}`
+							`No module factory available for dependency type: ${constructor.name}`
 						);
 					}
-					innerMap = dependencies.get(factory);
-					if (innerMap === undefined) {
-						dependencies.set(factory, (innerMap = new Map()));
+					if (factoryCacheKey2 === factory) {
+						// Fast path 2: same factory as prev item
+						factoryCacheKey = constructor;
+						if (listCacheKey1 === category && listCacheKey2 === resourceIdent) {
+							// Super fast path 2: also same resource
+							listCacheValue.push(dep);
+							return;
+						}
+					} else {
+						// Slow path
+						if (factoryCacheKey2 !== undefined) {
+							// Archive last cache entry
+							if (dependencies === undefined) dependencies = new Map();
+							dependencies.set(factoryCacheKey2, factoryCacheValue);
+							factoryCacheValue = dependencies.get(factory);
+							if (factoryCacheValue === undefined) {
+								factoryCacheValue = new Map();
+							}
+						} else {
+							factoryCacheValue = new Map();
+						}
+						factoryCacheKey = constructor;
+						factoryCacheKey2 = factory;
 					}
-					factoryCacheKey = constructor;
-					factoryCacheValue = innerMap;
-					factoryCacheValue2 = factory;
 				}
-				let list = innerMap.get(cacheKey);
+				// Here webpack is using heuristic that assumes
+				// mostly esm dependencies would be used
+				// so we don't allocate extra string for them
+				const cacheKey =
+					category === esmDependencyCategory
+						? resourceIdent
+						: `${category}${resourceIdent}`;
+				let list = factoryCacheValue.get(cacheKey);
 				if (list === undefined) {
-					innerMap.set(cacheKey, (list = []));
+					factoryCacheValue.set(cacheKey, (list = []));
 					sortedDependencies.push({
-						factory: factoryCacheValue2,
+						factory: factoryCacheKey2,
 						dependencies: list,
 						originModule: module
 					});
 				}
 				list.push(dep);
-				listCacheKey = cacheKey;
+				listCacheKey1 = category;
+				listCacheKey2 = resourceIdent;
 				listCacheValue = list;
 			}
 		};
 
-		const processDependenciesBlock = block => {
-			if (block.dependencies) {
-				currentBlock = block;
-				for (const dep of block.dependencies) processDependency(dep);
-			}
-			if (block.blocks) {
-				for (const b of block.blocks) processDependenciesBlock(b);
-			}
-		};
-
 		try {
-			processDependenciesBlock(module);
+			/** @type {DependenciesBlock[]} */
+			const queue = [module];
+			do {
+				const block = queue.pop();
+				if (block.dependencies) {
+					currentBlock = block;
+					for (const dep of block.dependencies) processDependency(dep);
+				}
+				if (block.blocks) {
+					for (const b of block.blocks) queue.push(b);
+				}
+			} while (queue.length !== 0);
 		} catch (e) {
 			return callback(e);
 		}

package/lib/ContextModuleFactory.js

@@ -10,6 +10,7 @@ const { AsyncSeriesWaterfallHook, SyncWaterfallHook } = require("tapable");
 const ContextModule = require("./ContextModule");
 const ModuleFactory = require("./ModuleFactory");
 const ContextElementDependency = require("./dependencies/ContextElementDependency");
+const LazySet = require("./util/LazySet");
 const { cachedSetProperty } = require("./util/cleverMerge");
 const { createFakeHook } = require("./util/deprecation");
 const { join } = require("./util/fs");
@@ -87,9 +88,9 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 		const dependencies = data.dependencies;
 		const resolveOptions = data.resolveOptions;
 		const dependency = /** @type {ContextDependency} */ (dependencies[0]);
-		const fileDependencies = new Set();
-		const missingDependencies = new Set();
-		const contextDependencies = new Set();
+		const fileDependencies = new LazySet();
+		const missingDependencies = new LazySet();
+		const contextDependencies = new LazySet();
 		this.hooks.beforeResolve.callAsync(
 			{
 				context: context,

package/lib/Dependency.js

@@ -9,6 +9,7 @@ const memoize = require("./util/memoize");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
@@ -84,14 +85,23 @@ const getIgnoredModule = memoize(() => {
 
 class Dependency {
 	constructor() {
+		/** @type {Module} */
+		this._parentModule = undefined;
+		/** @type {DependenciesBlock} */
+		this._parentDependenciesBlock = undefined;
 		// TODO check if this can be moved into ModuleDependency
 		/** @type {boolean} */
 		this.weak = false;
 		// TODO check if this can be moved into ModuleDependency
 		/** @type {boolean} */
 		this.optional = false;
-		/** @type {DependencyLocation} */
-		this.loc = undefined;
+		this._locSL = 0;
+		this._locSC = 0;
+		this._locEL = 0;
+		this._locEC = 0;
+		this._locI = undefined;
+		this._locN = undefined;
+		this._loc = undefined;
 	}
 
 	/**
@@ -108,6 +118,56 @@ class Dependency {
 		return "unknown";
 	}
 
+	/**
+	 * @returns {DependencyLocation} location
+	 */
+	get loc() {
+		if (this._loc !== undefined) return this._loc;
+		/** @type {SyntheticDependencyLocation & RealDependencyLocation} */
+		const loc = {};
+		if (this._locSL > 0) {
+			loc.start = { line: this._locSL, column: this._locSC };
+		}
+		if (this._locEL > 0) {
+			loc.end = { line: this._locEL, column: this._locEC };
+		}
+		if (this._locN !== undefined) {
+			loc.name = this._locN;
+		}
+		if (this._locI !== undefined) {
+			loc.index = this._locI;
+		}
+		return (this._loc = loc);
+	}
+
+	set loc(loc) {
+		if ("start" in loc && typeof loc.start === "object") {
+			this._locSL = loc.start.line || 0;
+			this._locSC = loc.start.column || 0;
+		} else {
+			this._locSL = 0;
+			this._locSC = 0;
+		}
+		if ("end" in loc && typeof loc.end === "object") {
+			this._locEL = loc.end.line || 0;
+			this._locEC = loc.end.column || 0;
+		} else {
+			this._locEL = 0;
+			this._locEC = 0;
+		}
+		if ("index" in loc) {
+			this._locI = loc.index;
+		} else {
+			this._locI = undefined;
+		}
+		if ("name" in loc) {
+			this._locN = loc.name;
+		} else {
+			this._locN = undefined;
+		}
+		this._loc = loc;
+	}
+
 	/**
 	 * @returns {string | null} an identifier to merge equal requests
 	 */
@@ -207,13 +267,23 @@ class Dependency {
 	serialize({ write }) {
 		write(this.weak);
 		write(this.optional);
-		write(this.loc);
+		write(this._locSL);
+		write(this._locSC);
+		write(this._locEL);
+		write(this._locEC);
+		write(this._locI);
+		write(this._locN);
 	}
 
 	deserialize({ read }) {
 		this.weak = read();
 		this.optional = read();
-		this.loc = read();
+		this._locSL = read();
+		this._locSC = read();
+		this._locEL = read();
+		this._locEC = read();
+		this._locI = read();
+		this._locN = read();
 	}
 }
 

package/lib/FileSystemInfo.js

@@ -1249,7 +1249,7 @@ class FileSystemInfo {
 						return callback();
 					}
 					resolveResults.set(key, undefined);
-					resolveContext(context, path, resolverContext, (err, result) => {
+					resolveContext(context, path, resolverContext, (err, _, result) => {
 						if (err) {
 							if (expected === false) {
 								resolveResults.set(key, false);
@@ -1259,11 +1259,12 @@ class FileSystemInfo {
 							err.message += `\nwhile resolving '${path}' in ${context} to a directory`;
 							return callback(err);
 						}
-						resolveResults.set(key, result);
+						const resultPath = result.path;
+						resolveResults.set(key, resultPath);
 						push({
 							type: RBDT_DIRECTORY,
 							context: undefined,
-							path: result,
+							path: resultPath,
 							expected: undefined,
 							issuer: job
 						});
@@ -1276,14 +1277,16 @@ class FileSystemInfo {
 						return callback();
 					}
 					resolveResults.set(key, undefined);
-					resolve(context, path, resolverContext, (err, result) => {
+					resolve(context, path, resolverContext, (err, _, result) => {
 						if (typeof expected === "string") {
-							if (result === expected) {
-								resolveResults.set(key, result);
+							if (!err && result && result.path === expected) {
+								resolveResults.set(key, result.path);
 							} else {
 								invalidResolveResults.add(key);
 								this.logger.warn(
-									`Resolving '${path}' in ${context} for build dependencies doesn't lead to expected result '${expected}', but to '${result}' instead. Resolving dependencies are ignored for this path.\n${pathToString(
+									`Resolving '${path}' in ${context} for build dependencies doesn't lead to expected result '${expected}', but to '${
+										err || (result && result.path)
+									}' instead. Resolving dependencies are ignored for this path.\n${pathToString(
 										job
 									)}`
 								);
@@ -1300,11 +1303,12 @@ class FileSystemInfo {
 								)}`;
 								return callback(err);
 							}
-							resolveResults.set(key, result);
+							const resultPath = result.path;
+							resolveResults.set(key, resultPath);
 							push({
 								type: RBDT_FILE,
 								context: undefined,
-								path: result,
+								path: resultPath,
 								expected: undefined,
 								issuer: job
 							});
@@ -1646,38 +1650,42 @@ class FileSystemInfo {
 				const [type, context, path] = key.split("\n");
 				switch (type) {
 					case "d":
-						resolveContext(context, path, {}, (err, result) => {
+						resolveContext(context, path, {}, (err, _, result) => {
 							if (expectedResult === false)
 								return callback(err ? undefined : INVALID);
 							if (err) return callback(err);
-							if (result !== expectedResult) return callback(INVALID);
+							const resultPath = result.path;
+							if (resultPath !== expectedResult) return callback(INVALID);
 							callback();
 						});
 						break;
 					case "f":
-						resolveCjs(context, path, {}, (err, result) => {
+						resolveCjs(context, path, {}, (err, _, result) => {
 							if (expectedResult === false)
 								return callback(err ? undefined : INVALID);
 							if (err) return callback(err);
-							if (result !== expectedResult) return callback(INVALID);
+							const resultPath = result.path;
+							if (resultPath !== expectedResult) return callback(INVALID);
 							callback();
 						});
 						break;
 					case "c":
-						resolveCjsAsChild(context, path, {}, (err, result) => {
+						resolveCjsAsChild(context, path, {}, (err, _, result) => {
 							if (expectedResult === false)
 								return callback(err ? undefined : INVALID);
 							if (err) return callback(err);
-							if (result !== expectedResult) return callback(INVALID);
+							const resultPath = result.path;
+							if (resultPath !== expectedResult) return callback(INVALID);
 							callback();
 						});
 						break;
 					case "e":
-						resolveEsm(context, path, {}, (err, result) => {
+						resolveEsm(context, path, {}, (err, _, result) => {
 							if (expectedResult === false)
 								return callback(err ? undefined : INVALID);
 							if (err) return callback(err);
-							if (result !== expectedResult) return callback(INVALID);
+							const resultPath = result.path;
+							if (resultPath !== expectedResult) return callback(INVALID);
 							callback();
 						});
 						break;