webpack 5.110.3 → 5.111.0

package/lib/optimize/InlineExports.js

@@ -17,6 +17,7 @@ const { propertyAccess } = require("../util/property");
 /** @import ModuleGraph from "../ModuleGraph" */
 /** @import Module from "../Module" */
 /** @import { RuntimeSpec } from "../util/runtime" */
+/** @import Hash from "../util/Hash" */
 
 const MAX_INLINE_BYTES = 6;
 
@@ -60,6 +61,14 @@ class InlinedValue {
 		return `(${comment}${this.renderLiteral()})`;
 	}
 
+	/**
+	 * @param {InlinedValue} other other inlined value
+	 * @returns {boolean} true when kind and value match
+	 */
+	equals(other) {
+		return this.kind === other.kind && this.value === other.value;
+	}
+
 	/**
 	 * @param {ObjectSerializerContext} context context
 	 */
@@ -96,12 +105,21 @@ class InlinedUsedName {
 	}
 
 	/**
-	 * @param {string} comment leading comment text
+	 * @param {string=} comment leading comment text
 	 * @returns {string} rendered literal with property access suffix
 	 */
-	render(comment) {
+	render(comment = "") {
 		return this.value.render(comment) + propertyAccess(this.suffix);
 	}
+
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @returns {void}
+	 */
+	updateHash(hash) {
+		hash.update(this.render());
+	}
 }
 
 /**
@@ -172,131 +190,10 @@ const isExportInlined = (moduleGraph, module, ids, runtime) => {
 	return moduleGraph.getExportsInfo(module).hasInlinedUsedName(ids, runtime);
 };
 
-/**
- * Collects, by an iterative Tarjan pass, the modules a cycle peer may read in
- * their dead zone. A cycle of bare side-effect imports still inlines.
- * @param {ModuleGraph} moduleGraph module graph
- * @param {Iterable<Module>} modules all modules of the compilation
- * @returns {Set<Module>} modules whose exports must not be inlined
- */
-const findModulesInCycles = (moduleGraph, modules) => {
-	const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
-	const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
-
-	/** @type {Set<Module>} */
-	const inCycle = new Set();
-	/** @type {[Module, Module][]} */
-	const bindingReads = [];
-	/** @type {Map<Module, number>} */
-	const componentOf = new Map();
-	let nextComponent = 0;
-	/** @type {Map<Module, number>} */
-	const index = new Map();
-	/** @type {Map<Module, number>} */
-	const low = new Map();
-	/** @type {Set<Module>} */
-	const onStack = new Set();
-	/** @type {Module[]} */
-	const componentStack = [];
-	let counter = 0;
-	/**
-	 * @param {Module} module the module
-	 * @returns {Module[]} modules it imports, self included when self-importing
-	 */
-	const targetsOf = (module) => {
-		const connections = moduleGraph.getOutgoingConnectionsByModule(module);
-		if (!connections) return [];
-		/** @type {Module[]} */
-		const targets = [];
-		for (const [target, moduleConnections] of connections) {
-			if (
-				!target ||
-				!moduleConnections.some(
-					(c) => c.dependency instanceof HarmonyImportDependency
-				)
-			) {
-				continue;
-			}
-			// Anything but a bare side-effect import may observe the binding.
-			if (
-				moduleConnections.some(
-					(c) =>
-						c.dependency instanceof HarmonyImportDependency &&
-						!(c.dependency instanceof HarmonyImportSideEffectDependency)
-				)
-			) {
-				bindingReads.push([module, target]);
-			}
-			targets.push(target);
-		}
-		return targets;
-	};
-	/** @type {{ node: Module, targets: Module[], i: number }[]} */
-	const work = [];
-	/**
-	 * @param {Module} node node to open
-	 */
-	const open = (node) => {
-		index.set(node, counter);
-		low.set(node, counter);
-		counter++;
-		componentStack.push(node);
-		onStack.add(node);
-		work.push({ node, targets: targetsOf(node), i: 0 });
-	};
-	for (const seed of modules) {
-		if (index.has(seed)) continue;
-		open(seed);
-		while (work.length > 0) {
-			const frame = work[work.length - 1];
-			if (frame.i < frame.targets.length) {
-				const next = frame.targets[frame.i++];
-				if (!index.has(next)) {
-					open(next);
-				} else if (onStack.has(next)) {
-					const nodeLow = /** @type {number} */ (low.get(frame.node));
-					const nextIndex = /** @type {number} */ (index.get(next));
-					if (nextIndex < nodeLow) low.set(frame.node, nextIndex);
-				}
-				continue;
-			}
-			work.pop();
-			const node = frame.node;
-			const nodeLow = /** @type {number} */ (low.get(node));
-			if (work.length > 0) {
-				const parent = work[work.length - 1].node;
-				if (nodeLow < /** @type {number} */ (low.get(parent))) {
-					low.set(parent, nodeLow);
-				}
-			}
-			if (nodeLow === index.get(node)) {
-				const id = nextComponent++;
-				let member;
-				do {
-					member = /** @type {Module} */ (componentStack.pop());
-					onStack.delete(member);
-					componentOf.set(member, id);
-				} while (member !== node);
-			}
-		}
-	}
-	// Reader and target evaluate together exactly when they share a component.
-	for (const [origin, target] of bindingReads) {
-		if (
-			origin === target ||
-			componentOf.get(origin) === componentOf.get(target)
-		) {
-			inCycle.add(target);
-		}
-	}
-	return inCycle;
-};
-
 module.exports.InlinedUsedName = InlinedUsedName;
 module.exports.InlinedValue = InlinedValue;
 module.exports.MAX_INLINE_BYTES = MAX_INLINE_BYTES;
 module.exports.enableInlineExports = enableInlineExports;
-module.exports.findModulesInCycles = findModulesInCycles;
 module.exports.isExportInlined = isExportInlined;
 module.exports.isInlineEnabled = isInlineEnabled;
 module.exports.isInlineExportsEnabled = isInlineExportsEnabled;

package/lib/optimize/MangleExportsPlugin.js

@@ -15,6 +15,7 @@ const { assignDeterministicIds } = require("../ids/IdHelpers");
 const { compareSelect, compareStringsNumeric } = require("../util/comparators");
 
 /** @import Compiler from "../Compiler" */
+/** @import { BuildInfo } from "../Module" */
 /** @import ExportsInfo, { ExportInfo } from "../ExportsInfo" */
 /** @import { UsedNames } from "../util/concatenate" */
 
@@ -184,6 +185,15 @@ class MangleExportsPlugin {
 					);
 				}
 				for (const module of modules) {
+					// A spec namespace reports the names the module exports, so a
+					// module handing one out cannot have them renamed.
+					if (
+						/** @type {BuildInfo} */
+						(module.buildInfo).specNamespaceObject
+					) {
+						continue;
+					}
+
 					const isNamespace =
 						module.buildMeta && module.buildMeta.exportsType === "namespace";
 					const exportsInfo = moduleGraph.getExportsInfo(module);

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -5,7 +5,6 @@
 
 "use strict";
 
-const asyncLib = require("neo-async");
 const ChunkGraph = require("../ChunkGraph");
 const Dependency = require("../Dependency");
 const Module = require("../Module");
@@ -14,6 +13,7 @@ const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
 const { STAGE_DEFAULT } = require("../OptimizationStages");
 const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
 const { ImportPhaseUtils } = require("../dependencies/ImportPhase");
+const asyncLib = require("../util/async");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const { isCommonJsConcatenationEnabled } = require("../util/concatenate");
 const {
@@ -28,6 +28,7 @@ const ConcatenatedModule = require("./ConcatenatedModule");
 /** @import Chunk from "../Chunk" */
 /** @import Compilation from "../Compilation" */
 /** @import Compiler from "../Compiler" */
+/** @import { JavascriptModuleBuildInfo } from "../javascript/JavascriptModule" */
 /** @import { BuildInfo, BuildMeta } from "../Module" */
 /** @import RequestShortener from "../RequestShortener" */
 /** @import { RuntimeSpec } from "../util/runtime" */
@@ -235,6 +236,19 @@ class ModuleConcatenationPlugin {
 							continue;
 						}
 
+						// Concatenation materializes the namespace inline, which would
+						// silently drop the spec exotic object the module asked for.
+						if (
+							/** @type {BuildInfo} */
+							(module.buildInfo).specNamespaceObject
+						) {
+							setBailoutReason(
+								module,
+								"Module hands out a spec namespace object"
+							);
+							continue;
+						}
+
 						// Module must be in any chunk (we don't want to do useless work)
 						if (chunkGraph.getNumberOfModuleChunks(module) === 0) {
 							setBailoutReason(module, "Module is not in any chunk");
@@ -302,6 +316,15 @@ class ModuleConcatenationPlugin {
 							canBeInner = false;
 						}
 
+						// The root stands in for the whole concatenation, so an
+						// expression only an inner module can answer statically rules it out
+						if (
+							/** @type {JavascriptModuleBuildInfo} */
+							(module.buildInfo).moduleConcatenationRootBailout
+						) {
+							canBeRoot = false;
+						}
+
 						if (deferEnabled && moduleGraph.isDeferred(module)) {
 							setInnerBailoutReason(module, "Module is deferred");
 							canBeInner = false;

package/lib/optimize/RealContentHashPlugin.js

@@ -187,6 +187,7 @@ const createCompilationHooks = () => ({
  * @typedef {object} RealContentHashPluginOptions
  * @property {HashFunction} hashFunction the hash function to use
  * @property {HashDigest} hashDigest the hash digest to use
+ * @property {boolean=} onDemand run only where analyzable output marked a name for repair
  */
 
 const PLUGIN_NAME = "RealContentHashPlugin";
@@ -196,11 +197,13 @@ class RealContentHashPlugin {
 	 * Creates an instance of RealContentHashPlugin.
 	 * @param {RealContentHashPluginOptions} options options
 	 */
-	constructor({ hashFunction, hashDigest }) {
+	constructor({ hashFunction, hashDigest, onDemand }) {
 		/** @type {HashFunction} */
 		this._hashFunction = hashFunction;
 		/** @type {HashDigest} */
 		this._hashDigest = hashDigest;
+		/** @type {boolean} */
+		this._onDemand = Boolean(onDemand);
 	}
 
 	/**
@@ -223,6 +226,14 @@ class RealContentHashPlugin {
 					stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH
 				},
 				async () => {
+					// Set by the deferred fill where a baked name would leave a hashed name
+					// stale; only then is `[chunkhash]` repaired rather than left as named.
+					const repairing = compilation.runtimeTemplate.needsAnalyzableRepair();
+					if (this._onDemand && !repairing) return;
+					// On demand, only a name the fill left stale moves, and whatever names it.
+					const repairedAssets = this._onDemand
+						? compilation.runtimeTemplate.analyzableRepairedAssets()
+						: undefined;
 					const assets = compilation.getAssets();
 					/** @type {AssetInfoForRealContentHash[]} */
 					const assetsWithInfo = [];
@@ -238,6 +249,7 @@ class RealContentHashPlugin {
 						/** @type {Hashes} */
 						const hashes = new Set();
 						addToList(info.contenthash, hashes);
+						if (repairing) addToList(info.chunkhash, hashes);
 						if (info.contenthashDigest) {
 							for (const hash of Object.keys(info.contenthashDigest)) {
 								hashToDigest.set(hash, info.contenthashDigest[hash]);
@@ -495,7 +507,44 @@ ${referencingAssets
 					};
 					/** @type {Comparator<AssetInfoForRealContentHash>} */
 					const comparator = compareSelect((a) => a.name, compareStrings);
+					/**
+					 * Whether a group's names went stale: the fill rewrote an asset of theirs, or
+					 * one names a hash that already moved (groups arrive dependencies first).
+					 * @param {string[]} group the hashes assigned together
+					 * @returns {boolean} true when they have to be recomputed
+					 */
+					const staleOnDemand = (group) => {
+						const own = new Set(group);
+						for (const hash of group) {
+							for (const asset of /** @type {AssetInfoForRealContentHash[]} */ (
+								hashToAssets.get(hash)
+							)) {
+								if (
+									/** @type {ReadonlySet<string>} */ (repairedAssets).has(
+										asset.name
+									)
+								) {
+									return true;
+								}
+								for (const referenced of /** @type {Hashes} */ (
+									asset.referencedHashes
+								)) {
+									if (
+										!own.has(referenced) &&
+										hashToNewHash.get(referenced) !== referenced
+									) {
+										return true;
+									}
+								}
+							}
+						}
+						return false;
+					};
 					for (const group of groupsInOrder) {
+						if (repairedAssets !== undefined && !staleOnDemand(group)) {
+							for (const hash of group) hashToNewHash.set(hash, hash);
+							continue;
+						}
 						// A cycle is assigned as one group: members are told apart by stable
 						// markers, so the group hashes to a fixed point instead of chasing one.
 						if (group.length > 1) {
@@ -608,15 +657,25 @@ ${referencingAssets
 								(hash) => /** @type {string} */ (hashToNewHash.get(hash))
 							);
 
+							/**
+							 * @param {string | string[]} hash what the asset was named with
+							 * @returns {string | string[]} the same, repaired
+							 */
+							const repaired = (hash) =>
+								Array.isArray(hash)
+									? hash.map(
+											(hash) => /** @type {string} */ (hashToNewHash.get(hash))
+										)
+									: /** @type {string} */ (hashToNewHash.get(hash));
+							/** @type {AssetInfo} */
 							const infoUpdate = {};
-							const hash =
-								/** @type {Exclude<AssetInfo["contenthash"], undefined>} */
-								(asset.info.contenthash);
-							infoUpdate.contenthash = Array.isArray(hash)
-								? hash.map(
-										(hash) => /** @type {string} */ (hashToNewHash.get(hash))
-									)
-								: /** @type {string} */ (hashToNewHash.get(hash));
+							if (asset.info.contenthash) {
+								infoUpdate.contenthash = repaired(asset.info.contenthash);
+							}
+							// Tracked only while repairing, so only then does it move with the name.
+							if (repairing && asset.info.chunkhash) {
+								infoUpdate.chunkhash = repaired(asset.info.chunkhash);
+							}
 
 							if (asset.newSource !== undefined) {
 								compilation.updateAsset(

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}`;
 							}
 						});
 					};

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/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) {

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));
 					}