webpack 5.107.2 → 5.108.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");
@@ -39,6 +45,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")
@@ -71,10 +81,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;
@@ -90,6 +104,8 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		this.usedByExports = undefined;
 		/** @type {DestructuringAssignmentProperties | undefined} */
 		this.referencedPropertiesInDestructuring = undefined;
+		/** @type {DependencyGuard[] | undefined} */
+		this.branchGuards = undefined;
 	}
 
 	// TODO webpack 6 remove
@@ -123,6 +139,14 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		return "harmony import specifier";
 	}
 
+	/**
+	 * 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
@@ -151,11 +175,41 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	 * @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;
+		};
 	}
 
 	/**
@@ -175,7 +229,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 =
@@ -219,7 +282,7 @@ 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) {
@@ -229,14 +292,27 @@ 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;
 	}
 
 	/**
@@ -249,7 +325,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 			return this.exportPresenceMode;
 		}
 		const buildMeta =
-			/** @type {BuildMeta} */
+			/** @type {JavascriptModuleBuildMeta} */
 			(
 				/** @type {Module} */
 				(moduleGraph.getParentModule(this)).buildMeta
@@ -325,6 +401,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		write(this.asiSafe);
 		write(this.usedByExports);
 		write(this.referencedPropertiesInDestructuring);
+		write(this.branchGuards);
 		super.serialize(context);
 	}
 
@@ -346,6 +423,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		this.asiSafe = read();
 		this.usedByExports = read();
 		this.referencedPropertiesInDestructuring = read();
+		this.branchGuards = read();
 		super.deserialize(context);
 	}
 }
@@ -369,9 +447,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`,
@@ -384,7 +466,6 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 			return;
 		}
 
-		const ids = dep.getIds(moduleGraph);
 		const {
 			trimmedRange: [trimmedRangeStart, trimmedRangeEnd],
 			trimmedIds
@@ -447,7 +528,16 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 				const used = moduleGraph
 					.getExportsInfo(module)
 					.getUsedName(concatedIds, runtime);
-				if (!used) return;
+				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;
@@ -477,6 +567,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 		const connection = moduleGraph.getConnection(dep);
 		/** @type {string} */
 		let exportExpr;
+
 		if (
 			connection &&
 			concatenationScope &&
@@ -487,7 +578,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) {
@@ -529,7 +626,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/dependencies/HarmonyLinkingError.js

@@ -12,6 +12,7 @@ class HarmonyLinkingError extends WebpackError {
 		super(message);
 		/** @type {string} */
 		this.name = "HarmonyLinkingError";
+		/** @type {boolean} */
 		this.hideStack = true;
 	}
 }

package/lib/dependencies/HarmonyModulesPlugin.js

@@ -44,6 +44,7 @@ class HarmonyModulesPlugin {
 	 * @param {HarmonyModulesPluginOptions} options options
 	 */
 	constructor(options) {
+		/** @type {HarmonyModulesPluginOptions} */
 		this.options = options;
 	}