webpack 5.99.6 → 5.99.8

package/lib/optimize/AggressiveSplittingPlugin.js

@@ -52,6 +52,8 @@ const isNotAEntryModule = (chunkGraph, chunk) => module =>
 /** @type {WeakSet<Chunk>} */
 const recordedChunks = new WeakSet();
 
+const PLUGIN_NAME = "AggressiveSplittingPlugin";
+
 class AggressiveSplittingPlugin {
 	/**
 	 * @param {AggressiveSplittingPluginOptions=} options options object
@@ -88,261 +90,251 @@ class AggressiveSplittingPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"AggressiveSplittingPlugin",
-			compilation => {
-				let needAdditionalSeal = false;
-				/** @typedef {{ id?: NonNullable<Chunk["id"]>, hash?: NonNullable<Chunk["hash"]>, modules: Module[], size: number }} SplitData */
-				/** @type {SplitData[]} */
-				let newSplits;
-				/** @type {Set<Chunk>} */
-				let fromAggressiveSplittingSet;
-				/** @type {Map<Chunk, SplitData>} */
-				let chunkSplitDataMap;
-				compilation.hooks.optimize.tap("AggressiveSplittingPlugin", () => {
-					newSplits = [];
-					fromAggressiveSplittingSet = new Set();
-					chunkSplitDataMap = new Map();
-				});
-				compilation.hooks.optimizeChunks.tap(
-					{
-						name: "AggressiveSplittingPlugin",
-						stage: STAGE_ADVANCED
-					},
-					chunks => {
-						const chunkGraph = compilation.chunkGraph;
-						// Precompute stuff
-						const nameToModuleMap = new Map();
-						const moduleToNameMap = new Map();
-						const makePathsRelative =
-							identifierUtils.makePathsRelative.bindContextCache(
-								compiler.context,
-								compiler.root
-							);
-						for (const m of compilation.modules) {
-							const name = makePathsRelative(m.identifier());
-							nameToModuleMap.set(name, m);
-							moduleToNameMap.set(m, name);
-						}
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+			let needAdditionalSeal = false;
+			/** @typedef {{ id?: NonNullable<Chunk["id"]>, hash?: NonNullable<Chunk["hash"]>, modules: Module[], size: number }} SplitData */
+			/** @type {SplitData[]} */
+			let newSplits;
+			/** @type {Set<Chunk>} */
+			let fromAggressiveSplittingSet;
+			/** @type {Map<Chunk, SplitData>} */
+			let chunkSplitDataMap;
+			compilation.hooks.optimize.tap(PLUGIN_NAME, () => {
+				newSplits = [];
+				fromAggressiveSplittingSet = new Set();
+				chunkSplitDataMap = new Map();
+			});
+			compilation.hooks.optimizeChunks.tap(
+				{
+					name: PLUGIN_NAME,
+					stage: STAGE_ADVANCED
+				},
+				chunks => {
+					const chunkGraph = compilation.chunkGraph;
+					// Precompute stuff
+					const nameToModuleMap = new Map();
+					const moduleToNameMap = new Map();
+					const makePathsRelative =
+						identifierUtils.makePathsRelative.bindContextCache(
+							compiler.context,
+							compiler.root
+						);
+					for (const m of compilation.modules) {
+						const name = makePathsRelative(m.identifier());
+						nameToModuleMap.set(name, m);
+						moduleToNameMap.set(m, name);
+					}
+
+					// Check used chunk ids
+					const usedIds = new Set();
+					for (const chunk of chunks) {
+						usedIds.add(chunk.id);
+					}
+
+					const recordedSplits =
+						(compilation.records && compilation.records.aggressiveSplits) || [];
+					const usedSplits = newSplits
+						? recordedSplits.concat(newSplits)
+						: recordedSplits;
 
-						// Check used chunk ids
-						const usedIds = new Set();
-						for (const chunk of chunks) {
-							usedIds.add(chunk.id);
+					const minSize = /** @type {number} */ (this.options.minSize);
+					const maxSize = /** @type {number} */ (this.options.maxSize);
+
+					/**
+					 * @param {SplitData} splitData split data
+					 * @returns {boolean} true when applied, otherwise false
+					 */
+					const applySplit = splitData => {
+						// Cannot split if id is already taken
+						if (splitData.id !== undefined && usedIds.has(splitData.id)) {
+							return false;
 						}
 
-						const recordedSplits =
-							(compilation.records && compilation.records.aggressiveSplits) ||
-							[];
-						const usedSplits = newSplits
-							? recordedSplits.concat(newSplits)
-							: recordedSplits;
-
-						const minSize = /** @type {number} */ (this.options.minSize);
-						const maxSize = /** @type {number} */ (this.options.maxSize);
-
-						/**
-						 * @param {SplitData} splitData split data
-						 * @returns {boolean} true when applied, otherwise false
-						 */
-						const applySplit = splitData => {
-							// Cannot split if id is already taken
-							if (splitData.id !== undefined && usedIds.has(splitData.id)) {
-								return false;
-							}
+						// Get module objects from names
+						const selectedModules = splitData.modules.map(name =>
+							nameToModuleMap.get(name)
+						);
 
-							// Get module objects from names
-							const selectedModules = splitData.modules.map(name =>
-								nameToModuleMap.get(name)
-							);
-
-							// Does the modules exist at all?
-							if (!selectedModules.every(Boolean)) return false;
-
-							// Check if size matches (faster than waiting for hash)
-							let size = 0;
-							for (const m of selectedModules) size += m.size();
-							if (size !== splitData.size) return false;
-
-							// get chunks with all modules
-							const selectedChunks = intersect(
-								selectedModules.map(
-									m => new Set(chunkGraph.getModuleChunksIterable(m))
-								)
-							);
-
-							// No relevant chunks found
-							if (selectedChunks.size === 0) return false;
-
-							// The found chunk is already the split or similar
-							if (
-								selectedChunks.size === 1 &&
-								chunkGraph.getNumberOfChunkModules(
-									Array.from(selectedChunks)[0]
-								) === selectedModules.length
-							) {
-								const chunk = Array.from(selectedChunks)[0];
-								if (fromAggressiveSplittingSet.has(chunk)) return false;
-								fromAggressiveSplittingSet.add(chunk);
-								chunkSplitDataMap.set(chunk, splitData);
-								return true;
-							}
+						// Does the modules exist at all?
+						if (!selectedModules.every(Boolean)) return false;
 
-							// split the chunk into two parts
-							const newChunk = compilation.addChunk();
-							newChunk.chunkReason = "aggressive splitted";
-							for (const chunk of selectedChunks) {
-								for (const module of selectedModules) {
-									moveModuleBetween(chunkGraph, chunk, newChunk)(module);
-								}
-								chunk.split(newChunk);
-								chunk.name = /** @type {TODO} */ (null);
-							}
-							fromAggressiveSplittingSet.add(newChunk);
-							chunkSplitDataMap.set(newChunk, splitData);
+						// Check if size matches (faster than waiting for hash)
+						let size = 0;
+						for (const m of selectedModules) size += m.size();
+						if (size !== splitData.size) return false;
 
-							if (splitData.id !== null && splitData.id !== undefined) {
-								newChunk.id = splitData.id;
-								newChunk.ids = [splitData.id];
-							}
-							return true;
-						};
+						// get chunks with all modules
+						const selectedChunks = intersect(
+							selectedModules.map(
+								m => new Set(chunkGraph.getModuleChunksIterable(m))
+							)
+						);
+
+						// No relevant chunks found
+						if (selectedChunks.size === 0) return false;
 
-						// try to restore to recorded splitting
-						let changed = false;
-						for (let j = 0; j < usedSplits.length; j++) {
-							const splitData = usedSplits[j];
-							if (applySplit(splitData)) changed = true;
+						// The found chunk is already the split or similar
+						if (
+							selectedChunks.size === 1 &&
+							chunkGraph.getNumberOfChunkModules(
+								Array.from(selectedChunks)[0]
+							) === selectedModules.length
+						) {
+							const chunk = Array.from(selectedChunks)[0];
+							if (fromAggressiveSplittingSet.has(chunk)) return false;
+							fromAggressiveSplittingSet.add(chunk);
+							chunkSplitDataMap.set(chunk, splitData);
+							return true;
 						}
 
-						// for any chunk which isn't splitted yet, split it and create a new entry
-						// start with the biggest chunk
-						const cmpFn = compareChunks(chunkGraph);
-						const sortedChunks = Array.from(chunks).sort((a, b) => {
-							const diff1 =
-								chunkGraph.getChunkModulesSize(b) -
-								chunkGraph.getChunkModulesSize(a);
-							if (diff1) return diff1;
-							const diff2 =
-								chunkGraph.getNumberOfChunkModules(a) -
-								chunkGraph.getNumberOfChunkModules(b);
-							if (diff2) return diff2;
-							return cmpFn(a, b);
-						});
-						for (const chunk of sortedChunks) {
-							if (fromAggressiveSplittingSet.has(chunk)) continue;
-							const size = chunkGraph.getChunkModulesSize(chunk);
-							if (
-								size > maxSize &&
-								chunkGraph.getNumberOfChunkModules(chunk) > 1
-							) {
-								const modules = chunkGraph
-									.getOrderedChunkModules(chunk, compareModulesByIdentifier)
-									.filter(isNotAEntryModule(chunkGraph, chunk));
-								const selectedModules = [];
-								let selectedModulesSize = 0;
-								for (let k = 0; k < modules.length; k++) {
-									const module = modules[k];
-									const newSize = selectedModulesSize + module.size();
-									if (newSize > maxSize && selectedModulesSize >= minSize) {
-										break;
-									}
-									selectedModulesSize = newSize;
-									selectedModules.push(module);
-								}
-								if (selectedModules.length === 0) continue;
-								/** @type {SplitData} */
-								const splitData = {
-									modules: selectedModules
-										.map(m => moduleToNameMap.get(m))
-										.sort(),
-									size: selectedModulesSize
-								};
-
-								if (applySplit(splitData)) {
-									newSplits = (newSplits || []).concat(splitData);
-									changed = true;
-								}
+						// split the chunk into two parts
+						const newChunk = compilation.addChunk();
+						newChunk.chunkReason = "aggressive splitted";
+						for (const chunk of selectedChunks) {
+							for (const module of selectedModules) {
+								moveModuleBetween(chunkGraph, chunk, newChunk)(module);
 							}
+							chunk.split(newChunk);
+							chunk.name = null;
 						}
-						if (changed) return true;
-					}
-				);
-				compilation.hooks.recordHash.tap(
-					"AggressiveSplittingPlugin",
-					records => {
-						// 4. save made splittings to records
-						const allSplits = new Set();
-						/** @type {Set<SplitData>} */
-						const invalidSplits = new Set();
-
-						// Check if some splittings are invalid
-						// We remove invalid splittings and try again
-						for (const chunk of compilation.chunks) {
-							const splitData = chunkSplitDataMap.get(chunk);
-							if (
-								splitData !== undefined &&
-								splitData.hash &&
-								chunk.hash !== splitData.hash
-							) {
-								// Split was successful, but hash doesn't equal
-								// We can throw away the split since it's useless now
-								invalidSplits.add(splitData);
-							}
+						fromAggressiveSplittingSet.add(newChunk);
+						chunkSplitDataMap.set(newChunk, splitData);
+
+						if (splitData.id !== null && splitData.id !== undefined) {
+							newChunk.id = splitData.id;
+							newChunk.ids = [splitData.id];
 						}
+						return true;
+					};
+
+					// try to restore to recorded splitting
+					let changed = false;
+					for (let j = 0; j < usedSplits.length; j++) {
+						const splitData = usedSplits[j];
+						if (applySplit(splitData)) changed = true;
+					}
 
-						if (invalidSplits.size > 0) {
-							records.aggressiveSplits =
-								/** @type {SplitData[]} */
-								(records.aggressiveSplits).filter(
-									splitData => !invalidSplits.has(splitData)
-								);
-							needAdditionalSeal = true;
-						} else {
-							// set hash and id values on all (new) splittings
-							for (const chunk of compilation.chunks) {
-								const splitData = chunkSplitDataMap.get(chunk);
-								if (splitData !== undefined) {
-									splitData.hash =
-										/** @type {NonNullable<Chunk["hash"]>} */
-										(chunk.hash);
-									splitData.id =
-										/** @type {NonNullable<Chunk["id"]>} */
-										(chunk.id);
-									allSplits.add(splitData);
-									// set flag for stats
-									recordedChunks.add(chunk);
+					// for any chunk which isn't splitted yet, split it and create a new entry
+					// start with the biggest chunk
+					const cmpFn = compareChunks(chunkGraph);
+					const sortedChunks = Array.from(chunks).sort((a, b) => {
+						const diff1 =
+							chunkGraph.getChunkModulesSize(b) -
+							chunkGraph.getChunkModulesSize(a);
+						if (diff1) return diff1;
+						const diff2 =
+							chunkGraph.getNumberOfChunkModules(a) -
+							chunkGraph.getNumberOfChunkModules(b);
+						if (diff2) return diff2;
+						return cmpFn(a, b);
+					});
+					for (const chunk of sortedChunks) {
+						if (fromAggressiveSplittingSet.has(chunk)) continue;
+						const size = chunkGraph.getChunkModulesSize(chunk);
+						if (
+							size > maxSize &&
+							chunkGraph.getNumberOfChunkModules(chunk) > 1
+						) {
+							const modules = chunkGraph
+								.getOrderedChunkModules(chunk, compareModulesByIdentifier)
+								.filter(isNotAEntryModule(chunkGraph, chunk));
+							const selectedModules = [];
+							let selectedModulesSize = 0;
+							for (let k = 0; k < modules.length; k++) {
+								const module = modules[k];
+								const newSize = selectedModulesSize + module.size();
+								if (newSize > maxSize && selectedModulesSize >= minSize) {
+									break;
 								}
+								selectedModulesSize = newSize;
+								selectedModules.push(module);
 							}
+							if (selectedModules.length === 0) continue;
+							/** @type {SplitData} */
+							const splitData = {
+								modules: selectedModules
+									.map(m => moduleToNameMap.get(m))
+									.sort(),
+								size: selectedModulesSize
+							};
 
-							// Also add all unused historical splits (after the used ones)
-							// They can still be used in some future compilation
-							const recordedSplits =
-								compilation.records && compilation.records.aggressiveSplits;
-							if (recordedSplits) {
-								for (const splitData of recordedSplits) {
-									if (!invalidSplits.has(splitData)) allSplits.add(splitData);
-								}
+							if (applySplit(splitData)) {
+								newSplits = (newSplits || []).concat(splitData);
+								changed = true;
 							}
+						}
+					}
+					if (changed) return true;
+				}
+			);
+			compilation.hooks.recordHash.tap(PLUGIN_NAME, records => {
+				// 4. save made splittings to records
+				const allSplits = new Set();
+				/** @type {Set<SplitData>} */
+				const invalidSplits = new Set();
 
-							// record all splits
-							records.aggressiveSplits = Array.from(allSplits);
+				// Check if some splittings are invalid
+				// We remove invalid splittings and try again
+				for (const chunk of compilation.chunks) {
+					const splitData = chunkSplitDataMap.get(chunk);
+					if (
+						splitData !== undefined &&
+						splitData.hash &&
+						chunk.hash !== splitData.hash
+					) {
+						// Split was successful, but hash doesn't equal
+						// We can throw away the split since it's useless now
+						invalidSplits.add(splitData);
+					}
+				}
 
-							needAdditionalSeal = false;
+				if (invalidSplits.size > 0) {
+					records.aggressiveSplits =
+						/** @type {SplitData[]} */
+						(records.aggressiveSplits).filter(
+							splitData => !invalidSplits.has(splitData)
+						);
+					needAdditionalSeal = true;
+				} else {
+					// set hash and id values on all (new) splittings
+					for (const chunk of compilation.chunks) {
+						const splitData = chunkSplitDataMap.get(chunk);
+						if (splitData !== undefined) {
+							splitData.hash =
+								/** @type {NonNullable<Chunk["hash"]>} */
+								(chunk.hash);
+							splitData.id =
+								/** @type {NonNullable<Chunk["id"]>} */
+								(chunk.id);
+							allSplits.add(splitData);
+							// set flag for stats
+							recordedChunks.add(chunk);
 						}
 					}
-				);
-				compilation.hooks.needAdditionalSeal.tap(
-					"AggressiveSplittingPlugin",
-					() => {
-						if (needAdditionalSeal) {
-							needAdditionalSeal = false;
-							return true;
+
+					// Also add all unused historical splits (after the used ones)
+					// They can still be used in some future compilation
+					const recordedSplits =
+						compilation.records && compilation.records.aggressiveSplits;
+					if (recordedSplits) {
+						for (const splitData of recordedSplits) {
+							if (!invalidSplits.has(splitData)) allSplits.add(splitData);
 						}
 					}
-				);
-			}
-		);
+
+					// record all splits
+					records.aggressiveSplits = Array.from(allSplits);
+
+					needAdditionalSeal = false;
+				}
+			});
+			compilation.hooks.needAdditionalSeal.tap(PLUGIN_NAME, () => {
+				if (needAdditionalSeal) {
+					needAdditionalSeal = false;
+					return true;
+				}
+			});
+		});
 	}
 }
 module.exports = AggressiveSplittingPlugin;

package/lib/optimize/ConcatenatedModule.js

@@ -84,6 +84,7 @@ const {
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {typeof import("../util/Hash")} HashConstructor */
+/** @typedef {import("../util/concatenate").ScopeInfo} ScopeInfo */
 /** @typedef {import("../util/concatenate").UsedNames} UsedNames */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
@@ -1138,13 +1139,8 @@ class ConcatenatedModule extends Module {
 		const topLevelDeclarations = new Set();
 
 		// List of additional names in scope for module references
-		/** @type {Map<string, { usedNames: UsedNames, alreadyCheckedScopes: Set<TODO> }>} */
+		/** @type {Map<string, ScopeInfo>} */
 		const usedNamesInScopeInfo = new Map();
-		/**
-		 * @param {string} module module identifier
-		 * @param {string} id export id
-		 * @returns {{ usedNames: UsedNames, alreadyCheckedScopes: Set<TODO> }} info
-		 */
 
 		// Set of already checked scopes
 		const ignoredScopes = new Set();
@@ -1163,7 +1159,7 @@ class ConcatenatedModule extends Module {
 				const superClassCache = new WeakMap();
 				/**
 				 * @param {Scope} scope scope
-				 * @returns {TODO} result
+				 * @returns {{ range: Range, variables: Variable[] }[]} result
 				 */
 				const getSuperClassExpressions = scope => {
 					const cacheEntry = superClassCache.get(scope);
@@ -1178,7 +1174,7 @@ class ConcatenatedModule extends Module {
 							block.superClass
 						) {
 							superClassExpressions.push({
-								range: block.superClass.range,
+								range: /** @type {Range} */ (block.superClass.range),
 								variables: childScope.variables
 							});
 						}
@@ -1428,9 +1424,9 @@ class ConcatenatedModule extends Module {
 		/** @type {Set<string>} */
 		const unusedExports = new Set();
 
-		const rootInfo = /** @type {ConcatenatedModuleInfo} */ (
-			moduleToInfoMap.get(this.rootModule)
-		);
+		const rootInfo =
+			/** @type {ConcatenatedModuleInfo} */
+			(moduleToInfoMap.get(this.rootModule));
 		const strictHarmonyModule =
 			/** @type {BuildMeta} */
 			(rootInfo.module.buildMeta).strictHarmonyModule;
@@ -1632,7 +1628,8 @@ ${defineGetters}`
 					);
 					runtimeRequirements.add(RuntimeGlobals.require);
 					const { runtimeCondition } =
-						/** @type {ExternalModuleInfo | ReferenceToModuleInfo} */ (rawInfo);
+						/** @type {ExternalModuleInfo | ReferenceToModuleInfo} */
+						(rawInfo);
 					const condition = runtimeTemplate.runtimeConditionExpression({
 						chunkGraph,
 						runtimeCondition,
@@ -1730,9 +1727,9 @@ ${defineGetters}`
 					codeGenerationResults,
 					sourceTypes: JS_TYPES
 				});
-				const source = /** @type {Source} */ (
-					codeGenResult.sources.get("javascript")
-				);
+				const source =
+					/** @type {Source} */
+					(codeGenResult.sources.get("javascript"));
 				const data = codeGenResult.data;
 				const chunkInitFragments = data && data.get("chunkInitFragments");
 				const code = source.source().toString();
@@ -1742,7 +1739,9 @@ ${defineGetters}`
 						sourceType: "module"
 					});
 				} catch (_err) {
-					const err = /** @type {TODO} */ (_err);
+					const err =
+						/** @type {Error & { loc?: { line: number, column: number } }} */
+						(_err);
 					if (
 						err.loc &&
 						typeof err.loc === "object" &&