@depup/webpack 5.110.3-depup.0 → 5.111.1-depup.0

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -15,6 +15,10 @@ const HarmonyExportImportedSpecifierDependency = require("../dependencies/Harmon
 const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
 const HarmonyImportSpecifierDependency = require("../dependencies/HarmonyImportSpecifierDependency");
 const { ImportPhaseUtils } = require("../dependencies/ImportPhase");
+const {
+	getBuildDiagnostics,
+	recordOptimizationBailout
+} = require("../util/buildDiagnostics");
 const formatLocation = require("../util/formatLocation");
 const { dirname, join, readJson, relative } = require("../util/fs");
 const { getGlobToRegExpSource } = require("../util/globUtils");
@@ -35,7 +39,7 @@ const { CompilerHintNotationRegExp } = require("../util/magicComment");
  * } from "estree"
  */
 /** @import Compiler from "../Compiler" */
-/** @import Module, { BuildMeta } from "../Module" */
+/** @import Module, { BuildMeta, BuildInfo } from "../Module" */
 /**
  * @import {
  * 	JavascriptModuleBuildInfo
@@ -546,14 +550,18 @@ class SideEffectsFlagPlugin {
 							} else {
 								const type = sideEffectsStatement.type;
 								const loc = parser.getLocation(sideEffectsStatement);
-								moduleGraph
-									.getOptimizationBailout(parser.state.module)
-									.push(
-										() =>
-											`Statement (${type}) with side effects in source code at ${formatLocation(
-												loc
-											)}`
-									);
+								const at = formatLocation(loc);
+
+								const buildInfo = /** @type {BuildInfo} */ (
+									parser.state.module.buildInfo
+								);
+								recordOptimizationBailout(
+									buildInfo,
+									`Statement (${type}) with side effects in source code at ${at}`
+								);
+								// `performance.unusedModules` names the statement, so it is kept typed too.
+								getBuildDiagnostics(buildInfo).sideEffectStatement =
+									`${type} at ${at}`;
 							}
 						});
 					};
@@ -588,12 +596,8 @@ class SideEffectsFlagPlugin {
 							pureFunctions.add(name);
 						};
 
-						// Detect on function declarations
-						// Covers:
-						// 	1. function foo
-						//  2. export function foo
-						//  3. export default function foo
-						// 	4. export default function / export default () => {} (anonymous)
+						// Covers a plain `function foo`, an exported one, and an
+						// `export default` function whether named or anonymous.
 						parser.hooks.preStatementByType
 							.for("FunctionDeclaration")
 							.tap(PLUGIN_NAME, (statement) => {
@@ -609,13 +613,10 @@ class SideEffectsFlagPlugin {
 									markPure(name);
 									return;
 								}
-								const commentsStart = parser.prevStatement
-									? /** @type {Range} */ (parser.prevStatement.range)[1]
-									: 0;
 								if (
 									hasNoSideEffectsNotation(
 										parser,
-										commentsStart,
+										parser.getAttachedCommentsStart(statement),
 										/** @type {Range} */ (statement.range)[0]
 									)
 								) {
@@ -640,12 +641,9 @@ class SideEffectsFlagPlugin {
 							let hasAnnotation = false;
 							// Before the VariableDeclaration (only for const)
 							if (statement.kind === "const") {
-								const commentsStart = parser.prevStatement
-									? /** @type {Range} */ (parser.prevStatement.range)[1]
-									: 0;
 								hasAnnotation = hasNoSideEffectsNotation(
 									parser,
-									commentsStart,
+									parser.getAttachedCommentsStart(statement),
 									/** @type {Range} */ (statement.range)[0]
 								);
 							}
@@ -893,11 +891,9 @@ class SideEffectsFlagPlugin {
 											}
 											if (!target) continue;
 
-											// A deferred re-export must keep its side-effect-free
-											// barrel: collapsing it here would turn the cached
-											// deferred namespace (`.z`) into an eager import of the
-											// source module, breaking deferred-namespace identity
-											// and evaluation semantics.
+											// A deferred re-export keeps its side-effect-free barrel:
+											// collapsing it would turn the cached deferred namespace into
+											// an eager import, losing both identity and semantics.
 											if (
 												deferEnabled &&
 												isDeferredTargetConnection(target.connection)

package/lib/optimize/SplitChunksPlugin.js

@@ -1390,10 +1390,8 @@ class SplitChunksPlugin {
 								}
 							}
 						}
-						// Create key for maps
-						// When it has a name we use the name as key
-						// Otherwise we create the key from chunks and cache group key
-						// This automatically merges equal names
+						// A named group keys on its name, which merges equal names by itself;
+						// an unnamed one keys on its chunks and cache group.
 						const key = name
 							? `${cacheGroup.key} name:${name}`
 							: getUnnamedKey(cacheGroup, selectedChunksKey);

package/lib/performance/AnalyzableBailoutsPlugin.js

@@ -0,0 +1,115 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const AnalyzableBailoutsWarning = require("../errors/AnalyzableBailoutsWarning");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import Module from "../Module" */
+/** @import { BailoutDetails } from "../errors/AnalyzableBailoutsWarning" */
+
+const PLUGIN_NAME = "AnalyzableBailoutsPlugin";
+
+// Enough to point at the offenders without listing every module of a build.
+const MAX_REPORTED_MODULES = 5;
+
+class AnalyzableBailoutsPlugin {
+	/**
+	 * Creates an instance of AnalyzableBailoutsPlugin.
+	 * @param {PerformanceOptions} options the plugin options
+	 */
+	constructor(options) {
+		/** @type {PerformanceOptions["hints"]} */
+		this.hints = options.hints;
+	}
+
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const hints = this.hints;
+
+		if (!hints) return;
+
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			// `afterSeal` is past the hash, which folds every message into it — and
+			// past the runtime modules, which record their reasons while being hashed.
+			compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
+				const { chunkGraph, runtimeTemplate, requestShortener } = compilation;
+
+				// Nothing is recorded outside ESM output, so there is nothing to walk.
+				if (!runtimeTemplate.isModule()) return;
+
+				/** @type {Map<string, Set<string>>} */
+				const modulesByReason = new Map();
+
+				/**
+				 * Files the reasons recorded on a module under its printed name.
+				 * @param {Module} module the module, a runtime module included
+				 * @returns {void}
+				 */
+				const collect = (module) => {
+					const reasons = runtimeTemplate.analyzableBailoutsOf(module);
+					if (reasons.length === 0) return;
+					const name = module.readableIdentifier(requestShortener);
+					for (const reason of reasons) {
+						let modules = modulesByReason.get(reason);
+						if (modules === undefined) {
+							modules = new Set();
+							modulesByReason.set(reason, modules);
+						}
+						modules.add(name);
+					}
+				};
+
+				for (const module of compilation.modules) collect(module);
+				for (const chunk of compilation.chunks) {
+					for (const module of chunkGraph.getChunkRuntimeModulesIterable(
+						chunk
+					)) {
+						collect(module);
+					}
+				}
+
+				if (modulesByReason.size === 0) return;
+
+				/** @type {BailoutDetails[]} */
+				const bailouts = [];
+				let references = 0;
+
+				for (const [reason, modules] of modulesByReason) {
+					const names = [...modules].sort();
+					references += names.length;
+					bailouts.push({
+						reason,
+						modules: names.slice(0, MAX_REPORTED_MODULES),
+						count: names.length
+					});
+				}
+
+				// The reason holding the most modules leads; ties read in one order.
+				bailouts.sort(
+					(a, b) => b.count - a.count || (a.reason < b.reason ? -1 : 1)
+				);
+
+				const warning = new AnalyzableBailoutsWarning(bailouts, references);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = AnalyzableBailoutsPlugin;

package/lib/performance/BroadContextsPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const ContextModule = require("../ContextModule");
+const ContextModule = require("../context/ContextModule");
 const BroadContextsWarning = require("../errors/BroadContextsWarning");
 const { compareStrings } = require("../util/comparators");
 const getModuleSize = require("./getModuleSize");

package/lib/performance/CacheEffectivenessPlugin.js

@@ -65,10 +65,11 @@ class CacheEffectivenessPlugin {
 
 					uncacheable++;
 
+					const notCacheableReasons =
+						buildInfo.diagnostics && buildInfo.diagnostics.notCacheableReasons;
 					const reasons =
-						buildInfo.notCacheableReasons &&
-						buildInfo.notCacheableReasons.length > 0
-							? buildInfo.notCacheableReasons
+						notCacheableReasons && notCacheableReasons.length > 0
+							? notCacheableReasons
 							: [UNSPECIFIED_REASON];
 
 					for (const reason of reasons) {
@@ -82,10 +83,9 @@ class CacheEffectivenessPlugin {
 
 				if (!warmRebuild && uncacheable === 0) return;
 
-				// Most frequent first, and by reason where two are as frequent: the
-				// map is keyed in the order the modules were walked, which is not the
-				// same twice, and only three reasons are reported — so an unbroken tie
-				// would vary which of them a build names at all.
+				// Most frequent first, then by reason: the map is keyed in walk order,
+				// which differs between builds, and only three reasons are reported, so
+				// an unbroken tie would vary which of them a build names.
 				const sorted = [...modulesByReason].sort(
 					(a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)
 				);

package/lib/performance/DuplicateModulesPlugin.js

@@ -8,18 +8,17 @@
 const DuplicateModulesWarning = require("../errors/DuplicateModulesWarning");
 const { compareStrings } = require("../util/comparators");
 const getModuleSize = require("./getModuleSize");
+const getSourceModules = require("./getSourceModules");
 
 /** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Chunk from "../Chunk" */
 /** @import Compiler from "../Compiler" */
-/**
- * @import {
- * 	DuplicateModuleDetails
- * } from "../errors/DuplicateModulesWarning"
- */
+/** @import Module from "../Module" */
+/** @import { DuplicateModuleDetails } from "../errors/DuplicateModulesWarning" */
 
 const PLUGIN_NAME = "DuplicateModulesPlugin";
 
-// Enough to name the offenders without printing the module graph.
+// Enough to name the costliest without listing every shared module.
 const MAX_REPORTED_MODULES = 5;
 
 class DuplicateModulesPlugin {
@@ -44,24 +43,69 @@ class DuplicateModulesPlugin {
 
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
-				const { chunkGraph, requestShortener } = compilation;
+				const { chunkGraph, entrypoints, requestShortener } = compilation;
+
+				// The entrypoints a chunk is reached from, so a copy can be blamed on
+				// the pages that pay for it.
+				/** @type {Map<Chunk, Set<string>>} */
+				const chunkEntrypoints = new Map();
+
+				for (const [name, entrypoint] of entrypoints) {
+					for (const chunk of entrypoint.chunks) {
+						const names = chunkEntrypoints.get(chunk);
+
+						if (names === undefined) {
+							chunkEntrypoints.set(chunk, new Set([name]));
+						} else {
+							names.add(name);
+						}
+					}
+				}
+
+				/** @type {Map<Module, { chunks: Set<Chunk>, entrypoints: Set<string> }>} */
+				const copies = new Map();
+
+				for (const chunk of compilation.chunks) {
+					const names = chunkEntrypoints.get(chunk);
+
+					for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+						// Scope hoisting makes several modules into one, so a module
+						// concatenated into two chunks is in neither on its own.
+						for (const inner of getSourceModules(module)) {
+							let entry = copies.get(inner);
+
+							if (entry === undefined) {
+								copies.set(
+									inner,
+									(entry = { chunks: new Set(), entrypoints: new Set() })
+								);
+							}
+
+							entry.chunks.add(chunk);
+
+							if (names !== undefined) {
+								for (const name of names) entry.entrypoints.add(name);
+							}
+						}
+					}
+				}
+
 				/** @type {DuplicateModuleDetails[]} */
 				const duplicated = [];
 				let wasted = 0;
 
-				for (const module of compilation.modules) {
-					const chunks = chunkGraph.getNumberOfModuleChunks(module);
-
-					if (chunks < 2) continue;
+				for (const [module, { chunks, entrypoints: names }] of copies) {
+					if (chunks.size < 2) continue;
 
 					// The first copy is the one that had to be emitted; the rest are
 					// what a shared chunk would save.
-					const extra = getModuleSize(module) * (chunks - 1);
+					const extra = getModuleSize(module) * (chunks.size - 1);
 
 					wasted += extra;
 					duplicated.push({
 						name: module.readableIdentifier(requestShortener),
-						chunks,
+						chunks: chunks.size,
+						entrypoints: [...names].sort(compareStrings),
 						wasted: extra
 					});
 				}

package/lib/performance/EvalUsagePlugin.js

@@ -11,6 +11,7 @@ const {
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
 const EvalUsageWarning = require("../errors/EvalUsageWarning");
+const { getBuildDiagnostics } = require("../util/buildDiagnostics");
 const { compareStrings } = require("../util/comparators");
 
 /** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
@@ -59,7 +60,7 @@ class EvalUsagePlugin {
 							parser.state.module.buildInfo
 						);
 
-						buildInfo.usesEval = true;
+						getBuildDiagnostics(buildInfo).usesEval = true;
 					});
 				};
 
@@ -84,7 +85,9 @@ class EvalUsagePlugin {
 						// Every built module carries one, so only the field is in question.
 						const buildInfo = /** @type {BuildInfo} */ (module.buildInfo);
 
-						if (!buildInfo.usesEval) continue;
+						if (!buildInfo.diagnostics || !buildInfo.diagnostics.usesEval) {
+							continue;
+						}
 
 						callers.push(module.readableIdentifier(requestShortener));
 					}

package/lib/performance/MissingSourceMapsPlugin.js

@@ -0,0 +1,115 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const { SourceMapSource } = require("webpack-sources");
+const NormalModule = require("../NormalModule");
+const MissingSourceMapsWarning = require("../errors/MissingSourceMapsWarning");
+const { compareStrings } = require("../util/comparators");
+const getSourceModules = require("./getSourceModules");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import Module from "../Module" */
+/** @import RequestShortener from "../RequestShortener" */
+/** @import { MissingSourceMapDetails } from "../errors/MissingSourceMapsWarning" */
+
+const PLUGIN_NAME = "MissingSourceMapsPlugin";
+
+// Enough to name the offenders without listing every module a loader touched.
+const MAX_REPORTED_MODULES = 5;
+
+/**
+ * The loaders that ran on a module, shortened for reading.
+ * @param {NormalModule} module the module
+ * @param {RequestShortener} requestShortener the request shortener
+ * @returns {string[]} what to call them
+ */
+const loaderNames = (module, requestShortener) =>
+	module.loaders.map((it) => requestShortener.shorten(it.loader) || it.loader);
+
+class MissingSourceMapsPlugin {
+	/**
+	 * Creates an instance of MissingSourceMapsPlugin.
+	 * @param {PerformanceOptions} options the plugin options
+	 */
+	constructor(options) {
+		/** @type {PerformanceOptions["hints"]} */
+		this.hints = options.hints;
+	}
+
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const hints = this.hints;
+
+		if (!hints) return;
+
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			// `afterSeal` is past the hash, which folds every message into it — a
+			// hint reported earlier would change the build's identity.
+			compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
+				const { requestShortener } = compilation;
+				/** @type {MissingSourceMapDetails[]} */
+				const found = [];
+
+				// A module can be reached both on its own and inside a
+				// concatenation, so it is only counted the first time.
+				/** @type {Set<Module>} */
+				const seen = new Set();
+
+				for (const parent of compilation.modules) {
+					// Scope hoisting makes several modules into one, and each of them
+					// kept the source its own loaders produced.
+					for (const module of getSourceModules(parent)) {
+						if (seen.has(module)) continue;
+
+						seen.add(module);
+
+						if (!(module instanceof NormalModule)) continue;
+
+						// Only where a real map was asked for: the cheap devtools map to
+						// the loader output by design, so nothing is lost there.
+						if (!module.useSourceMap) continue;
+						if (module.loaders.length === 0) continue;
+
+						// A loader that returned a map produces a `SourceMapSource`;
+						// falling back to any other source is the map being dropped.
+						if (module.originalSource() instanceof SourceMapSource) continue;
+
+						found.push({
+							name: module.readableIdentifier(requestShortener),
+							loaders: loaderNames(module, requestShortener)
+						});
+					}
+				}
+
+				if (found.length === 0) return;
+
+				// By name: module order is not stable across runs.
+				found.sort((a, b) => compareStrings(a.name, b.name));
+
+				const warning = new MissingSourceMapsWarning(
+					found.slice(0, MAX_REPORTED_MODULES),
+					found.length
+				);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = MissingSourceMapsPlugin;

package/lib/performance/PureAnnotationsPlugin.js

@@ -11,6 +11,7 @@ const {
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
 const PureAnnotationsWarning = require("../errors/PureAnnotationsWarning");
+const { getBuildDiagnostics } = require("../util/buildDiagnostics");
 const { compareStrings } = require("../util/comparators");
 const { CompilerHintNotationRegExp } = require("../util/magicComment");
 
@@ -154,7 +155,7 @@ class PureAnnotationsPlugin {
 							parser.state.module.buildInfo
 						);
 
-						buildInfo.ineffectivePureAnnotations = wasted;
+						getBuildDiagnostics(buildInfo).ineffectivePureAnnotations = wasted;
 					});
 				};
 
@@ -180,9 +181,11 @@ class PureAnnotationsPlugin {
 						// Every built module carries one, so only the field is in question.
 						const buildInfo = /** @type {BuildInfo} */ (module.buildInfo);
 
-						if (!buildInfo.ineffectivePureAnnotations) continue;
+						const count =
+							buildInfo.diagnostics &&
+							buildInfo.diagnostics.ineffectivePureAnnotations;
 
-						const count = buildInfo.ineffectivePureAnnotations;
+						if (!count) continue;
 
 						total += count;
 						wasteful.push({

package/lib/performance/SizeLimitsPlugin.js

@@ -269,10 +269,8 @@ module.exports = class SizeLimitsPlugin {
 			}
 
 			if (hints) {
-				// 1. Individual Chunk: Size < 250kb
-				// 2. Collective Initial Chunks [entrypoint] (Each Set?): Size < 250kb
-				// 3. No Async Chunks
-				// if !1, then 2, if !2 return
+				// Each asset is checked against the limit first, then each entrypoint's
+				// initial chunks together; async chunks count towards neither.
 				if (assetsOverSizeLimit.length > 0) {
 					addLargestModules(compilation, assetsOverSizeLimit);
 					warnings.push(

package/lib/performance/TopLevelThisPlugin.js

@@ -11,14 +11,14 @@ const {
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
 const TopLevelThisWarning = require("../errors/TopLevelThisWarning");
+const { getBuildDiagnostics } = require("../util/buildDiagnostics");
 const { compareStrings } = require("../util/comparators");
 const getSourceModules = require("./getSourceModules");
 
 /** @import { Program } from "estree" */
 /** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
 /** @import Compiler from "../Compiler" */
-/** @import Module from "../Module" */
-/** @import { BuildInfo } from "../Module" */
+/** @import Module, { BuildInfo } from "../Module" */
 /** @import JavascriptParser from "../javascript/JavascriptParser" */
 /** @import { TopLevelThisDetails } from "../errors/TopLevelThisWarning" */
 
@@ -133,7 +133,7 @@ class TopLevelThisPlugin {
 							/** @type {BuildInfo} */
 							(parser.state.module.buildInfo);
 
-						buildInfo.topLevelThis = count;
+						getBuildDiagnostics(buildInfo).topLevelThis = count;
 					});
 				};
 
@@ -168,7 +168,8 @@ class TopLevelThisPlugin {
 							seen.add(module);
 
 							const buildInfo = /** @type {BuildInfo} */ (module.buildInfo);
-							const count = buildInfo.topLevelThis;
+							const count =
+								buildInfo.diagnostics && buildInfo.diagnostics.topLevelThis;
 
 							if (!count) continue;