webpack 5.107.1 → 5.108.0

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -11,8 +11,8 @@ const {
 	VariableInfo,
 	getImportAttributes
 } = require("../javascript/JavascriptParser");
-const InnerGraph = require("../optimize/InnerGraph");
-const AppendOnlyStackedSet = require("../util/AppendOnlyStackedSet");
+const { getInnerGraphUtils } = require("../optimize/InnerGraph");
+const memoize = require("../util/memoize");
 const ConstDependency = require("./ConstDependency");
 const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
 const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
@@ -32,6 +32,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,17 +44,18 @@ const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
 /** @typedef {import("./HarmonyImportDependency").Ids} Ids */
 /** @typedef {import("./HarmonyImportDependency").ExportPresenceMode} ExportPresenceMode */
 /** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
-
-/**
- * Defines the harmony specifier guards type used by this module.
- * @typedef {object} HarmonySpecifierGuards
- * @property {AppendOnlyStackedSet<string> | undefined} guards
- */
+/** @typedef {import("./HarmonyImportGuard").GuardFrame} GuardFrame */
 
 /** @typedef {Map<string, Set<string>>} Guards Map of import root to guarded member keys */
 
+const getHarmonyImportGuard = memoize(() => require("./HarmonyImportGuard"));
+
 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.
@@ -109,18 +111,51 @@ 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)
+			);
+		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;
 	}
 
@@ -140,12 +175,21 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 		);
 		if (!harmonySettings) return this.exportPresenceMode;
 
-		const data = /** @type {HarmonySpecifierGuards=} */ (
-			parser.getTagData(harmonySettings.name, harmonySpecifierGuardTag)
+		const stack = /** @type {GuardFrame[] | undefined} */ (
+			parser.state.guardStack
 		);
-
-		if (data && data.guards && data.guards.has(ids[0])) {
-			return ExportPresenceModes.NONE;
+		if (stack !== undefined) {
+			const name = harmonySettings.name;
+			const member = ids[0];
+			for (let i = stack.length - 1; i >= 0; i--) {
+				const presence = stack[i].presence;
+				if (presence !== undefined) {
+					const members = presence.get(name);
+					if (members !== undefined && members.has(member)) {
+						return ExportPresenceModes.NONE;
+					}
+				}
+			}
 		}
 
 		return this.exportPresenceMode;
@@ -263,7 +307,10 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			);
 			dep.loc = /** @type {DependencyLocation} */ (expression.loc);
 			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(
@@ -295,7 +342,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					this.exportPresenceMode,
 					settings.phase,
 					settings.attributes,
-					[]
+					EMPTY_ID_RANGES
 				);
 				dep.referencedPropertiesInDestructuring =
 					parser.destructuringAssignmentPropertiesFor(expr);
@@ -307,7 +354,11 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				dep.call = parser.scope.inTaggedTemplateTag;
 				parser.state.module.addDependency(dep);
-				InnerGraph.onUsage(parser.state, (e) => (dep.usedByExports = e));
+				getHarmonyImportGuard().attachDependencyGuards(parser, dep);
+				getInnerGraphUtils(parser.state.compilation).onUsage(
+					parser.state,
+					(e) => (dep.usedByExports = e)
+				);
 				return true;
 			});
 		parser.hooks.expressionMemberChain
@@ -355,7 +406,11 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					);
 					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 					parser.state.module.addDependency(dep);
-					InnerGraph.onUsage(parser.state, (e) => (dep.usedByExports = e));
+					getHarmonyImportGuard().attachDependencyGuards(parser, dep);
+					getInnerGraphUtils(parser.state.compilation).onUsage(
+						parser.state,
+						(e) => (dep.usedByExports = e)
+					);
 					return true;
 				}
 			);
@@ -408,8 +463,12 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						/** @type {boolean} */ (this.strictThisContextOnImports);
 					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 					parser.state.module.addDependency(dep);
+					getHarmonyImportGuard().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;
 				}
 			);
@@ -481,55 +540,14 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			}
 		});
 
-		/**
-		 * Processes the provided guard.
-		 * @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)
-					);
-
-					const mergedGuards =
-						exist && exist.guards
-							? exist.guards.createChild()
-							: new AppendOnlyStackedSet();
-
-					for (const memberKey of members) mergedGuards.add(memberKey);
-					parser.tagVariable(rootName, harmonySpecifierGuardTag, {
-						guards: mergedGuards
-					});
-					restoreFns.push(() => {
-						parser.setVariable(rootName, previous);
-					});
-				}
-
-				return () => {
-					for (const restore of restoreFns) {
-						restore();
-					}
-				};
-			};
-
-			const restore = applyGuards();
-			try {
-				walk();
-			} finally {
-				restore();
-			}
-		};
+		parser.hooks.collectGuards.tap(PLUGIN_NAME, (expression) => {
+			if (parser.scope.isAsmJs) return;
 
-		if (this.exportPresenceMode !== ExportPresenceModes.NONE) {
-			parser.hooks.collectGuards.tap(PLUGIN_NAME, (expression) => {
-				if (parser.scope.isAsmJs) return;
+			// Presence guards: `"x" in ns` checks that suppress export-presence errors
+			// (consequent only).
+			/** @type {Guards | undefined} */
+			let presence;
+			if (this.exportPresenceMode !== ExportPresenceModes.NONE) {
 				/** @type {Guards} */
 				const guards = new Map();
 
@@ -596,14 +614,32 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 
 				collect(expression, true);
 
-				if (guards.size === 0) return;
-				return (walk) => {
-					withGuards(guards, walk);
-				};
-			});
-		}
+				if (guards.size > 0) presence = guards;
+			}
+
+			const hasSpecifier = findImportSpecifier(parser, expression);
+			const depStart = hasSpecifier
+				? /** @type {Module} */ (parser.state.module).dependencies.length
+				: undefined;
+
+			if (presence === undefined && depStart === undefined) return;
+
+			/** @type {GuardFrame} */
+			const consequent = {
+				presence,
+				test: expression,
+				depStart,
+				condition: true
+			};
+			/** @type {GuardFrame | undefined} */
+			const alternate =
+				depStart === undefined
+					? undefined
+					: { test: expression, depStart, condition: false };
+
+			return { consequent, alternate };
+		});
 	}
 };
 
-module.exports.harmonySpecifierGuardTag = harmonySpecifierGuardTag;
 module.exports.harmonySpecifierTag = harmonySpecifierTag;

package/lib/dependencies/HarmonyImportGuard.js

@@ -0,0 +1,254 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+"use strict";
+
+const { InlinedUsedName } = require("../optimize/InlineExports");
+const memoize = require("../util/memoize");
+
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./CommonJsRequireDependency")} CommonJsRequireDependency */
+/** @typedef {import("./HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
+/** @typedef {import("./ImportDependency")} ImportDependency */
+
+// Tuple-encoded boolean formula over guard dependencies. Split into per-shape
+// aliases so the recursive references resolve through array/object types.
+/** @typedef {["v", Dependency]} GuardAtom */
+/** @typedef {["?"]} GuardUnknown */
+/** @typedef {["!", GuardFormula]} GuardNot */
+/** @typedef {["&&" | "||" | "??", GuardFormula, GuardFormula]} GuardLogical */
+/** @typedef {GuardAtom | GuardUnknown | GuardNot | GuardLogical} GuardFormula */
+/** @typedef {{ formula: GuardFormula, value: boolean }} DependencyGuard branch guard: the dependency is live only when the formula evaluates to `value` */
+/** @typedef {HarmonyImportSpecifierDependency | CommonJsRequireDependency | ImportDependency} GuardableDependency */
+
+/**
+ * A guard frame pushed onto `parser.state.guardStack` for the duration of one
+ * conditional branch body. Carries the `"x" in ns` presence guards and/or the
+ * dead-branch dependency guard for that branch.
+ * @typedef {object} GuardFrame
+ * @property {Map<string, Set<string>>=} presence `"x" in ns` presence guards active in this branch
+ * @property {Expression=} test the conditional test (for the lazily built formula)
+ * @property {number=} depStart dependency count before the test was walked
+ * @property {boolean=} condition branch truthiness the dependency guard is live for
+ * @property {GuardFormula | null=} formula memoized formula (null = no knowable atom)
+ */
+
+const getHarmonyImportSpecifierDependency = memoize(() =>
+	require("./HarmonyImportSpecifierDependency")
+);
+
+// Tri-state truthiness: UNKNOWN means not statically known.
+const UNKNOWN = 0;
+const FALSE = 1;
+const TRUE = 2;
+
+/**
+ * @param {number} t tri-state value
+ * @returns {number} negated tri-state
+ */
+const flip = (t) => (t === TRUE ? FALSE : t === FALSE ? TRUE : UNKNOWN);
+
+/**
+ * @param {boolean} b boolean
+ * @returns {number} tri-state value
+ */
+const fromBool = (b) => (b ? TRUE : FALSE);
+
+/**
+ * Build a guard formula from a conditional test AST.
+ * @param {Expression} test conditional test expression
+ * @param {Map<number, HarmonyImportSpecifierDependency>} depByRangeStart import-specifier deps in the test, keyed by range start
+ * @returns {GuardFormula | null} formula, or null when it has no knowable atom
+ */
+const buildGuardFormula = (test, depByRangeStart) => {
+	/**
+	 * @param {Expression} node ast node
+	 * @returns {GuardFormula} formula node
+	 */
+	const build = (node) => {
+		if (node.type === "UnaryExpression" && node.operator === "!") {
+			return ["!", build(/** @type {Expression} */ (node.argument))];
+		}
+		if (
+			node.type === "LogicalExpression" &&
+			(node.operator === "&&" ||
+				node.operator === "||" ||
+				node.operator === "??")
+		) {
+			return [
+				node.operator,
+				build(/** @type {Expression} */ (node.left)),
+				build(/** @type {Expression} */ (node.right))
+			];
+		}
+		const dep =
+			node.range && depByRangeStart.get(/** @type {number} */ (node.range[0]));
+		return dep ? ["v", dep] : ["?"];
+	};
+
+	const formula = build(test);
+	return hasAtom(formula) ? formula : null;
+};
+
+/**
+ * @param {GuardFormula} formula formula
+ * @returns {boolean} true when the formula contains at least one atom
+ */
+const hasAtom = (formula) => {
+	switch (formula[0]) {
+		case "v":
+			return true;
+		case "!":
+			return hasAtom(formula[1]);
+		case "&&":
+		case "||":
+		case "??":
+			return hasAtom(formula[1]) || hasAtom(formula[2]);
+		default:
+			return false;
+	}
+};
+
+/**
+ * @param {GuardFormula} formula formula
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {RuntimeSpec} runtime runtime
+ * @returns {{ t: number, n: number }} truthy `t` and null `n` tri-states
+ */
+const evalNode = (formula, moduleGraph, runtime) => {
+	switch (formula[0]) {
+		case "v": {
+			const dep = /** @type {HarmonyImportSpecifierDependency} */ (formula[1]);
+			const module = moduleGraph.getModule(dep);
+			if (!module) return { t: UNKNOWN, n: UNKNOWN };
+			const used = moduleGraph
+				.getExportsInfo(module)
+				.getUsedName(dep.getIds(moduleGraph), runtime);
+			// Only a bare inlined primitive is knowable; a property suffix is not.
+			if (!(used instanceof InlinedUsedName) || used.suffix.length !== 0) {
+				return { t: UNKNOWN, n: UNKNOWN };
+			}
+			const value = used.value;
+			const nullish = value.kind === "null" || value.kind === "undefined";
+			return {
+				t: fromBool(!nullish && Boolean(value.value)),
+				n: fromBool(nullish)
+			};
+		}
+		case "!":
+			// `!x` always yields a boolean → never nullish.
+			return {
+				t: flip(evalNode(formula[1], moduleGraph, runtime).t),
+				n: FALSE
+			};
+		case "&&": {
+			const l = evalNode(formula[1], moduleGraph, runtime);
+			const r = evalNode(formula[2], moduleGraph, runtime);
+			const t =
+				l.t === FALSE || r.t === FALSE
+					? FALSE
+					: l.t === TRUE && r.t === TRUE
+						? TRUE
+						: UNKNOWN;
+			return { t, n: UNKNOWN };
+		}
+		case "||": {
+			const l = evalNode(formula[1], moduleGraph, runtime);
+			const r = evalNode(formula[2], moduleGraph, runtime);
+			const t =
+				l.t === TRUE || r.t === TRUE
+					? TRUE
+					: l.t === FALSE && r.t === FALSE
+						? FALSE
+						: UNKNOWN;
+			return { t, n: UNKNOWN };
+		}
+		case "??": {
+			const l = evalNode(formula[1], moduleGraph, runtime);
+			const r = evalNode(formula[2], moduleGraph, runtime);
+			// `l ?? r` is l when l non-nullish, else r.
+			const t =
+				l.n === FALSE ? l.t : l.n === TRUE ? r.t : l.t === r.t ? l.t : UNKNOWN;
+			return { t, n: UNKNOWN };
+		}
+		default:
+			return { t: UNKNOWN, n: UNKNOWN };
+	}
+};
+
+/**
+ * Whether any guard proves its branch dead.
+ * @param {DependencyGuard[]} guards dependency guards
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {RuntimeSpec} runtime runtime
+ * @returns {boolean} true when a test is provably the opposite of its branch
+ */
+const isDeadByGuards = (guards, moduleGraph, runtime) => {
+	for (const guard of guards) {
+		const t = evalNode(guard.formula, moduleGraph, runtime).t;
+		if (t !== UNKNOWN && t !== (guard.value ? TRUE : FALSE)) return true;
+	}
+	return false;
+};
+
+/**
+ * Builds (once) the dependency-guard formula for a frame from the import
+ * specifier deps created while walking the test.
+ * @param {JavascriptParser} parser the parser
+ * @param {GuardFrame} frame guard frame
+ * @returns {GuardFormula | null} formula, or null when it has no knowable atom
+ */
+const buildFrameFormula = (parser, frame) => {
+	const HarmonyImportSpecifierDependency =
+		getHarmonyImportSpecifierDependency();
+	const deps = /** @type {Module} */ (parser.state.module).dependencies;
+	/** @type {Map<number, HarmonyImportSpecifierDependency>} */
+	const depByRangeStart = new Map();
+	for (let i = /** @type {number} */ (frame.depStart); i < deps.length; i++) {
+		const dep = deps[i];
+		if (dep instanceof HarmonyImportSpecifierDependency && dep.range) {
+			depByRangeStart.set(dep.range[0], dep);
+		}
+	}
+	return buildGuardFormula(
+		/** @type {Expression} */ (frame.test),
+		depByRangeStart
+	);
+};
+
+/**
+ * Tags a freshly created dependency with the active dependency guards.
+ * @param {JavascriptParser} parser the parser
+ * @param {GuardableDependency} dep the dependency
+ */
+const attachDependencyGuards = (parser, dep) => {
+	const stack = /** @type {GuardFrame[] | undefined} */ (
+		parser.state.guardStack
+	);
+	if (stack === undefined || stack.length === 0) return;
+	/** @type {DependencyGuard[] | undefined} */
+	let guards;
+	for (const frame of stack) {
+		if (frame.depStart === undefined) continue;
+		let formula = frame.formula;
+		if (formula === undefined) {
+			formula = frame.formula = buildFrameFormula(parser, frame);
+		}
+		if (formula === null) continue;
+		(guards || (guards = [])).push({
+			formula,
+			value: /** @type {boolean} */ (frame.condition)
+		});
+	}
+	if (guards !== undefined) dep.branchGuards = guards;
+};
+
+module.exports.attachDependencyGuards = attachDependencyGuards;
+module.exports.isDeadByGuards = isDeadByGuards;

package/lib/dependencies/HarmonyImportSideEffectDependency.js

@@ -5,14 +5,15 @@
 
 "use strict";
 
+const Dependency = require("../Dependency");
 const Module = require("../Module");
 const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
 const makeSerializable = require("../util/makeSerializable");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
+/** @typedef {import("../Dependency").LazyUntil} LazyUntil */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
@@ -35,6 +36,22 @@ class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
 		return "harmony side effect evaluation";
 	}
 
+	/**
+	 * 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 null;
+	}
+
+	/**
+	 * Returns how this dependency may be deferred when its parent module is side-effect-free (lazy barrel optimization).
+	 * @returns {LazyUntil | null} lazy classification, null when it must be processed eagerly
+	 */
+	getLazyUntil() {
+		return Dependency.LAZY_UNTIL_REQUEST;
+	}
+
 	/**
 	 * Returns function to determine if the connection is active.
 	 * @param {ModuleGraph} moduleGraph module graph