@depup/webpack 5.106.0-depup.0 → 5.109.0-depup.0

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -6,13 +6,12 @@
 "use strict";
 
 const HotModuleReplacementPlugin = require("../HotModuleReplacementPlugin");
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
 const {
 	VariableInfo,
 	getImportAttributes
 } = require("../javascript/JavascriptParser");
-const InnerGraph = require("../optimize/InnerGraph");
-const AppendOnlyStackedSet = require("../util/AppendOnlyStackedSet");
+const { getInnerGraphUtils } = require("../optimize/InnerGraph");
 const ConstDependency = require("./ConstDependency");
 const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
 const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
@@ -22,6 +21,10 @@ const {
 	ExportPresenceModes,
 	getNonOptionalPart
 } = require("./HarmonyImportDependency");
+const {
+	attachDependencyGuards,
+	isPresentByGuards
+} = require("./HarmonyImportGuard");
 const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
 const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
 const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
@@ -32,6 +35,7 @@ const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
 /** @typedef {import("estree").MemberExpression} MemberExpression */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module")} Module */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").ExportAllDeclaration} ExportAllDeclaration */
 /** @typedef {import("../javascript/JavascriptParser").ExportNamedDeclaration} ExportNamedDeclaration */
@@ -43,18 +47,17 @@ const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
 /** @typedef {import("./HarmonyImportDependency").Ids} Ids */
 /** @typedef {import("./HarmonyImportDependency").ExportPresenceMode} ExportPresenceMode */
 /** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
-
-/**
- * @typedef {object} HarmonySpecifierGuards
- * @property {AppendOnlyStackedSet<string> | undefined} guards
- */
-
-/** @typedef {Map<string, Set<string>>} Guards Map of import root to guarded member keys */
+/** @typedef {import("./HarmonyImportGuard").GuardFrame} GuardFrame */
 
 const harmonySpecifierTag = Symbol("harmony import");
-const harmonySpecifierGuardTag = Symbol("harmony import guard");
+
+// Shared placeholder: plain specifier references have no member ranges, so they
+// can all reuse one (never-mutated) array instead of allocating per dependency.
+/** @type {Range[]} */
+const EMPTY_ID_RANGES = [];
 
 /**
+ * Defines the harmony settings type used by this module.
  * @typedef {object} HarmonySettings
  * @property {Ids} ids
  * @property {string} source
@@ -68,6 +71,7 @@ const harmonySpecifierGuardTag = Symbol("harmony import guard");
 const PLUGIN_NAME = "HarmonyImportDependencyParserPlugin";
 
 /**
+ * Gets in operator harmony import info.
  * @param {JavascriptParser} parser the parser
  * @param {PrivateIdentifier | Expression} left left expression
  * @param {Expression} right right expression
@@ -106,21 +110,62 @@ const getInOperatorHarmonyImportInfo = (parser, left, right) => {
 	};
 };
 
+/**
+ * Whether the conditional test references an imported binding (so a dependency
+ * guard can possibly gate a dead branch). Cheap pre-scan over the test AST.
+ * @param {JavascriptParser} parser the parser
+ * @param {Expression} node test expression
+ * @returns {boolean} true when the test references a harmony import specifier
+ */
+const findImportSpecifier = (parser, node) => {
+	switch (node.type) {
+		case "Identifier":
+			return Boolean(parser.getTagData(node.name, harmonySpecifierTag));
+		case "UnaryExpression":
+			return findImportSpecifier(
+				parser,
+				/** @type {Expression} */ (node.argument)
+			);
+		case "LogicalExpression":
+			return (
+				findImportSpecifier(parser, /** @type {Expression} */ (node.left)) ||
+				findImportSpecifier(parser, /** @type {Expression} */ (node.right))
+			);
+		case "MemberExpression":
+			return findImportSpecifier(
+				parser,
+				/** @type {Expression} */ (node.object)
+			);
+		case "BinaryExpression":
+			// `"x" in ns` presence guard
+			return (
+				node.operator === "in" &&
+				findImportSpecifier(parser, /** @type {Expression} */ (node.right))
+			);
+		default:
+			return false;
+	}
+};
+
 module.exports = class HarmonyImportDependencyParserPlugin {
 	/**
+	 * Creates an instance of HarmonyImportDependencyParserPlugin.
 	 * @param {JavascriptParserOptions} options options
 	 */
 	constructor(options) {
+		/** @type {JavascriptParserOptions} */
 		this.options = options;
 		/** @type {ExportPresenceMode} */
 		this.exportPresenceMode = ExportPresenceModes.resolveFromOptions(
 			options.importExportsPresence,
 			options
 		);
+		/** @type {boolean | undefined} */
 		this.strictThisContextOnImports = options.strictThisContextOnImports;
 	}
 
 	/**
+	 * Gets export presence mode.
 	 * @param {JavascriptParser} parser the parser
 	 * @param {HarmonySettings} settings settings
 	 * @param {Ids} ids ids
@@ -135,11 +180,17 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 		);
 		if (!harmonySettings) return this.exportPresenceMode;
 
-		const data = /** @type {HarmonySpecifierGuards=} */ (
-			parser.getTagData(harmonySettings.name, harmonySpecifierGuardTag)
-		);
+		if (this.exportPresenceMode === ExportPresenceModes.NONE) {
+			return this.exportPresenceMode;
+		}
 
-		if (data && data.guards && data.guards.has(ids[0])) {
+		const stack = /** @type {GuardFrame[] | undefined} */ (
+			parser.state.guardStack
+		);
+		if (
+			stack !== undefined &&
+			isPresentByGuards(parser, stack, harmonySettings.name, ids[0])
+		) {
 			return ExportPresenceModes.NONE;
 		}
 
@@ -147,6 +198,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 	}
 
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
@@ -157,6 +209,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 		);
 
 		/**
+		 * Gets non optional member chain.
 		 * @param {MemberExpression} node member expression
 		 * @param {number} count count
 		 * @returns {Expression} member expression
@@ -184,7 +237,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					: "",
 				/** @type {Range} */ (statement.range)
 			);
-			clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
+			clearDep.loc = parser.getLocation(statement);
 			parser.state.module.addPresentationalDependency(clearDep);
 			parser.unsetAsiPosition(/** @type {Range} */ (statement.range)[1]);
 			const attributes = getImportAttributes(statement);
@@ -197,7 +250,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				const error = new WebpackError(
 					"Deferred import can only be used with `import * as namespace from '...'` syntax."
 				);
-				error.loc = statement.loc || undefined;
+				error.loc = parser.getLocation(statement) || undefined;
 				parser.state.current.addError(error);
 			}
 
@@ -207,7 +260,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				phase,
 				attributes
 			);
-			sideEffectDep.loc = /** @type {DependencyLocation} */ (statement.loc);
+			sideEffectDep.loc = parser.getLocation(statement);
 			parser.state.module.addDependency(sideEffectDep);
 			return true;
 		});
@@ -254,9 +307,12 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			dep.asiSafe = !parser.isAsiPosition(
 				/** @type {Range} */ (expression.range)[0]
 			);
-			dep.loc = /** @type {DependencyLocation} */ (expression.loc);
+			dep.loc = parser.getLocation(expression);
 			parser.state.module.addDependency(dep);
-			InnerGraph.onUsage(parser.state, (e) => (dep.usedByExports = e));
+			getInnerGraphUtils(parser.state.compilation).onUsage(
+				parser.state,
+				(e) => (dep.usedByExports = e)
+			);
 			return true;
 		});
 		parser.hooks.collectDestructuringAssignmentProperties.tap(
@@ -288,7 +344,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					this.exportPresenceMode,
 					settings.phase,
 					settings.attributes,
-					[]
+					EMPTY_ID_RANGES
 				);
 				dep.referencedPropertiesInDestructuring =
 					parser.destructuringAssignmentPropertiesFor(expr);
@@ -297,10 +353,14 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				dep.asiSafe = !parser.isAsiPosition(
 					/** @type {Range} */ (expr.range)[0]
 				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.loc = parser.getLocation(expr);
 				dep.call = parser.scope.inTaggedTemplateTag;
 				parser.state.module.addDependency(dep);
-				InnerGraph.onUsage(parser.state, (e) => (dep.usedByExports = e));
+				attachDependencyGuards(parser, dep);
+				getInnerGraphUtils(parser.state.compilation).onUsage(
+					parser.state,
+					(e) => (dep.usedByExports = e)
+				);
 				return true;
 			});
 		parser.hooks.expressionMemberChain
@@ -346,9 +406,13 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						/** @type {Range} */
 						(expr.range)[0]
 					);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					dep.loc = parser.getLocation(expr);
 					parser.state.module.addDependency(dep);
-					InnerGraph.onUsage(parser.state, (e) => (dep.usedByExports = e));
+					attachDependencyGuards(parser, dep);
+					getInnerGraphUtils(parser.state.compilation).onUsage(
+						parser.state,
+						(e) => (dep.usedByExports = e)
+					);
 					return true;
 				}
 			);
@@ -399,13 +463,38 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					dep.namespaceObjectAsContext =
 						members.length > 0 &&
 						/** @type {boolean} */ (this.strictThisContextOnImports);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					dep.loc = parser.getLocation(expr);
 					parser.state.module.addDependency(dep);
+					attachDependencyGuards(parser, dep);
 					if (args) parser.walkExpressions(args);
-					InnerGraph.onUsage(parser.state, (e) => (dep.usedByExports = e));
+					getInnerGraphUtils(parser.state.compilation).onUsage(
+						parser.state,
+						(e) => (dep.usedByExports = e)
+					);
 					return true;
 				}
 			);
+		// Per the TC39 import-defer spec, [[Set]] on a Module Namespace
+		// Exotic Object returns false without triggering evaluation. The
+		// default expressionMemberChain path produces `<importVar>.a.foo`
+		// whose `.a` getter eagerly requires (and thus evaluates) the
+		// deferred module. For top-level `ns.foo = value`, walk only the
+		// bare `ns` identifier so it gets replaced with the deferred
+		// namespace proxy (whose set trap returns false), and leave the
+		// `.foo = value` part as plain code.
+		parser.hooks.assignMemberChain
+			.for(harmonySpecifierTag)
+			.tap(PLUGIN_NAME, (expression, members) => {
+				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				if (!ImportPhaseUtils.isDefer(settings.phase)) return;
+				if (expression.operator !== "=") return;
+				if (members.length !== 1) return;
+				const left = /** @type {MemberExpression} */ (expression.left);
+				if (left.object.type !== "Identifier") return;
+				parser.walkExpression(expression.right);
+				parser.walkExpression(left.object);
+				return true;
+			});
 		const { hotAcceptCallback, hotAcceptWithoutCallback } =
 			HotModuleReplacementPlugin.getParserHooks(parser);
 		hotAcceptCallback.tap(PLUGIN_NAME, (expr, requests) => {
@@ -415,7 +504,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			}
 			const dependencies = requests.map((request) => {
 				const dep = new HarmonyAcceptImportDependency(request);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.loc = parser.getLocation(expr);
 				parser.state.module.addDependency(dep);
 				return dep;
 			});
@@ -426,7 +515,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					dependencies,
 					true
 				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.loc = parser.getLocation(expr);
 				parser.state.module.addDependency(dep);
 			}
 		});
@@ -437,7 +526,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			}
 			const dependencies = requests.map((request) => {
 				const dep = new HarmonyAcceptImportDependency(request);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.loc = parser.getLocation(expr);
 				parser.state.module.addDependency(dep);
 				return dep;
 			});
@@ -448,132 +537,36 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					dependencies,
 					false
 				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.loc = parser.getLocation(expr);
 				parser.state.module.addDependency(dep);
 			}
 		});
 
-		/**
-		 * @param {Guards} guards guards
-		 * @param {() => void} walk walk callback
-		 * @returns {void}
-		 */
-		const withGuards = (guards, walk) => {
-			const applyGuards = () => {
-				/** @type {(() => void)[]} */
-				const restoreFns = [];
-
-				for (const [rootName, members] of guards) {
-					const previous = parser.getVariableInfo(rootName);
-					const exist = /** @type {HarmonySpecifierGuards=} */ (
-						parser.getTagData(rootName, harmonySpecifierGuardTag)
-					);
+		parser.hooks.collectGuards.tap(PLUGIN_NAME, (expression) => {
+			if (parser.scope.isAsmJs) return;
 
-					const mergedGuards =
-						exist && exist.guards
-							? exist.guards.createChild()
-							: new AppendOnlyStackedSet();
+			const hasSpecifier = findImportSpecifier(parser, expression);
+			const depStart = hasSpecifier
+				? /** @type {Module} */ (parser.state.module).dependencies.length
+				: undefined;
 
-					for (const memberKey of members) mergedGuards.add(memberKey);
-					parser.tagVariable(rootName, harmonySpecifierGuardTag, {
-						guards: mergedGuards
-					});
-					restoreFns.push(() => {
-						parser.setVariable(rootName, previous);
-					});
-				}
+			if (depStart === undefined) return;
 
-				return () => {
-					for (const restore of restoreFns) {
-						restore();
-					}
-				};
+			/** @type {GuardFrame} */
+			const consequent = {
+				test: expression,
+				depStart,
+				condition: true
 			};
+			/** @type {GuardFrame | undefined} */
+			const alternate =
+				depStart === undefined
+					? undefined
+					: { test: expression, depStart, condition: false };
 
-			const restore = applyGuards();
-			try {
-				walk();
-			} finally {
-				restore();
-			}
-		};
-
-		if (this.exportPresenceMode !== ExportPresenceModes.NONE) {
-			parser.hooks.collectGuards.tap(PLUGIN_NAME, (expression) => {
-				if (parser.scope.isAsmJs) return;
-				/** @type {Guards} */
-				const guards = new Map();
-
-				/**
-				 * @param {Expression} expression expression
-				 * @param {boolean} needTruthy need to be truthy
-				 */
-				const collect = (expression, needTruthy) => {
-					if (
-						expression.type === "UnaryExpression" &&
-						expression.operator === "!"
-					) {
-						collect(expression.argument, !needTruthy);
-						return;
-					} else if (expression.type === "LogicalExpression" && needTruthy) {
-						if (expression.operator === "&&") {
-							collect(expression.left, true);
-							collect(expression.right, true);
-						} else if (expression.operator === "||") {
-							const leftEvaluation = parser.evaluateExpression(expression.left);
-							const leftBool = leftEvaluation.asBool();
-							if (leftBool === false) {
-								collect(expression.right, true);
-							}
-						} else if (expression.operator === "??") {
-							const leftEvaluation = parser.evaluateExpression(expression.left);
-							const leftNullish = leftEvaluation.asNullish();
-							if (leftNullish === true) {
-								collect(expression.right, true);
-							}
-						}
-						return;
-					}
-					if (!needTruthy) return;
-
-					// Direct `"x" in ns` guards
-					if (
-						expression.type === "BinaryExpression" &&
-						expression.operator === "in"
-					) {
-						if (expression.right.type !== "Identifier") {
-							return;
-						}
-						const info = getInOperatorHarmonyImportInfo(
-							parser,
-							expression.left,
-							expression.right
-						);
-						if (!info) return;
-
-						const { settings, leftPart, members } = info;
-						// Only direct namespace guards
-						if (members.length > 0) return;
-						const guarded = guards.get(settings.name);
-						if (guarded) {
-							guarded.add(leftPart);
-							return;
-						}
-
-						guards.set(settings.name, new Set([leftPart]));
-					}
-				};
-
-				collect(expression, true);
-
-				if (guards.size === 0) return;
-				return (walk) => {
-					withGuards(guards, walk);
-				};
-			});
-		}
+			return { consequent, alternate };
+		});
 	}
 };
 
-module.exports.harmonySpecifierGuardTag = harmonySpecifierGuardTag;
 module.exports.harmonySpecifierTag = harmonySpecifierTag;