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

package/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -130,6 +130,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 					/** @type {HarmonySettings | undefined} */
 					(parser.getTagData(name, harmonySpecifierTag));
 				if (!settings || settings.ids.length !== 0) return;
+				settings.used = true;
 				if (ImportPhaseUtils.isDefer(settings.phase)) return;
 				const harmonyNamedExports = (parser.state.harmonyNamedExports =
 					parser.state.harmonyNamedExports || new Set());
@@ -255,6 +256,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 				const settings =
 					/** @type {HarmonySettings} */
 					(parser.getTagData(id, harmonySpecifierTag));
+				if (settings) settings.used = true;
 				const harmonyNamedExports = (parser.state.harmonyNamedExports =
 					parser.state.harmonyNamedExports || new Set());
 				harmonyNamedExports.add(name);

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -135,6 +135,11 @@ class ExportMode {
 		/** @type {InstanceType<ExportInfo> | null} */
 		this.partialNamespaceExportInfo = null;
 
+		// for "reexport-undefined": the name resolves through a circular
+		// reexport chain rather than being absent from a non-harmony module
+		/** @type {boolean} */
+		this.circular = false;
+
 		// for "dynamic-reexport":
 		/** @type {ExportModeIgnored | null} */
 		this.ignored = null;
@@ -232,12 +237,28 @@ const isStarReexportBackToParent = (moduleGraph, exportInfo, parentModule) => {
 	}
 };
 
+/**
+ * Two `export *` sources are ambiguous for a name when they resolve to
+ * different bindings; a diamond re-export of the same binding is not.
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {InstanceType<ExportInfo>} previous export info of the star source that first provided the name
+ * @param {InstanceType<ExportInfo>} exportInfo export info of a later star source providing the same name
+ * @returns {boolean} true when the two sources provide different bindings
+ */
+const isAmbiguousWith = (moduleGraph, previous, exportInfo) => {
+	const previousBinding = previous.getTerminalBinding(moduleGraph);
+	if (!previousBinding) return false;
+	const binding = exportInfo.getTerminalBinding(moduleGraph);
+	if (!binding) return false;
+	return previousBinding !== binding;
+};
+
 /**
  * Determine export assignments.
  * @param {ModuleGraph} moduleGraph module graph
  * @param {HarmonyExportImportedSpecifierDependency[]} dependencies dependencies
  * @param {HarmonyExportImportedSpecifierDependency=} additionalDependency additional dependency
- * @returns {{ names: ExportInfoName[], dependencyIndices: DependencyIndices }} result
+ * @returns {{ names: ExportInfoName[], dependencyIndices: DependencyIndices, conflicting: Set<ExportInfoName> | undefined }} result
  */
 const determineExportAssignments = (
 	moduleGraph,
@@ -248,6 +269,10 @@ const determineExportAssignments = (
 	const names = new Set();
 	/** @type {DependencyIndices} */
 	const dependencyIndices = [];
+	/** @type {Map<ExportInfoName, InstanceType<ExportInfo>>} */
+	const firstProvider = new Map();
+	/** @type {Set<ExportInfoName> | undefined} */
+	let conflicting;
 
 	if (additionalDependency) {
 		dependencies = [...dependencies, additionalDependency];
@@ -265,24 +290,42 @@ const determineExportAssignments = (
 		if (otherImportedModule) {
 			const exportsInfo = moduleGraph.getExportsInfo(otherImportedModule);
 			for (const exportInfo of exportsInfo.exports) {
+				if (exportInfo.provided !== true || exportInfo.name === "default") {
+					continue;
+				}
+				if (names.has(exportInfo.name)) {
+					const previous =
+						/** @type {InstanceType<ExportInfo>} */
+						(firstProvider.get(exportInfo.name));
+					if (
+						isAmbiguousWith(moduleGraph, previous, exportInfo) &&
+						// A cyclic contribution resolves to nothing, so it never competes
+						// with the binding a sibling `export *` provides.
+						!(
+							parentModule &&
+							isStarReexportBackToParent(moduleGraph, exportInfo, parentModule)
+						)
+					) {
+						if (conflicting === undefined) conflicting = new Set();
+						conflicting.add(exportInfo.name);
+					}
+					continue;
+				}
 				if (
-					exportInfo.provided === true &&
-					exportInfo.name !== "default" &&
-					!names.has(exportInfo.name) &&
-					!(
-						parentModule &&
-						isStarReexportBackToParent(moduleGraph, exportInfo, parentModule)
-					)
+					parentModule &&
+					isStarReexportBackToParent(moduleGraph, exportInfo, parentModule)
 				) {
-					names.add(exportInfo.name);
-					dependencyIndices[i] = names.size;
+					continue;
 				}
+				names.add(exportInfo.name);
+				firstProvider.set(exportInfo.name, exportInfo);
+				dependencyIndices[i] = names.size;
 			}
 		}
 	}
 	dependencyIndices.push(names.size);
 
-	return { names: [...names], dependencyIndices };
+	return { names: [...names], dependencyIndices, conflicting };
 };
 
 /**
@@ -396,6 +439,14 @@ const getMode = (moduleGraph, dep, runtimeKey) => {
 					mode.name = name;
 					break;
 				default:
+					// forwarding to a circular chain would recurse until the stack
+					// blows, so the name resolves to undefined like a missing one
+					if (exportInfo.hasCircularTarget(moduleGraph)) {
+						mode = new ExportMode("reexport-undefined");
+						mode.name = name;
+						mode.circular = true;
+						break;
+					}
 					mode = new ExportMode("normal-reexport");
 					mode.items = [
 						new NormalReexportItem(name, ids, exportInfo, false, false)
@@ -653,6 +704,12 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		/** @type {IgnoredExports} */
 		const ignoredExports = new Set(this.activeExports);
 		ignoredExports.add("default");
+		// An ambiguous name resolves to no binding at all, so no `export *` in this
+		// module may contribute it — not even the first one.
+		const conflicting = this._getConflictingStarExportNames(moduleGraph);
+		if (conflicting !== undefined) {
+			for (const name of conflicting) ignoredExports.add(name);
+		}
 
 		/** @type {Hidden | undefined} */
 		let hiddenExports;
@@ -858,6 +915,21 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		}
 	}
 
+	/**
+	 * Names this module's `export *` sources provide with conflicting bindings.
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {Set<ExportInfoName> | undefined} ambiguous names, or nothing when there are none
+	 */
+	_getConflictingStarExportNames(moduleGraph) {
+		// Every `export *` carries the module's full star list; a lone one has
+		// nothing to be ambiguous with, so skip the walk.
+		if (!this.allStarExports) return;
+		const { dependencies } = this.allStarExports;
+		if (dependencies.length < 2) return;
+		return moduleGraph.cached(determineExportAssignments, dependencies)
+			.conflicting;
+	}
+
 	/**
 	 * Discover active exports from other star exports.
 	 * @param {ModuleGraph} moduleGraph the module graph
@@ -1059,10 +1131,54 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	 */
 	getWarnings(moduleGraph) {
 		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
+		const circular =
+			this._getCircularReexportPresenceLevel() === ExportPresenceModes.WARN
+				? this._getCircularReexportErrors(moduleGraph)
+				: undefined;
 		if (exportsPresence === ExportPresenceModes.WARN) {
-			return this._getErrors(moduleGraph);
+			const errors = this._getErrors(moduleGraph);
+			if (!circular) return errors;
+			return errors ? [...errors, ...circular] : circular;
 		}
-		return null;
+		return circular;
+	}
+
+	/**
+	 * Reporting level for a circular reexport chain. It skips the promotion to
+	 * an error that AUTO gives a strict harmony module — a cycle warns by
+	 * default — but an explicit setting still says whether and how to report.
+	 * @returns {ExportPresenceMode} effective mode
+	 */
+	_getCircularReexportPresenceLevel() {
+		return this.exportPresenceMode === ExportPresenceModes.AUTO
+			? ExportPresenceModes.WARN
+			: this.exportPresenceMode;
+	}
+
+	/**
+	 * Returns errors for a name resolving through a circular reexport chain.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | undefined} errors
+	 */
+	_getCircularReexportErrors(moduleGraph) {
+		const ids = this.getIds(moduleGraph);
+		if (ids.length === 0 || !this.name) return;
+		const parentModule = /** @type {Module} */ (
+			moduleGraph.getParentModule(this)
+		);
+		const exportInfo = moduleGraph
+			.getExportsInfo(parentModule)
+			.getReadOnlyExportInfo(this.name);
+		if (!exportInfo.hasCircularTarget(moduleGraph)) return;
+		return [
+			new HarmonyLinkingError(
+				`export '${ids.join(".")}' (reexported as '${
+					this.name
+				}') is part of a circular reexport chain in '${
+					this.userRequest
+				}' and is undefined`
+			)
+		];
 	}
 
 	/**
@@ -1072,10 +1188,18 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	 */
 	getErrors(moduleGraph) {
 		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
-		if (exportsPresence === ExportPresenceModes.ERROR) {
-			return this._getErrors(moduleGraph);
+		const errors =
+			exportsPresence === ExportPresenceModes.ERROR
+				? this._getErrors(moduleGraph)
+				: null;
+		if (
+			this._getCircularReexportPresenceLevel() !== ExportPresenceModes.ERROR
+		) {
+			return errors;
 		}
-		return null;
+		const circular = this._getCircularReexportErrors(moduleGraph);
+		if (!circular) return errors;
+		return errors ? [...errors, ...circular] : circular;
 	}
 
 	/**
@@ -1429,7 +1553,9 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 				initFragments.push(
 					this.getReexportFragment(
 						module,
-						"reexport non-default export from non-harmony",
+						mode.circular
+							? "reexport circular"
+							: "reexport non-default export from non-harmony",
 						moduleGraph
 							.getExportsInfo(module)
 							.getUsedName(/** @type {string} */ (mode.name), runtime),

package/lib/dependencies/HarmonyImportDependency.js

@@ -11,11 +11,14 @@ const InitFragment = require("../InitFragment");
 const Template = require("../Template");
 const AwaitDependenciesInitFragment = require("../async-modules/AwaitDependenciesInitFragment");
 const isGeneratorLowered = require("../async-modules/isGeneratorLowered");
+const memoize = require("../util/memoize");
 const { filterRuntime, mergeRuntime } = require("../util/runtime");
 const HarmonyLinkingError = require("./HarmonyLinkingError");
 const { ImportPhase, ImportPhaseUtils } = require("./ImportPhase");
 const ModuleDependency = require("./ModuleDependency");
 
+const getExternalModule = memoize(() => require("../ExternalModule"));
+
 /** @import { ReplaceSource } from "webpack-sources" */
 /**
  * @import {
@@ -97,6 +100,31 @@ const getNonOptionalPart = (members, membersOptionals) => {
 
 /** @typedef {string[]} Ids */
 
+/**
+ * Export names a lazy barrel still defers, so they are missing from its provided
+ * exports without being absent from the module.
+ * @param {Module} module the imported module
+ * @returns {Set<string> | true | undefined} deferred names, true when a deferred star re-export may provide any name, undefined when none
+ */
+const getDeferredExports = (module) => {
+	const factoryMeta = module.factoryMeta;
+	if (factoryMeta === undefined || !factoryMeta.sideEffectFree) return;
+	/** @type {Set<string> | undefined} */
+	let names;
+	for (const dep of module.dependencies) {
+		// TODO remove in webpack 6
+		// These may be missing on custom dependency types not extending the base Dependency
+		if (!("getLazyUntil" in dep) || !("isLazy" in dep)) continue;
+		if (!dep.isLazy()) continue;
+		const until = dep.getLazyUntil();
+		if (until === Dependency.LAZY_UNTIL_FALLBACK) return true;
+		if (until !== Dependency.LAZY_UNTIL_ID) continue;
+		if (names === undefined) names = new Set();
+		names.add(/** @type {string} */ (dep.getLazyName()));
+	}
+	return names;
+};
+
 class HarmonyImportDependency extends ModuleDependency {
 	/**
 	 * Creates an instance of HarmonyImportDependency.
@@ -185,9 +213,14 @@ class HarmonyImportDependency extends ModuleDependency {
 		const importedModule = /** @type {Module} */ (moduleGraph.getModule(this));
 		const meta = moduleGraph.getMeta(module);
 
+		// An async external is a promise webpack awaits, not a module record with
+		// an evaluating state, so deferring its namespace would never throw.
 		const isDeferred =
 			ImportPhaseUtils.isDefer(this.phase) &&
-			!(/** @type {BuildMeta} */ (importedModule.buildMeta).async);
+			!(
+				/** @type {BuildMeta} */ (importedModule.buildMeta).async &&
+				importedModule instanceof getExternalModule()
+			);
 
 		const metaKey = isDeferred ? "deferredImportVarMap" : "importVarMap";
 		let importVarMap = meta[metaKey];
@@ -283,48 +316,63 @@ class HarmonyImportDependency extends ModuleDependency {
 				(exportsType !== "default-with-named" || ids[0] !== "default") &&
 				moduleGraph.isExportProvided(importedModule, ids) === false
 			) {
-				// We are sure that it's not provided
-
-				// Try to provide detailed info in the error message
-				let pos = 0;
-				let exportsInfo = moduleGraph.getExportsInfo(importedModule);
-				while (pos < ids.length && exportsInfo) {
-					const id = ids[pos++];
-					const exportInfo = exportsInfo.getReadOnlyExportInfo(id);
-					if (exportInfo.provided === false) {
-						// We are sure that it's not provided
-						const providedExports = exportsInfo.getProvidedExports();
-						const moreInfo = !Array.isArray(providedExports)
-							? " (possible exports unknown)"
-							: providedExports.length === 0
-								? " (module has no exports)"
-								: ` (possible exports: ${providedExports.join(", ")})`;
-						return [
-							new HarmonyLinkingError(
-								`export ${ids
-									.slice(0, pos)
-									.map((id) => `'${id}'`)
-									.join(".")} ${additionalMessage} was not found in '${
-									this.userRequest
-								}'${moreInfo}`
-							)
-						];
+				const deferredExports = getDeferredExports(importedModule);
+
+				if (
+					deferredExports !== true &&
+					(deferredExports === undefined || !deferredExports.has(ids[0]))
+				) {
+					// We are sure that it's not provided
+
+					// Try to provide detailed info in the error message
+					let pos = 0;
+					let exportsInfo = moduleGraph.getExportsInfo(importedModule);
+					while (pos < ids.length && exportsInfo) {
+						const id = ids[pos++];
+						const exportInfo = exportsInfo.getReadOnlyExportInfo(id);
+						if (exportInfo.provided === false) {
+							// We are sure that it's not provided
+							let providedExports = exportsInfo.getProvidedExports();
+							// only the first level names the imported module itself
+							if (
+								pos === 1 &&
+								deferredExports !== undefined &&
+								Array.isArray(providedExports)
+							) {
+								providedExports = [...providedExports, ...deferredExports];
+							}
+							const moreInfo = !Array.isArray(providedExports)
+								? " (possible exports unknown)"
+								: providedExports.length === 0
+									? " (module has no exports)"
+									: ` (possible exports: ${providedExports.join(", ")})`;
+							return [
+								new HarmonyLinkingError(
+									`export ${ids
+										.slice(0, pos)
+										.map((id) => `'${id}'`)
+										.join(".")} ${additionalMessage} was not found in '${
+										this.userRequest
+									}'${moreInfo}`
+								)
+							];
+						}
+						exportsInfo =
+							/** @type {ExportsInfo} */
+							(exportInfo.getNestedExportsInfo());
 					}
-					exportsInfo =
-						/** @type {ExportsInfo} */
-						(exportInfo.getNestedExportsInfo());
-				}
 
-				// General error message
-				return [
-					new HarmonyLinkingError(
-						`export ${ids
-							.map((id) => `'${id}'`)
-							.join(".")} ${additionalMessage} was not found in '${
-							this.userRequest
-						}'`
-					)
-				];
+					// General error message
+					return [
+						new HarmonyLinkingError(
+							`export ${ids
+								.map((id) => `'${id}'`)
+								.join(".")} ${additionalMessage} was not found in '${
+								this.userRequest
+							}'`
+						)
+					];
+				}
 			}
 		}
 		switch (exportsType) {
@@ -468,8 +516,13 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 		}
 
 		const importStatement = dep.getImportStatement(false, templateContext);
+		// A module deferring itself is already evaluating: awaiting it would probe
+		// the deferred namespace and force the evaluation it must not trigger.
+		const isSelfDeferred =
+			ImportPhaseUtils.isDefer(dep.phase) && referencedModule === module;
 		if (
 			referencedModule &&
+			!isSelfDeferred &&
 			templateContext.moduleGraph.isAsync(referencedModule)
 		) {
 			templateContext.initFragments.push(

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const ImportedBindingAssignmentError = require("../errors/ImportedBindingAssignmentError");
 const WebpackError = require("../errors/WebpackError");
 const getParserHooks = require("../hmr/parserHooks");
 const {
@@ -43,6 +44,7 @@ const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
  * } from "../../declarations/WebpackOptions"
  */
 /** @import Module from "../Module" */
+/** @import { JavascriptModuleBuildInfo } from "../javascript/JavascriptModule" */
 /**
  * @import JavascriptParser, {
  * 	ImportAttributes,
@@ -71,10 +73,24 @@ const EMPTY_ID_RANGES = [];
  * @property {boolean} await
  * @property {ImportAttributes=} attributes
  * @property {ImportPhaseType} phase
+ * @property {boolean} used whether the binding is referenced anywhere
+ * @property {HarmonyImportSideEffectDependency | undefined} dependency the statement's own dependency
  */
 
 const PLUGIN_NAME = "HarmonyImportDependencyParserPlugin";
 
+/**
+ * Records that an import binding is referenced, so it is not reported as an
+ * unused specifier naming a missing export.
+ * @param {HarmonySettings | undefined} settings settings of the referenced tag
+ * @returns {boolean} true when the reference was a harmony import specifier
+ */
+const markUsed = (settings) => {
+	if (!settings) return false;
+	settings.used = true;
+	return true;
+};
+
 /**
  * Gets in operator harmony import info.
  * @param {JavascriptParser} parser the parser
@@ -107,6 +123,7 @@ const getInOperatorHarmonyImportInfo = (parser, left, right) => {
 	if (!settings) {
 		return;
 	}
+	settings.used = true;
 
 	return {
 		leftPart,
@@ -125,7 +142,10 @@ const getInOperatorHarmonyImportInfo = (parser, left, right) => {
 const findImportSpecifier = (parser, node) => {
 	switch (node.type) {
 		case "Identifier":
-			return Boolean(parser.getTagData(node.name, harmonySpecifierTag));
+			return markUsed(
+				/** @type {HarmonySettings | undefined} */
+				(parser.getTagData(node.name, harmonySpecifierTag))
+			);
 		case "UnaryExpression":
 			return findImportSpecifier(
 				parser,
@@ -213,6 +233,35 @@ class HarmonyImportDependencyParserPlugin {
 			this.options.sourceImport
 		);
 
+		// Parsers are reused across modules, so both are reset per program.
+		/** @type {HarmonySettings[]} */
+		const declaredSpecifiers = [];
+		/** @type {HarmonyImportSideEffectDependency | undefined} */
+		let lastSideEffectDependency;
+
+		parser.hooks.program.tap(PLUGIN_NAME, () => {
+			declaredSpecifiers.length = 0;
+			lastSideEffectDependency = undefined;
+		});
+		parser.hooks.finish.tap(PLUGIN_NAME, () => {
+			for (const settings of declaredSpecifiers) {
+				const dependency = settings.dependency;
+				if (dependency === undefined || settings.used) continue;
+				if (dependency.unusedSpecifiers === undefined) {
+					dependency.unusedSpecifiers = {
+						exportPresenceMode: this.exportPresenceMode,
+						specifiers: []
+					};
+				}
+				dependency.unusedSpecifiers.specifiers.push([
+					settings.ids,
+					settings.name
+				]);
+			}
+			declaredSpecifiers.length = 0;
+			lastSideEffectDependency = undefined;
+		});
+
 		/**
 		 * Gets non optional member chain.
 		 * @param {MemberExpression} node member expression
@@ -228,7 +277,10 @@ class HarmonyImportDependencyParserPlugin {
 			const expr = /** @type {Identifier} */ (expression);
 			if (
 				parser.isVariableDefined(expr.name) ||
-				parser.getTagData(expr.name, harmonySpecifierTag)
+				markUsed(
+					/** @type {HarmonySettings | undefined} */
+					(parser.getTagData(expr.name, harmonySpecifierTag))
+				)
 			) {
 				return true;
 			}
@@ -267,6 +319,7 @@ class HarmonyImportDependencyParserPlugin {
 			);
 			sideEffectDep.loc = parser.getLocation(statement);
 			parser.state.module.addDependency(sideEffectDep);
+			lastSideEffectDependency = sideEffectDep;
 			return true;
 		});
 		parser.hooks.importSpecifier.tap(
@@ -274,18 +327,20 @@ class HarmonyImportDependencyParserPlugin {
 			(statement, source, id, name) => {
 				const ids = id === null ? [] : [id];
 				const phase = getImportPhase(parser, statement);
-				parser.tagVariable(
+				const settings = /** @type {HarmonySettings} */ ({
 					name,
-					harmonySpecifierTag,
-					/** @type {HarmonySettings} */ ({
-						name,
-						source,
-						ids,
-						sourceOrder: parser.state.lastHarmonyImportOrder,
-						attributes: getImportAttributes(statement),
-						phase
-					})
-				);
+					source,
+					ids,
+					sourceOrder: parser.state.lastHarmonyImportOrder,
+					attributes: getImportAttributes(statement),
+					phase,
+					used: false,
+					dependency: lastSideEffectDependency
+				});
+				parser.tagVariable(name, harmonySpecifierTag, settings);
+				// The statement's dependency carries them, so a never-referenced
+				// one still resolves; a namespace import names no export.
+				if (ids.length !== 0) declaredSpecifiers.push(settings);
 				return true;
 			}
 		);
@@ -328,16 +383,37 @@ class HarmonyImportDependencyParserPlugin {
 					nameInfo &&
 					nameInfo.rootInfo instanceof VariableInfo &&
 					nameInfo.rootInfo.name &&
-					parser.getTagData(nameInfo.rootInfo.name, harmonySpecifierTag)
+					markUsed(
+						/** @type {HarmonySettings | undefined} */
+						(parser.getTagData(nameInfo.rootInfo.name, harmonySpecifierTag))
+					)
 				) {
 					return true;
 				}
 			}
 		);
+		// Concatenation would turn the binding into a plain local, losing the
+		// getter-only property whose write throws.
+		parser.hooks.assign.for(harmonySpecifierTag).tap(PLUGIN_NAME, (expr) => {
+			const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+			markUsed(settings);
+			/** @type {JavascriptModuleBuildInfo} */
+			(parser.state.module.buildInfo).moduleConcatenationBailout =
+				"assignment to an imported binding";
+			// A named import is written through the namespace's getter-only
+			// property, which throws on its own. A namespace one is the binding
+			// itself, and nothing webpack can emit for it throws, so report it.
+			if (settings.ids.length === 0) {
+				const error = new ImportedBindingAssignmentError(settings.name);
+				error.loc = parser.getLocation(expr);
+				parser.state.module.addError(error);
+			}
+		});
 		parser.hooks.expression
 			.for(harmonySpecifierTag)
 			.tap(PLUGIN_NAME, (expr) => {
 				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				settings.used = true;
 
 				const dep = new HarmonyImportSpecifierDependency(
 					settings.source,
@@ -376,6 +452,7 @@ class HarmonyImportDependencyParserPlugin {
 					const settings =
 						/** @type {HarmonySettings} */
 						(parser.currentTagData);
+					settings.used = true;
 					const nonOptionalMembers = getNonOptionalPart(
 						members,
 						membersOptionals
@@ -431,6 +508,7 @@ class HarmonyImportDependencyParserPlugin {
 					const settings = /** @type {HarmonySettings} */ (
 						parser.currentTagData
 					);
+					settings.used = true;
 					const nonOptionalMembers = getNonOptionalPart(
 						members,
 						membersOptionals
@@ -491,6 +569,7 @@ class HarmonyImportDependencyParserPlugin {
 			.for(harmonySpecifierTag)
 			.tap(PLUGIN_NAME, (expression, members) => {
 				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				settings.used = true;
 				if (!ImportPhaseUtils.isDefer(settings.phase)) return;
 				if (expression.operator !== "=") return;
 				if (members.length !== 1) return;