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

package/lib/FlagDependencyUsagePlugin.js

@@ -11,15 +11,15 @@ const ModuleGraphConnection = require("./ModuleGraphConnection");
 const { STAGE_DEFAULT } = require("./OptimizationStages");
 const ArrayQueue = require("./util/ArrayQueue");
 const TupleQueue = require("./util/TupleQueue");
+const TupleSet = require("./util/TupleSet");
 const { getEntryRuntime, mergeRuntimeOwned } = require("./util/runtime");
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("./Dependency").ReferencedExports} ReferencedExports */
-/** @typedef {import("./ExportsInfo")} ExportsInfo */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import Compiler from "./Compiler" */
+/** @import DependenciesBlock from "./DependenciesBlock" */
+/** @import { ReferencedExport, ReferencedExports } from "./Dependency" */
+/** @import ExportsInfo from "./ExportsInfo" */
+/** @import Module from "./Module" */
+/** @import { RuntimeSpec } from "./util/runtime" */
 
 const {
 	NO_EXPORTS_REFERENCED,
@@ -80,20 +80,17 @@ class FlagDependencyUsagePlugin {
 					/** @type {TupleQueue<Module, RuntimeSpec>} */
 					const queue = new TupleQueue();
 
+					/** @type {TupleSet<Module, RuntimeSpec> | undefined} */
+					let walkedSideEffectFreeModules;
+
 					/**
 					 * Process referenced module.
 					 * @param {Module} module module to process
 					 * @param {ReferencedExports} usedExports list of used exports
 					 * @param {RuntimeSpec} runtime part of which runtime
-					 * @param {boolean} forceSideEffects always apply side effects
 					 * @returns {void}
 					 */
-					const processReferencedModule = (
-						module,
-						usedExports,
-						runtime,
-						forceSideEffects
-					) => {
+					const processReferencedModule = (module, usedExports, runtime) => {
 						const exportsInfo = moduleGraph.getExportsInfo(module);
 						if (usedExports === EXPORTS_OBJECT_REFERENCED_MANGLEABLE) {
 							// The whole namespace object escapes via a reference that codegen
@@ -211,20 +208,22 @@ class FlagDependencyUsagePlugin {
 									}
 								}
 							}
-						} else {
-							// for a module without side effects we stop tracking usage here when no export is used
-							// This module won't be evaluated in this case
-							// TODO webpack 6 remove this check
-							if (
-								!forceSideEffects &&
-								module.factoryMeta !== undefined &&
-								module.factoryMeta.sideEffectFree
-							) {
-								return;
+						} else if (
+							module.factoryMeta !== undefined &&
+							module.factoryMeta.sideEffectFree
+						) {
+							// Nothing is used and the module has no side effects, so it is
+							// not used for them either. An active connection still evaluates
+							// it, so keep walking it to count the references it makes itself.
+							if (walkedSideEffectFreeModules === undefined) {
+								walkedSideEffectFreeModules = new TupleSet();
 							}
-							if (exportsInfo.setUsedForSideEffectsOnly(runtime)) {
+							if (!walkedSideEffectFreeModules.has(module, runtime)) {
+								walkedSideEffectFreeModules.add(module, runtime);
 								queue.enqueue(module, runtime);
 							}
+						} else if (exportsInfo.setUsedForSideEffectsOnly(runtime)) {
+							queue.enqueue(module, runtime);
 						}
 					};
 
@@ -232,10 +231,9 @@ class FlagDependencyUsagePlugin {
 					 * Processes the provided module.
 					 * @param {DependenciesBlock} module the module
 					 * @param {RuntimeSpec} runtime part of which runtime
-					 * @param {boolean} forceSideEffects always apply side effects
 					 * @returns {void}
 					 */
-					const processModule = (module, runtime, forceSideEffects) => {
+					const processModule = (module, runtime) => {
 						/** @typedef {Map<string, string[] | ReferencedExport>} ExportMaps */
 						/** @type {Map<Module, ReferencedExports | ExportMaps>} */
 						const map = new Map();
@@ -258,8 +256,7 @@ class FlagDependencyUsagePlugin {
 										b,
 										this.global
 											? undefined
-											: b.groupOptions.entryOptions.runtime || undefined,
-										true
+											: b.groupOptions.entryOptions.runtime || undefined
 									);
 								} else {
 									queue.enqueue(b);
@@ -274,7 +271,7 @@ class FlagDependencyUsagePlugin {
 								if (activeState === false) continue;
 								const { module } = connection;
 								if (activeState === ModuleGraphConnection.TRANSITIVE_ONLY) {
-									processModule(module, runtime, false);
+									processModule(module, runtime);
 									continue;
 								}
 								const oldReferencedExports = map.get(module);
@@ -348,10 +345,16 @@ class FlagDependencyUsagePlugin {
 											if (oldItem === undefined || Array.isArray(oldItem)) {
 												exportsMap.set(key, item);
 											} else {
+												// An unset flag means "allowed", so merge on `!== false`:
+												// `undefined && false` reads back as allowed.
 												exportsMap.set(key, {
 													name: item.name,
-													canMangle: item.canMangle && oldItem.canMangle,
-													canInline: item.canInline && oldItem.canInline
+													canMangle:
+														item.canMangle !== false &&
+														oldItem.canMangle !== false,
+													canInline:
+														item.canInline !== false &&
+														oldItem.canInline !== false
 												});
 											}
 										}
@@ -362,18 +365,12 @@ class FlagDependencyUsagePlugin {
 
 						for (const [module, referencedExports] of map) {
 							if (Array.isArray(referencedExports)) {
-								processReferencedModule(
-									module,
-									referencedExports,
-									runtime,
-									forceSideEffects
-								);
+								processReferencedModule(module, referencedExports, runtime);
 							} else {
 								processReferencedModule(
 									module,
 									[...referencedExports.values()],
-									runtime,
-									forceSideEffects
+									runtime
 								);
 							}
 						}
@@ -382,8 +379,7 @@ class FlagDependencyUsagePlugin {
 								processReferencedModule(
 									module,
 									EXPORTS_OBJECT_REFERENCED_MANGLEABLE,
-									runtime,
-									forceSideEffects
+									runtime
 								);
 							}
 						}
@@ -407,12 +403,7 @@ class FlagDependencyUsagePlugin {
 					const processEntryDependency = (dep, runtime) => {
 						const module = moduleGraph.getModule(dep);
 						if (module) {
-							processReferencedModule(
-								module,
-								NO_EXPORTS_REFERENCED,
-								runtime,
-								true
-							);
+							processReferencedModule(module, NO_EXPORTS_REFERENCED, runtime);
 						}
 					};
 					/** @type {RuntimeSpec} */
@@ -443,7 +434,7 @@ class FlagDependencyUsagePlugin {
 						const [module, runtime] = /** @type {[Module, RuntimeSpec]} */ (
 							queue.dequeue()
 						);
-						processModule(module, runtime, false);
+						processModule(module, runtime);
 					}
 					logger.timeEnd("trace exports usage in graph");
 				}

package/lib/FlagEntryExportAsUsedPlugin.js

@@ -7,7 +7,7 @@
 
 const { getEntryRuntime } = require("./util/runtime");
 
-/** @typedef {import("./Compiler")} Compiler */
+/** @import Compiler from "./Compiler" */
 
 const PLUGIN_NAME = "FlagEntryExportAsUsedPlugin";
 

package/lib/Generator.js

@@ -6,22 +6,27 @@
 "use strict";
 
 const { JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants");
+const memoize = require("./util/memoize");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("./ConcatenationScope")} ConcatenationScope */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Module").CodeGenerationResultData} CodeGenerationResultData */
-/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
-/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
-/** @typedef {import("./Module").SourceType} SourceType */
-/** @typedef {import("./Module").SourceTypes} SourceTypes */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./NormalModule")} NormalModule */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import { Source } from "webpack-sources" */
+/** @import ChunkGraph from "./ChunkGraph" */
+/** @import CodeGenerationResults from "./CodeGenerationResults" */
+/** @import ConcatenationScope from "./ConcatenationScope" */
+/** @import DependencyTemplates from "./DependencyTemplates" */
+/**
+ * @import {
+ * 	CodeGenerationResultData,
+ * 	ConcatenationBailoutReasonContext,
+ * 	RuntimeRequirements,
+ * 	SourceType,
+ * 	SourceTypes
+ * } from "./Module"
+ */
+/** @import ModuleGraph from "./ModuleGraph" */
+/** @import NormalModule from "./NormalModule" */
+/** @import RuntimeTemplate from "./RuntimeTemplate" */
+/** @import Hash from "./util/Hash" */
+/** @import { RuntimeSpec } from "./util/runtime" */
 
 /**
  * Defines the generate context type used by this module.
@@ -56,6 +61,8 @@ const { JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants");
  * @property {RuntimeTemplate=} runtimeTemplate
  */
 
+const getModuleParseError = memoize(() => require("./errors/ModuleParseError"));
+
 class Generator {
 	/**
 	 * Returns generator by type.
@@ -66,6 +73,20 @@ class Generator {
 		return new ByTypeGenerator(map);
 	}
 
+	/**
+	 * Returns the statement a module that failed to build throws when executed.
+	 * @param {Error} error the build error
+	 * @param {string=} parseErrorConstructor constructor for a rejected source, defaults to `SyntaxError` (WebAssembly rejects with `WebAssembly.CompileError` instead)
+	 * @returns {string} javascript statement
+	 */
+	static throwBuildErrorCode(error, parseErrorConstructor = "SyntaxError") {
+		// A source the parser rejected throws what a native load of it would.
+		const name =
+			error instanceof getModuleParseError() ? parseErrorConstructor : "Error";
+
+		return `throw new ${name}(${JSON.stringify(error.message)});`;
+	}
+
 	/* istanbul ignore next */
 	/**
 	 * Returns the source types available for this module.

package/lib/HotModuleReplacementPlugin.js

@@ -5,7 +5,6 @@
 
 "use strict";
 
-const { SyncBailHook } = require("tapable");
 const { RawSource } = require("webpack-sources");
 const ChunkGraph = require("./ChunkGraph");
 const Compilation = require("./Compilation");
@@ -27,7 +26,7 @@ const ModuleHotAcceptDependency = require("./dependencies/ModuleHotAcceptDepende
 const ModuleHotDeclineDependency = require("./dependencies/ModuleHotDeclineDependency");
 const WebpackError = require("./errors/WebpackError");
 const HotModuleReplacementRuntimeModule = require("./hmr/HotModuleReplacementRuntimeModule");
-const JavascriptParser = require("./javascript/JavascriptParser");
+const getParserHooks = require("./hmr/parserHooks");
 const {
 	evaluateToIdentifier
 } = require("./javascript/JavascriptParserHelpers");
@@ -44,34 +43,22 @@ const {
 	subtractRuntime
 } = require("./util/runtime");
 
-/** @typedef {import("estree").CallExpression} CallExpression */
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("estree").SpreadElement} SpreadElement */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Chunk").ChunkId} ChunkId */
-/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
-/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./Compilation").Records} Records */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./Module").BuildInfo} BuildInfo */
-/** @typedef {import("./css/CssModule").CssModuleBuildMeta} CssModuleBuildMeta */
-/** @typedef {import("./RuntimeModule")} RuntimeModule */
-/** @typedef {import("./javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
-/** @typedef {import("./javascript/JavascriptParserHelpers").Range} Range */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import { CallExpression, Expression } from "estree" */
+/** @import Chunk, { ChunkId } from "./Chunk" */
+/** @import { ModuleId } from "./ChunkGraph" */
+/** @import { AssetInfo } from "./Compilation" */
+/** @import Compiler, { Records } from "./Compiler" */
+/** @import CodeGenerationResults from "./CodeGenerationResults" */
+/** @import Module, { BuildInfo } from "./Module" */
+/** @import { CssModuleBuildMeta } from "./css/CssModule" */
+/** @import { HMRJavascriptParserHooks } from "./hmr/parserHooks" */
+/** @import RuntimeModule from "./RuntimeModule" */
+/** @import BasicEvaluatedExpression from "./javascript/BasicEvaluatedExpression" */
+/** @import JavascriptParser, { Range } from "./javascript/JavascriptParser" */
+/** @import { RuntimeSpec } from "./util/runtime" */
 
 /** @typedef {string[]} Requests */
 
-/**
- * Defines the hmr javascript parser hooks type used by this module.
- * @typedef {object} HMRJavascriptParserHooks
- * @property {SyncBailHook<[Expression | SpreadElement, Requests], void>} hotAcceptCallback
- * @property {SyncBailHook<[CallExpression, Requests], void>} hotAcceptWithoutCallback
- */
-
 /** @typedef {number} HotIndex */
 /** @typedef {Record<string, string>} FullHashChunkModuleHashes */
 /** @typedef {Record<string, string>} ChunkModuleHashes */
@@ -85,9 +72,6 @@ const {
 /** @typedef {{ updatedChunkIds: ChunkIds, removedChunkIds: ChunkIds, removedModules: ModuleSet, forceLoadChunkIds: ChunkIds, filename: string, assetInfo: AssetInfo }} HotUpdateMainContentByRuntimeItem */
 /** @typedef {Map<string, HotUpdateMainContentByRuntimeItem>} HotUpdateMainContentByRuntime */
 
-/** @type {WeakMap<JavascriptParser, HMRJavascriptParserHooks>} */
-const parserHooksMap = new WeakMap();
-
 const PLUGIN_NAME = "HotModuleReplacementPlugin";
 
 class HotModuleReplacementPlugin {
@@ -97,20 +81,7 @@ class HotModuleReplacementPlugin {
 	 * @returns {HMRJavascriptParserHooks} the attached hooks
 	 */
 	static getParserHooks(parser) {
-		if (!(parser instanceof JavascriptParser)) {
-			throw new TypeError(
-				"The 'parser' argument must be an instance of JavascriptParser"
-			);
-		}
-		let hooks = parserHooksMap.get(parser);
-		if (hooks === undefined) {
-			hooks = {
-				hotAcceptCallback: new SyncBailHook(["expression", "requests"]),
-				hotAcceptWithoutCallback: new SyncBailHook(["expression", "requests"])
-			};
-			parserHooksMap.set(parser, hooks);
-		}
-		return hooks;
+		return getParserHooks(parser);
 	}
 
 	/**
@@ -132,6 +103,7 @@ class HotModuleReplacementPlugin {
 		 * @returns {(expr: CallExpression) => boolean | undefined} callback
 		 */
 		const createAcceptHandler = (parser, ParamDependency) => {
+			// through the static method: replacing it stays a way to intercept
 			const { hotAcceptCallback, hotAcceptWithoutCallback } =
 				HotModuleReplacementPlugin.getParserHooks(parser);
 

package/lib/IgnorePlugin.js

@@ -8,10 +8,14 @@
 const RawModule = require("./RawModule");
 const EntryDependency = require("./dependencies/EntryDependency");
 
-/** @typedef {import("../declarations/plugins/IgnorePlugin").IgnorePluginOptions} IgnorePluginOptions */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./NormalModuleFactory").ResolveData} ResolveData */
-/** @typedef {import("./ContextModuleFactory").BeforeContextResolveData} BeforeContextResolveData */
+/**
+ * @import {
+ * 	IgnorePluginOptions
+ * } from "../declarations/plugins/IgnorePlugin"
+ */
+/** @import Compiler from "./Compiler" */
+/** @import { ResolveData } from "./NormalModuleFactory" */
+/** @import { BeforeContextResolveData } from "./ContextModuleFactory" */
 
 /** @typedef {(resource: string, context: string) => boolean} CheckResourceFn */
 

package/lib/IgnoreWarningsPlugin.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Compilation")} Compilation */
+/** @import Compiler from "./Compiler" */
+/** @import Compilation from "./Compilation" */
 
 /** @typedef {(warning: Error, compilation: Compilation) => boolean} IgnoreFn */
 

package/lib/InitFragment.js

@@ -8,10 +8,14 @@
 const { ConcatSource } = require("webpack-sources");
 const makeSerializable = require("./util/makeSerializable");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./Generator").GenerateContext} GenerateContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @import { Source } from "webpack-sources" */
+/** @import { GenerateContext } from "./Generator" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "./serialization/ObjectMiddleware"
+ */
 
 /** @typedef {string} InitFragmentKey */
 

package/lib/JavascriptMetaInfoPlugin.js

@@ -12,10 +12,14 @@ const {
 } = require("./ModuleTypeConstants");
 const { getInnerGraphUtils } = require("./optimize/InnerGraph");
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Module").BuildInfo} BuildInfo */
-/** @typedef {import("./javascript/JavascriptModule").JavascriptModuleBuildInfo} JavascriptModuleBuildInfo */
-/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+/** @import Compiler from "./Compiler" */
+/** @import { BuildInfo } from "./Module" */
+/**
+ * @import {
+ * 	JavascriptModuleBuildInfo
+ * } from "./javascript/JavascriptModule"
+ */
+/** @import JavascriptParser from "./javascript/JavascriptParser" */
 
 const PLUGIN_NAME = "JavascriptMetaInfoPlugin";
 
@@ -36,6 +40,26 @@ class JavascriptMetaInfoPlugin {
 				 * @returns {void}
 				 */
 				const handler = (parser) => {
+					parser.hooks.program.tap(PLUGIN_NAME, (ast) => {
+						// Nested blocks keep their own disposal scope, only a module-scope
+						// declaration ties disposal to the end of module evaluation.
+						if (
+							ast.body.some(
+								(statement) =>
+									statement.type === "VariableDeclaration" &&
+									(statement.kind === "using" ||
+										statement.kind === "await using")
+							)
+						) {
+							const buildInfo =
+								/** @type {JavascriptModuleBuildInfo} */
+								(parser.state.module.buildInfo);
+							buildInfo.usesTopLevelUsingDeclaration = true;
+							// Concatenation would defer disposal to the enclosing scope.
+							buildInfo.moduleConcatenationBailout =
+								"a top-level using declaration";
+						}
+					});
 					parser.hooks.call.for("eval").tap(PLUGIN_NAME, () => {
 						const buildInfo =
 							/** @type {JavascriptModuleBuildInfo} */
@@ -45,7 +69,14 @@ class JavascriptMetaInfoPlugin {
 						if (currentSymbol) {
 							innerGraph.addUsage(parser.state, null, currentSymbol);
 						} else {
+							// Only worth reporting when the analysis was actually running
+							const wasEnabled = innerGraph.isEnabled(parser.state);
 							innerGraph.bailout(parser.state);
+							if (wasEnabled) {
+								compilation.moduleGraph
+									.getOptimizationBailout(parser.state.module)
+									.push("Inner graph bailout: eval()");
+							}
 						}
 					});
 					parser.hooks.finish.tap(PLUGIN_NAME, () => {

package/lib/LazyBarrel.js

@@ -7,10 +7,9 @@
 
 const Dependency = require("./Dependency");
 
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Compilation").DependencyConstructor} DependencyConstructor */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleFactory")} ModuleFactory */
+/** @import Compilation, { DependencyConstructor } from "./Compilation" */
+/** @import Module from "./Module" */
+/** @import ModuleFactory from "./ModuleFactory" */
 
 /**
  * Defines the deferred request group type used by this module.

package/lib/LibraryTemplatePlugin.js

@@ -7,12 +7,16 @@
 
 const EnableLibraryPlugin = require("./library/EnableLibraryPlugin");
 
-/** @typedef {import("../declarations/WebpackOptions").AuxiliaryComment} AuxiliaryComment */
-/** @typedef {import("../declarations/WebpackOptions").LibraryExport} LibraryExport */
-/** @typedef {import("../declarations/WebpackOptions").LibraryName} LibraryName */
-/** @typedef {import("../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../declarations/WebpackOptions").UmdNamedDefine} UmdNamedDefine */
-/** @typedef {import("./Compiler")} Compiler */
+/**
+ * @import {
+ * 	AuxiliaryComment,
+ * 	LibraryExport,
+ * 	LibraryName,
+ * 	LibraryType,
+ * 	UmdNamedDefine
+ * } from "../declarations/WebpackOptions"
+ */
+/** @import Compiler from "./Compiler" */
 
 // TODO webpack 6 remove
 class LibraryTemplatePlugin {

package/lib/LoaderOptionsPlugin.js

@@ -8,9 +8,13 @@
 const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
 const NormalModule = require("./NormalModule");
 
-/** @typedef {import("../declarations/plugins/LoaderOptionsPlugin").LoaderOptionsPluginOptions} LoaderOptionsPluginOptions */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./ModuleFilenameHelpers").MatchObject} MatchObject  */
+/**
+ * @import {
+ * 	LoaderOptionsPluginOptions
+ * } from "../declarations/plugins/LoaderOptionsPlugin"
+ */
+/** @import Compiler from "./Compiler" */
+/** @import { MatchObject } from "./ModuleFilenameHelpers" */
 
 /**
  * Defines the loader context type used by this module.

package/lib/LoaderTargetPlugin.js

@@ -7,7 +7,7 @@
 
 const NormalModule = require("./NormalModule");
 
-/** @typedef {import("./Compiler")} Compiler */
+/** @import Compiler from "./Compiler" */
 
 const PLUGIN_NAME = "LoaderTargetPlugin";