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

package/lib/dependencies/HarmonyImportGuard.js

@@ -6,19 +6,18 @@
 "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("./CommonJsFullRequireDependency")} CommonJsFullRequireDependency */
-/** @typedef {import("./CommonJsRequireDependency")} CommonJsRequireDependency */
-/** @typedef {import("./HarmonyEvaluatedImportSpecifierDependency")} HarmonyEvaluatedImportSpecifierDependency */
-/** @typedef {import("./HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
-/** @typedef {import("./ImportDependency")} ImportDependency */
+/** @import { Expression } from "estree" */
+/** @import Dependency from "../Dependency" */
+/** @import Module from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import JavascriptParser from "../javascript/JavascriptParser" */
+/** @import { RuntimeSpec } from "../util/runtime" */
+/** @import CommonJsFullRequireDependency from "./CommonJsFullRequireDependency" */
+/** @import CommonJsRequireDependency from "./CommonJsRequireDependency" */
+/** @import HarmonyEvaluatedImportSpecifierDependency from "./HarmonyEvaluatedImportSpecifierDependency" */
+/** @import HarmonyImportSpecifierDependency from "./HarmonyImportSpecifierDependency" */
+/** @import ImportDependency from "./ImportDependency" */
 
 // Tuple-encoded boolean formula over guard dependencies. Split into per-shape
 // aliases so the recursive references resolve through array/object types.
@@ -44,13 +43,6 @@ const memoize = require("../util/memoize");
  * @property {GuardFormula | null=} presenceFormula memoized presence formula (null = no presence atom)
  */
 
-const getHarmonyImportSpecifierDependency = memoize(() =>
-	require("./HarmonyImportSpecifierDependency")
-);
-const getHarmonyEvaluatedImportSpecifierDependency = memoize(() =>
-	require("./HarmonyEvaluatedImportSpecifierDependency")
-);
-
 // Tri-state truthiness: UNKNOWN means not statically known.
 const UNKNOWN = 0;
 const FALSE = 1;
@@ -214,19 +206,17 @@ const isDeadByGuards = (guards, moduleGraph, runtime) => {
  * @returns {GuardFormula | null} formula, or null when it has no knowable atom
  */
 const buildFrameLivenessFormula = (parser, frame) => {
-	const HarmonyImportSpecifierDependency =
-		getHarmonyImportSpecifierDependency();
-	const HarmonyEvaluatedImportSpecifierDependency =
-		getHarmonyEvaluatedImportSpecifierDependency();
 	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];
+		const dep = /** @type {HarmonyEvaluatedImportSpecifierDependency} */ (
+			deps[i]
+		);
 		// Exclude `"x" in ns` evaluated deps; those feed the presence formula only.
 		if (
-			dep instanceof HarmonyImportSpecifierDependency &&
-			!(dep instanceof HarmonyEvaluatedImportSpecifierDependency) &&
+			dep.isHarmonyImportSpecifier === true &&
+			dep.isHarmonyEvaluatedImportSpecifier !== true &&
 			dep.range
 		) {
 			depByRangeStart.set(dep.range[0], dep);
@@ -341,14 +331,14 @@ const evalPresenceFormula = (formula, name, member, needTruthy) => {
  * @returns {GuardFormula | null} formula, or null when it has no presence atom
  */
 const buildFramePresenceFormula = (parser, frame) => {
-	const HarmonyEvaluatedImportSpecifierDependency =
-		getHarmonyEvaluatedImportSpecifierDependency();
 	const deps = /** @type {Module} */ (parser.state.module).dependencies;
 	/** @type {Map<number, HarmonyEvaluatedImportSpecifierDependency>} */
 	const depByRangeStart = new Map();
 	for (let i = /** @type {number} */ (frame.depStart); i < deps.length; i++) {
-		const dep = deps[i];
-		if (dep instanceof HarmonyEvaluatedImportSpecifierDependency && dep.range) {
+		const dep = /** @type {HarmonyEvaluatedImportSpecifierDependency} */ (
+			deps[i]
+		);
+		if (dep.isHarmonyEvaluatedImportSpecifier === true && dep.range) {
 			depByRangeStart.set(dep.range[0], dep);
 		}
 	}

package/lib/dependencies/HarmonyImportSideEffectDependency.js

@@ -6,19 +6,35 @@
 "use strict";
 
 const Dependency = require("../Dependency");
+const InitFragment = require("../InitFragment");
 const Module = require("../Module");
 const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
 const makeSerializable = require("../util/makeSerializable");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
+const { ImportPhaseUtils } = require("./ImportPhase");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
-/** @typedef {import("../Dependency").LazyUntil} LazyUntil */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
-/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
+const { ExportPresenceModes } = HarmonyImportDependency;
+
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import { GetConditionFn, LazyUntil } from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { ConnectionState } from "../ModuleGraphConnection" */
+/** @import { ImportAttributes } from "../javascript/JavascriptParser" */
+/** @import { ImportPhaseType } from "./ImportPhase" */
+/** @import { Ids, ExportPresenceMode } from "./HarmonyImportDependency" */
+/** @import { JavascriptModuleBuildMeta } from "../javascript/JavascriptModule" */
+/** @import WebpackError from "../errors/WebpackError" */
+/** @import { ObjectSerializerContext, ObjectDeserializerContext } from "../serialization/ObjectMiddleware" */
+
+/**
+ * Specifiers the module declares but never reads, with the presence level to
+ * report them at. Allocated only for a module that has one, so the common
+ * import pays a single empty slot.
+ * @typedef {object} UnusedSpecifiers
+ * @property {ExportPresenceMode} exportPresenceMode
+ * @property {[Ids, string][]} specifiers
+ */
 
 class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
 	/**
@@ -30,12 +46,111 @@ class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
 	 */
 	constructor(request, sourceOrder, phase, attributes) {
 		super(request, sourceOrder, phase, attributes);
+		/** @type {UnusedSpecifiers | undefined} */
+		this.unusedSpecifiers = undefined;
 	}
 
 	get type() {
 		return "harmony side effect evaluation";
 	}
 
+	/**
+	 * Returns warnings.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | null | undefined} warnings
+	 */
+	getWarnings(moduleGraph) {
+		if (
+			this._getEffectiveExportPresenceLevel(moduleGraph) !==
+			ExportPresenceModes.WARN
+		) {
+			return null;
+		}
+		return this._getUnusedSpecifierErrors(moduleGraph);
+	}
+
+	/**
+	 * Get effective export presence level.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportPresenceMode} effective mode
+	 */
+	_getEffectiveExportPresenceLevel(moduleGraph) {
+		if (this.unusedSpecifiers === undefined) return ExportPresenceModes.NONE;
+		const mode = this.unusedSpecifiers.exportPresenceMode;
+		if (mode !== ExportPresenceModes.AUTO) return mode;
+		const buildMeta =
+			/** @type {JavascriptModuleBuildMeta} */
+			(
+				/** @type {Module} */
+				(moduleGraph.getParentModule(this)).buildMeta
+			);
+		return buildMeta.strictHarmonyModule
+			? ExportPresenceModes.ERROR
+			: ExportPresenceModes.WARN;
+	}
+
+	/**
+	 * Returns errors.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | null | undefined} errors
+	 */
+	getErrors(moduleGraph) {
+		if (
+			this._getEffectiveExportPresenceLevel(moduleGraph) !==
+			ExportPresenceModes.ERROR
+		) {
+			return null;
+		}
+		return this._getUnusedSpecifierErrors(moduleGraph);
+	}
+
+	/**
+	 * Linking errors for specifiers the module declares but never references.
+	 * The spec resolves every import entry, so a name that does not exist is a
+	 * link error whether or not the binding is read.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | undefined} errors
+	 */
+	_getUnusedSpecifierErrors(moduleGraph) {
+		// Both callers resolve the presence level first, which is NONE without
+		// specifiers, so this only runs when there are some.
+		const { specifiers } = /** @type {UnusedSpecifiers} */ (
+			this.unusedSpecifiers
+		);
+		/** @type {WebpackError[] | undefined} */
+		let errors;
+		for (const [ids, name] of specifiers) {
+			const linkingErrors = this.getLinkingErrors(
+				moduleGraph,
+				ids,
+				`(imported as '${name}')`
+			);
+			if (linkingErrors) {
+				if (errors === undefined) errors = linkingErrors;
+				else errors.push(...linkingErrors);
+			}
+		}
+		return errors;
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		context.write(this.unusedSpecifiers);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		this.unusedSpecifiers = context.read();
+		super.deserialize(context);
+	}
+
 	/**
 	 * 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
@@ -93,7 +208,8 @@ HarmonyImportSideEffectDependency.Template = class HarmonyImportSideEffectDepend
 	 * @returns {void}
 	 */
 	apply(dependency, source, templateContext) {
-		const { moduleGraph, concatenationScope } = templateContext;
+		const { moduleGraph, concatenationScope, runtime, initFragments } =
+			templateContext;
 
 		const module = /** @type {Module} */ (moduleGraph.getModule(dependency));
 
@@ -103,6 +219,33 @@ HarmonyImportSideEffectDependency.Template = class HarmonyImportSideEffectDepend
 		}
 
 		if (concatenationScope && concatenationScope.isModuleInScope(module)) {
+			if (concatenationScope.isModuleWrapped(module)) {
+				const dep = /** @type {HarmonyImportSideEffectDependency} */ (
+					dependency
+				);
+				if (ImportPhaseUtils.isDefer(dep.phase)) return;
+				const connection = moduleGraph.getConnection(dep);
+				if (!connection || !connection.isTargetActive(runtime)) return;
+				// A hoisted body cannot be deferred, so its imports evaluate at their
+				// own slots; calling from here would run them after everything hoisted
+				// in between. Eagerness stops at one level: a module is generated
+				// before its importers, so it never learns whether it is itself eager.
+				if (concatenationScope.isWrapped()) {
+					initFragments.push(
+						new InitFragment(
+							`${concatenationScope.createModuleReference(module, {
+								moduleExportsAccess: true,
+								asiSafe: true
+							})};\n`,
+							InitFragment.STAGE_HARMONY_IMPORTS,
+							/** @type {number} */ (dep.sourceOrder),
+							`cjs eager init ${module.identifier()}`
+						)
+					);
+				} else {
+					concatenationScope.registerEagerModule(module);
+				}
+			}
 			return;
 		}
 		super.apply(dependency, source, templateContext);

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -11,6 +11,7 @@ const Template = require("../Template");
 const {
 	InlinedUsedName,
 	isExportInlined,
+	isInlineEnabled,
 	isInlineExportsEnabled
 } = require("../optimize/InlineExports");
 const {
@@ -18,38 +19,48 @@ const {
 } = 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");
+const HarmonyImportGuard = require("./HarmonyImportGuard");
 const { ImportPhaseUtils } = require("./ImportPhase");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
-/** @typedef {import("../Dependency").RawReferencedExports} RawReferencedExports */
-/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../errors/WebpackError")} WebpackError */
-/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperties} DestructuringAssignmentProperties */
-/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../optimize/InnerGraph").UsedByExports} UsedByExports */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("../util/chainedImports").IdRanges} IdRanges */
-/** @typedef {import("./HarmonyImportDependency").ExportPresenceMode} ExportPresenceMode */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import { GetConditionFn, ReferencedExports } from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import Module, { BuildMeta } from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/**
+ * @import ModuleGraphConnection, {
+ * 	ConnectionState
+ * } from "../ModuleGraphConnection"
+ */
+/** @import WebpackError from "../errors/WebpackError" */
+/**
+ * @import {
+ * 	DestructuringAssignmentProperties,
+ * 	ImportAttributes,
+ * 	Range
+ * } from "../javascript/JavascriptParser"
+ */
+/** @import { UsedByExports } from "../optimize/InnerGraph" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
+/** @import { RuntimeSpec } from "../util/runtime" */
+/** @import { IdRanges } from "../util/chainedImports" */
+/** @import { ExportPresenceMode } from "./HarmonyImportDependency" */
 /** @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"));
+/** @import { ImportPhaseType } from "./ImportPhase" */
+/** @import { DependencyGuard } from "./HarmonyImportGuard" */
+/**
+ * @import {
+ * 	JavascriptModuleBuildMeta
+ * } from "../javascript/JavascriptModule"
+ */
 
 const idsSymbol = /** @type {symbol} */ (
 	Symbol("HarmonyImportSpecifierDependency.ids")
@@ -57,7 +68,22 @@ const idsSymbol = /** @type {symbol} */ (
 
 const { ExportPresenceModes } = HarmonyImportDependency;
 
+/**
+ * One condition closure per module graph and variant rather than per dependency.
+ * The dependency the condition was built for is always the one on the connection
+ * it is called with, since `ModuleGraph#setResolvedModule` is the only caller of
+ * `getCondition` and pairs the two. Indexed by
+ * `(usedByExports ? 1 : 0) | (inlineEnabled ? 2 : 0)`.
+ * @type {WeakMap<ModuleGraph, (GetConditionFn | undefined)[]>}
+ */
+const conditionsByModuleGraph = new WeakMap();
+
 class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
+	// read by `HarmonyImportGuard` in place of `instanceof`, which would cycle
+	get isHarmonyImportSpecifier() {
+		return true;
+	}
+
 	/**
 	 * Creates an instance of HarmonyImportSpecifierDependency.
 	 * @param {string} request request
@@ -181,36 +207,59 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 			moduleGraph
 		);
 		if (usedByExportsCondition === false) return false;
+		const inlineEnabled = isInlineExportsEnabled(moduleGraph);
 		// Keep the connection unconditional (fast path) when nothing can deactivate it
 		if (
 			usedByExportsCondition === null &&
 			this.branchGuards === undefined &&
-			!isInlineExportsEnabled(moduleGraph)
+			!inlineEnabled
 		) {
 			return null;
 		}
-		const dep = this;
-		return (connection, runtime) => {
+		// Everything the condition still needs is either per module graph or on
+		// the connection it is called with, so one closure per variant serves the
+		// whole graph instead of one per dependency.
+		const slot =
+			(usedByExportsCondition === null ? 0 : 1) | (inlineEnabled ? 2 : 0);
+		let variants = conditionsByModuleGraph.get(moduleGraph);
+		if (variants === undefined) {
+			variants = [undefined, undefined, undefined, undefined];
+			conditionsByModuleGraph.set(moduleGraph, variants);
+		}
+		const cached = variants[slot];
+		if (cached !== undefined) return cached;
+		/** @type {GetConditionFn} */
+		const condition = (connection, runtime) => {
+			const dep = /** @type {HarmonyImportSpecifierDependency} */ (
+				connection.dependency
+			);
 			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;
+			// `isInlineEnabled` is the cheap module-level precondition of
+			// `isExportInlined`; checking it here keeps the id lookup off the hot
+			// path for the common target module that has no inlined exports
+			if (inlineEnabled && isInlineEnabled(connection.module)) {
+				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)
+				HarmonyImportGuard.isDeadByGuards(guards, moduleGraph, runtime)
 			) {
 				return false;
 			}
 			return true;
 		};
+		variants[slot] = condition;
+		return condition;
 	}
 
 	/**
@@ -287,21 +336,19 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	 */
 	_getReferencedExportsInDestructuring(ids) {
 		if (this.referencedPropertiesInDestructuring) {
-			/** @type {RawReferencedExports} */
-			const refsInDestructuring = [];
+			/** @type {ReferencedExports} */
+			const refs = [];
 			traverseDestructuringAssignmentProperties(
 				this.referencedPropertiesInDestructuring,
-				(stack) => refsInDestructuring.push(stack.map((p) => p.id))
+				(stack) => {
+					const idsInDestructuring = stack.map((p) => p.id);
+					// Destructuring consumer can't accept an inlined literal
+					refs.push({
+						name: ids ? [...ids, ...idsInDestructuring] : idsInDestructuring,
+						canInline: false
+					});
+				}
 			);
-			/** @type {ReferencedExports} */
-			const refs = [];
-			for (const idsInDestructuring of refsInDestructuring) {
-				// Destructuring consumer can't accept an inlined literal
-				refs.push({
-					name: ids ? [...ids, ...idsInDestructuring] : idsInDestructuring,
-					canInline: false
-				});
-			}
 			return refs;
 		}
 		return ids
@@ -643,5 +690,6 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 	}
 };
 
+HarmonyImportSpecifierDependency.idsSymbol = idsSymbol;
+
 module.exports = HarmonyImportSpecifierDependency;
-module.exports.idsSymbol = idsSymbol;

package/lib/dependencies/HarmonyModulesPlugin.js

@@ -27,9 +27,13 @@ const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDepend
 const HarmonyTopLevelThisParserPlugin = require("./HarmonyTopLevelThisParserPlugin");
 const TopLevelAwaitDependency = require("./TopLevelAwaitDependency");
 
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../javascript/JavascriptParser")} Parser */
+/**
+ * @import {
+ * 	JavascriptParserOptions
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Compiler from "../Compiler" */
+/** @import Parser from "../javascript/JavascriptParser" */
 
 /**
  * Defines the harmony modules plugin options type used by this module.

package/lib/dependencies/HarmonyTopLevelThisParserPlugin.js

@@ -8,9 +8,7 @@
 const ConstDependency = require("./ConstDependency");
 const HarmonyExports = require("./HarmonyExports");
 
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
 
 const PLUGIN_NAME = "HarmonyTopLevelThisParserPlugin";