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

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -8,11 +8,17 @@
 const Dependency = require("../Dependency");
 const InitFragment = require("../InitFragment");
 const Template = require("../Template");
+const {
+	InlinedUsedName,
+	isExportInlined,
+	isInlineExportsEnabled
+} = require("../optimize/InlineExports");
 const {
 	getDependencyUsedByExportsCondition
 } = require("../optimize/InnerGraph");
 const { getTrimmedIdsAndRange } = require("../util/chainedImports");
 const makeSerializable = require("../util/makeSerializable");
+const memoize = require("../util/memoize");
 const { propertyAccess } = require("../util/property");
 const traverseDestructuringAssignmentProperties = require("../util/traverseDestructuringAssignmentProperties");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
@@ -26,8 +32,9 @@ const { ImportPhaseUtils } = require("./ImportPhase");
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../errors/WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperties} DestructuringAssignmentProperties */
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
@@ -39,6 +46,10 @@ const { ImportPhaseUtils } = require("./ImportPhase");
 /** @typedef {import("./HarmonyImportDependency").ExportPresenceMode} ExportPresenceMode */
 /** @typedef {HarmonyImportDependency.Ids} Ids */
 /** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
+/** @typedef {import("./HarmonyImportGuard").DependencyGuard} DependencyGuard */
+/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildMeta} JavascriptModuleBuildMeta */
+
+const getHarmonyImportGuard = memoize(() => require("./HarmonyImportGuard"));
 
 const idsSymbol = /** @type {symbol} */ (
 	Symbol("HarmonyImportSpecifierDependency.ids")
@@ -48,6 +59,7 @@ const { ExportPresenceModes } = HarmonyImportDependency;
 
 class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	/**
+	 * Creates an instance of HarmonyImportSpecifierDependency.
 	 * @param {string} request request
 	 * @param {number} sourceOrder source order
 	 * @param {Ids} ids ids
@@ -70,10 +82,14 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		idRanges // TODO webpack 6 make this non-optional. It must always be set to properly trim ids.
 	) {
 		super(request, sourceOrder, phase, attributes);
+		/** @type {Ids} */
 		this.ids = ids;
+		/** @type {string} */
 		this.name = name;
 		this.range = range;
+		/** @type {IdRanges | undefined} */
 		this.idRanges = idRanges;
+		/** @type {ExportPresenceMode} */
 		this.exportPresenceMode = exportPresenceMode;
 		/** @type {undefined | boolean} */
 		this.namespaceObjectAsContext = false;
@@ -89,10 +105,13 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		this.usedByExports = undefined;
 		/** @type {DestructuringAssignmentProperties | undefined} */
 		this.referencedPropertiesInDestructuring = undefined;
+		/** @type {DependencyGuard[] | undefined} */
+		this.branchGuards = undefined;
 	}
 
 	// TODO webpack 6 remove
 	/**
+	 * Returns id.
 	 * @deprecated
 	 */
 	get id() {
@@ -101,6 +120,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 
 	// TODO webpack 6 remove
 	/**
+	 * Returns id.
 	 * @deprecated
 	 */
 	getId() {
@@ -109,6 +129,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 
 	// TODO webpack 6 remove
 	/**
+	 * Updates id.
 	 * @deprecated
 	 */
 	setId() {
@@ -120,6 +141,15 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	}
 
 	/**
+	 * Returns the export name this dependency requests from its target module (lazy barrel optimization).
+	 * @returns {string | true | null} export name, true for all exports, null for none
+	 */
+	getForwardId() {
+		return this.ids.length > 0 ? this.ids[0] : true;
+	}
+
+	/**
+	 * Returns the imported ids.
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @returns {Ids} the imported ids
 	 */
@@ -131,6 +161,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	}
 
 	/**
+	 * Updates ids using the provided module graph.
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {Ids} ids the imported ids
 	 * @returns {void}
@@ -140,18 +171,50 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	}
 
 	/**
+	 * Returns function to determine if the connection is active.
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
 	 */
 	getCondition(moduleGraph) {
-		return getDependencyUsedByExportsCondition(
+		const usedByExportsCondition = getDependencyUsedByExportsCondition(
 			this,
-			this.usedByExports,
 			moduleGraph
 		);
+		if (usedByExportsCondition === false) return false;
+		// Keep the connection unconditional (fast path) when nothing can deactivate it
+		if (
+			usedByExportsCondition === null &&
+			this.branchGuards === undefined &&
+			!isInlineExportsEnabled(moduleGraph)
+		) {
+			return null;
+		}
+		const dep = this;
+		return (connection, runtime) => {
+			if (usedByExportsCondition !== null) {
+				const result = usedByExportsCondition(connection, runtime);
+				if (result === false) return false;
+			}
+			const ids = dep.getIds(moduleGraph);
+			if (
+				ids.length > 0 &&
+				isExportInlined(moduleGraph, connection.module, ids, runtime)
+			) {
+				return false;
+			}
+			const guards = dep.branchGuards;
+			if (
+				guards !== undefined &&
+				getHarmonyImportGuard().isDeadByGuards(guards, moduleGraph, runtime)
+			) {
+				return false;
+			}
+			return true;
+		};
 	}
 
 	/**
+	 * Gets module evaluation side effects state.
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
 	 */
@@ -167,7 +230,16 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	 */
 	getReferencedExports(moduleGraph, runtime) {
 		let ids = this.getIds(moduleGraph);
-		if (ids.length === 0) return this._getReferencedExportsInDestructuring();
+		if (ids.length === 0) {
+			const refs = this._getReferencedExportsInDestructuring();
+			// The whole namespace object is used as a value (no destructuring): it
+			// can be rendered as a decoupled namespace object, keeping the module's
+			// exports mangleable. Deferred imports keep their special namespace.
+			return refs === Dependency.EXPORTS_OBJECT_REFERENCED &&
+				!ImportPhaseUtils.isDefer(this.phase)
+				? Dependency.EXPORTS_OBJECT_REFERENCED_MANGLEABLE
+				: refs;
+		}
 		let namespaceObjectAsContext = this.namespaceObjectAsContext;
 		if (ids[0] === "default") {
 			const selfModule =
@@ -209,8 +281,9 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	}
 
 	/**
+	 * Get referenced exports in destructuring.
 	 * @param {Ids=} ids ids
-	 * @returns {RawReferencedExports} referenced exports
+	 * @returns {ReferencedExports} referenced exports
 	 */
 	_getReferencedExportsInDestructuring(ids) {
 		if (this.referencedPropertiesInDestructuring) {
@@ -220,17 +293,31 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 				this.referencedPropertiesInDestructuring,
 				(stack) => refsInDestructuring.push(stack.map((p) => p.id))
 			);
-			/** @type {RawReferencedExports} */
+			/** @type {ReferencedExports} */
 			const refs = [];
 			for (const idsInDestructuring of refsInDestructuring) {
-				refs.push(ids ? [...ids, ...idsInDestructuring] : idsInDestructuring);
+				// Destructuring consumer can't accept an inlined literal
+				refs.push({
+					name: ids ? [...ids, ...idsInDestructuring] : idsInDestructuring,
+					canInline: false
+				});
 			}
 			return refs;
 		}
-		return ids ? [ids] : Dependency.EXPORTS_OBJECT_REFERENCED;
+		return ids
+			? [
+					{
+						name: ids,
+						canMangle: true,
+						// Need access the export value to trigger side effects for deferred module
+						canInline: !ImportPhaseUtils.isDefer(this.phase)
+					}
+				]
+			: Dependency.EXPORTS_OBJECT_REFERENCED;
 	}
 
 	/**
+	 * Get effective export presence level.
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @returns {ExportPresenceMode} effective mode
 	 */
@@ -239,7 +326,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 			return this.exportPresenceMode;
 		}
 		const buildMeta =
-			/** @type {BuildMeta} */
+			/** @type {JavascriptModuleBuildMeta} */
 			(
 				/** @type {Module} */
 				(moduleGraph.getParentModule(this)).buildMeta
@@ -250,7 +337,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	}
 
 	/**
-	 * Returns warnings
+	 * Returns warnings.
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @returns {WebpackError[] | null | undefined} warnings
 	 */
@@ -263,7 +350,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	}
 
 	/**
-	 * Returns errors
+	 * Returns errors.
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @returns {WebpackError[] | null | undefined} errors
 	 */
@@ -276,6 +363,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	}
 
 	/**
+	 * Returns errors.
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @returns {WebpackError[] | undefined} errors
 	 */
@@ -297,6 +385,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
@@ -313,10 +402,12 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		write(this.asiSafe);
 		write(this.usedByExports);
 		write(this.referencedPropertiesInDestructuring);
+		write(this.branchGuards);
 		super.serialize(context);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
@@ -333,6 +424,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		this.asiSafe = read();
 		this.usedByExports = read();
 		this.referencedPropertiesInDestructuring = read();
+		this.branchGuards = read();
 		super.deserialize(context);
 	}
 }
@@ -346,6 +438,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 	HarmonyImportDependency.Template
 ) {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified
 	 * @param {DependencyTemplateContext} templateContext the context object
@@ -355,9 +448,13 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 		const dep = /** @type {HarmonyImportSpecifierDependency} */ (dependency);
 		const { moduleGraph, runtime, initFragments } = templateContext;
 		const connection = moduleGraph.getConnection(dep);
+		const ids = dep.getIds(moduleGraph);
 
-		// Only render declaration for import specifier when the dependency is conditional
-		if (connection && !connection.isTargetActive(runtime)) {
+		if (
+			connection &&
+			!connection.isTargetActive(runtime) &&
+			!isExportInlined(moduleGraph, connection.module, ids, runtime)
+		) {
 			initFragments.push(
 				new InitFragment(
 					`/* unused harmony import specifier */ var ${dep.name};\n`,
@@ -370,7 +467,6 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 			return;
 		}
 
-		const ids = dep.getIds(moduleGraph);
 		const {
 			trimmedRange: [trimmedRangeStart, trimmedRangeEnd],
 			trimmedIds
@@ -380,7 +476,8 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 			dep,
 			source,
 			templateContext,
-			trimmedIds
+			trimmedIds,
+			connection
 		);
 		if (dep.shorthand) {
 			source.insert(trimmedRangeEnd, `: ${exportExpr}`);
@@ -426,14 +523,24 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 					});
 				}
 			);
+			// loop-invariant: resolve the imported module's exports info once
+			const destructuredExportsInfo = moduleGraph.getExportsInfo(
+				/** @type {Module} */ (moduleGraph.getModule(dep))
+			);
 			for (const { ids, shorthand, range } of replacementsInDestructuring) {
 				/** @type {Ids} */
 				const concatedIds = [...prefixedIds, ...ids];
-				const module = /** @type {Module} */ (moduleGraph.getModule(dep));
-				const used = moduleGraph
-					.getExportsInfo(module)
-					.getUsedName(concatedIds, runtime);
-				if (!used) return;
+				const used = destructuredExportsInfo.getUsedName(concatedIds, runtime);
+				if (!used) {
+					return;
+				} else if (used instanceof InlinedUsedName) {
+					throw new Error(
+						`Should not inline for destructuring name ${concatedIds.join(".")}`
+					);
+				}
+				// Destructuring can't consume an inlined literal — should be unreachable
+				// because the consumer-side canInline=false suppresses inlining there.
+				if (!Array.isArray(used)) continue;
 				const newName = used[used.length - 1];
 				const name = concatedIds[concatedIds.length - 1];
 				if (newName === name) continue;
@@ -450,18 +557,20 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 	}
 
 	/**
+	 * Returns generated code.
 	 * @param {HarmonyImportSpecifierDependency} dep dependency
 	 * @param {ReplaceSource} source source
 	 * @param {DependencyTemplateContext} templateContext context
 	 * @param {Ids} ids ids
+	 * @param {ModuleGraphConnection | undefined} connection the resolved connection for dep
 	 * @returns {string} generated code
 	 */
-	_getCodeForIds(dep, source, templateContext, ids) {
+	_getCodeForIds(dep, source, templateContext, ids, connection) {
 		const { moduleGraph, module, runtime, concatenationScope } =
 			templateContext;
-		const connection = moduleGraph.getConnection(dep);
 		/** @type {string} */
 		let exportExpr;
+
 		if (
 			connection &&
 			concatenationScope &&
@@ -472,7 +581,13 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 					connection.module,
 					{
 						asiSafe: dep.asiSafe,
-						deferredImport: ImportPhaseUtils.isDefer(dep.phase)
+						deferredImport: ImportPhaseUtils.isDefer(dep.phase),
+						// A bare namespace value that isn't destructured may escape, so
+						// allow a decoupled namespace object that keeps the original names.
+						// Deferred imports keep their special namespace object.
+						mangleableNamespace:
+							!dep.referencedPropertiesInDestructuring &&
+							!ImportPhaseUtils.isDefer(dep.phase)
 					}
 				);
 			} else if (dep.namespaceObjectAsContext && ids.length === 1) {
@@ -514,7 +629,14 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 				initFragments,
 				runtime,
 				runtimeRequirements,
-				dependency: dep
+				dependency: dep,
+				// A bare namespace value that isn't destructured may escape, so allow a
+				// decoupled namespace object that keeps the original export names.
+				// Deferred imports keep their special namespace object.
+				mangleableNamespace:
+					ids.length === 0 &&
+					!dep.referencedPropertiesInDestructuring &&
+					!ImportPhaseUtils.isDefer(dep.phase)
 			});
 		}
 		return exportExpr;

package/lib/{HarmonyLinkingError.js → dependencies/HarmonyLinkingError.js}

@@ -4,14 +4,17 @@
 
 "use strict";
 
-const WebpackError = require("./WebpackError");
+const WebpackError = require("../errors/WebpackError");
 
-module.exports = class HarmonyLinkingError extends WebpackError {
+class HarmonyLinkingError extends WebpackError {
 	/** @param {string} message Error message */
 	constructor(message) {
 		super(message);
 		/** @type {string} */
 		this.name = "HarmonyLinkingError";
+		/** @type {boolean} */
 		this.hideStack = true;
 	}
-};
+}
+
+module.exports = HarmonyLinkingError;

package/lib/dependencies/HarmonyModulesPlugin.js

@@ -25,12 +25,14 @@ const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDepe
 const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
 
 const HarmonyTopLevelThisParserPlugin = require("./HarmonyTopLevelThisParserPlugin");
+const TopLevelAwaitDependency = require("./TopLevelAwaitDependency");
 
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
 
 /**
+ * Defines the harmony modules plugin options type used by this module.
  * @typedef {object} HarmonyModulesPluginOptions
  * @property {boolean=} deferImport
  */
@@ -39,14 +41,16 @@ const PLUGIN_NAME = "HarmonyModulesPlugin";
 
 class HarmonyModulesPlugin {
 	/**
+	 * Creates an instance of HarmonyModulesPlugin.
 	 * @param {HarmonyModulesPluginOptions} options options
 	 */
 	constructor(options) {
+		/** @type {HarmonyModulesPluginOptions} */
 		this.options = options;
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -59,6 +63,11 @@ class HarmonyModulesPlugin {
 					new HarmonyCompatibilityDependency.Template()
 				);
 
+				compilation.dependencyTemplates.set(
+					TopLevelAwaitDependency,
+					new TopLevelAwaitDependency.Template()
+				);
+
 				compilation.dependencyFactories.set(
 					HarmonyImportSideEffectDependency,
 					normalModuleFactory
@@ -125,6 +134,7 @@ class HarmonyModulesPlugin {
 				);
 
 				/**
+				 * Handles the hook callback for this code path.
 				 * @param {Parser} parser parser parser
 				 * @param {JavascriptParserOptions} parserOptions parserOptions
 				 * @returns {void}

package/lib/dependencies/HarmonyTopLevelThisParserPlugin.js

@@ -16,6 +16,7 @@ const PLUGIN_NAME = "HarmonyTopLevelThisParserPlugin";
 
 class HarmonyTopLevelThisParserPlugin {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
@@ -28,7 +29,7 @@ class HarmonyTopLevelThisParserPlugin {
 					/** @type {Range} */ (node.range),
 					null
 				);
-				dep.loc = /** @type {DependencyLocation} */ (node.loc);
+				dep.loc = parser.getLocation(node);
 				parser.state.module.addPresentationalDependency(dep);
 				return true;
 			}