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

package/lib/dependencies/HarmonyExportSpecifierDependency.js

@@ -8,22 +8,30 @@
 const Dependency = require("../Dependency");
 const { InlinedUsedName } = require("../optimize/InlineExports");
 const makeSerializable = require("../util/makeSerializable");
+const memoize = require("../util/memoize");
 const ExportBindingInitFragment = require("./ExportBindingInitFragment");
 const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
 const NullDependency = require("./NullDependency");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../Dependency").LazyUntil} LazyUntil */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../optimize/InlineExports").InlinedValue} InlinedValue */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import { ExportsSpec, LazyUntil } from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { ConnectionState } from "../ModuleGraphConnection" */
+/** @import { InlinedValue } from "../optimize/InlineExports" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, string, InlinedValue | null | undefined]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string, string, InlinedValue | null | undefined]>} ObjectSerializerContext */
-/** @typedef {import("./HarmonyExportInitFragment").UnusedExports} UnusedExports */
-/** @typedef {import("./HarmonyExportInitFragment").ExportMap} ExportMap */
-/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildInfo} JavascriptModuleBuildInfo */
+/** @import { UnusedExports, ExportMap } from "./HarmonyExportInitFragment" */
+/**
+ * @import {
+ * 	JavascriptModuleBuildInfo
+ * } from "../javascript/JavascriptModule"
+ */
+
+// Required here rather than at the top: the plugin reaches back into the dependencies.
+const getJavascriptModulesPlugin = memoize(() =>
+	require("../javascript/JavascriptModulesPlugin")
+);
 
 class HarmonyExportSpecifierDependency extends NullDependency {
 	/**
@@ -139,10 +147,18 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 	apply(
 		dependency,
 		source,
-		{ module, moduleGraph, initFragments, runtime, concatenationScope }
+		{
+			module,
+			moduleGraph,
+			initFragments,
+			runtime,
+			runtimeTemplate,
+			concatenationScope
+		}
 	) {
 		const dep = /** @type {HarmonyExportSpecifierDependency} */ (dependency);
-		if (concatenationScope) {
+		// a wrapped module's bindings stay inside the wrapper, not in the shared scope
+		if (concatenationScope && !concatenationScope.isWrapped()) {
 			concatenationScope.registerExport(dep.name, dep.id);
 			return;
 		}
@@ -169,6 +185,21 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 			/** @type {import("../Module").BuildInfo} */ (module.buildInfo)
 				.isCircular === false;
 
+		// A library exporting the same bindings natively reads none of them back off the
+		// exports object, so it takes the call over and emits it only where wrapped.
+		const hooks = getJavascriptModulesPlugin().getCompilationHooks(
+			runtimeTemplate.compilation
+		);
+		const onDemand = hooks.onDemandExportsGeneration.isUsed()
+			? (/** @type {string} */ definition, /** @type {boolean} */ placeAtEnd) =>
+					hooks.onDemandExportsGeneration.call(
+						module,
+						runtime,
+						definition,
+						placeAtEnd
+					) === true
+			: undefined;
+
 		if (canUseValueBinding) {
 			initFragments.push(
 				new ExportBindingInitFragment(
@@ -180,7 +211,8 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 							bindingType: "value"
 						}
 					],
-					true
+					true,
+					onDemand
 				)
 			);
 		} else {
@@ -188,7 +220,12 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 			const map = new Map();
 			map.set(used, `/* binding */ ${dep.id}`);
 			initFragments.push(
-				new HarmonyExportInitFragment(module.exportsArgument, map, undefined)
+				new HarmonyExportInitFragment(
+					module.exportsArgument,
+					map,
+					undefined,
+					onDemand
+				)
 			);
 		}
 	}

package/lib/dependencies/HarmonyExports.js

@@ -7,10 +7,13 @@
 
 const RuntimeGlobals = require("../RuntimeGlobals");
 
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildMeta} JavascriptModuleBuildMeta */
-/** @typedef {import("../javascript/JavascriptParser").JavascriptParserState} JavascriptParserState */
+/** @import { BuildInfo } from "../Module" */
+/**
+ * @import {
+ * 	JavascriptModuleBuildMeta
+ * } from "../javascript/JavascriptModule"
+ */
+/** @import { JavascriptParserState } from "../javascript/JavascriptParser" */
 
 /** @type {WeakMap<JavascriptParserState, boolean>} */
 const parserStateExportsState = new WeakMap();

package/lib/dependencies/HarmonyImportDependency.js

@@ -11,25 +11,35 @@ 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");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ExportsInfo")} ExportsInfo */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../errors/WebpackError")} WebpackError */
-/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
-/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+const getExternalModule = memoize(() => require("../ExternalModule"));
+
+/** @import { ReplaceSource } from "webpack-sources" */
+/**
+ * @import {
+ * 	JavascriptParserOptions
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import { ReferencedExports } from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import ExportsInfo from "../ExportsInfo" */
+/** @import Module, { BuildMeta } from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import WebpackError from "../errors/WebpackError" */
+/** @import { ImportAttributes } from "../javascript/JavascriptParser" */
+/** @import { ImportPhaseType } from "./ImportPhase" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 /** @typedef {0 | 1 | 2 | 3} ExportPresenceMode */
 
@@ -90,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.
@@ -135,9 +170,10 @@ class HarmonyImportDependency extends ModuleDependency {
 
 	/**
 	 * Returns true if this dependency can be concatenated
+	 * @param {boolean} concatenateCommonJsModules whether optimization.concatenateModules.commonjs is enabled
 	 * @returns {boolean} true if this dependency can be concatenated
 	 */
-	canConcatenate() {
+	canConcatenate(concatenateCommonJsModules) {
 		return true;
 	}
 
@@ -177,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];
@@ -275,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) {
@@ -384,8 +440,6 @@ class HarmonyImportDependency extends ModuleDependency {
 	}
 }
 
-module.exports = HarmonyImportDependency;
-
 /** @type {WeakMap<Module, WeakMap<Module, RuntimeSpec | boolean>>} */
 const importEmittedMap = new WeakMap();
 
@@ -462,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(
@@ -524,5 +583,7 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 	}
 };
 
-module.exports.ExportPresenceModes = ExportPresenceModes;
-module.exports.getNonOptionalPart = getNonOptionalPart;
+HarmonyImportDependency.ExportPresenceModes = ExportPresenceModes;
+HarmonyImportDependency.getNonOptionalPart = getNonOptionalPart;
+
+module.exports = HarmonyImportDependency;

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -5,8 +5,9 @@
 
 "use strict";
 
-const HotModuleReplacementPlugin = require("../HotModuleReplacementPlugin");
+const ImportedBindingAssignmentError = require("../errors/ImportedBindingAssignmentError");
 const WebpackError = require("../errors/WebpackError");
+const getParserHooks = require("../hmr/parserHooks");
 const {
 	VariableInfo,
 	getImportAttributes
@@ -29,25 +30,31 @@ const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDepe
 const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
 const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
 
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("estree").PrivateIdentifier} PrivateIdentifier */
-/** @typedef {import("estree").Identifier} Identifier */
-/** @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 */
-/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
-/** @typedef {import("../javascript/JavascriptParser").ImportDeclaration} ImportDeclaration */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../javascript/JavascriptParser").Members} Members */
-/** @typedef {import("../javascript/JavascriptParser").MembersOptionals} MembersOptionals */
-/** @typedef {import("./HarmonyImportDependency").Ids} Ids */
-/** @typedef {import("./HarmonyImportDependency").ExportPresenceMode} ExportPresenceMode */
-/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
-/** @typedef {import("./HarmonyImportGuard").GuardFrame} GuardFrame */
+/**
+ * @import {
+ * 	Expression,
+ * 	PrivateIdentifier,
+ * 	Identifier,
+ * 	MemberExpression
+ * } from "estree"
+ */
+/**
+ * @import {
+ * 	JavascriptParserOptions
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Module from "../Module" */
+/** @import { JavascriptModuleBuildInfo } from "../javascript/JavascriptModule" */
+/**
+ * @import JavascriptParser, {
+ * 	ImportAttributes,
+ * 	Range,
+ * 	Members
+ * } from "../javascript/JavascriptParser"
+ */
+/** @import { Ids, ExportPresenceMode } from "./HarmonyImportDependency" */
+/** @import { ImportPhaseType } from "./ImportPhase" */
+/** @import { GuardFrame } from "./HarmonyImportGuard" */
 
 const harmonySpecifierTag = Symbol("harmony import");
 
@@ -66,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
@@ -102,6 +123,7 @@ const getInOperatorHarmonyImportInfo = (parser, left, right) => {
 	if (!settings) {
 		return;
 	}
+	settings.used = true;
 
 	return {
 		leftPart,
@@ -120,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,
@@ -147,7 +172,7 @@ const findImportSpecifier = (parser, node) => {
 	}
 };
 
-module.exports = class HarmonyImportDependencyParserPlugin {
+class HarmonyImportDependencyParserPlugin {
 	/**
 	 * Creates an instance of HarmonyImportDependencyParserPlugin.
 	 * @param {JavascriptParserOptions} options options
@@ -208,6 +233,35 @@ module.exports = 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
@@ -223,7 +277,10 @@ module.exports = 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;
 			}
@@ -262,6 +319,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			);
 			sideEffectDep.loc = parser.getLocation(statement);
 			parser.state.module.addDependency(sideEffectDep);
+			lastSideEffectDependency = sideEffectDep;
 			return true;
 		});
 		parser.hooks.importSpecifier.tap(
@@ -269,18 +327,20 @@ module.exports = 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;
 			}
 		);
@@ -323,16 +383,37 @@ module.exports = 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,
@@ -371,6 +452,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					const settings =
 						/** @type {HarmonySettings} */
 						(parser.currentTagData);
+					settings.used = true;
 					const nonOptionalMembers = getNonOptionalPart(
 						members,
 						membersOptionals
@@ -426,6 +508,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					const settings = /** @type {HarmonySettings} */ (
 						parser.currentTagData
 					);
+					settings.used = true;
 					const nonOptionalMembers = getNonOptionalPart(
 						members,
 						membersOptionals
@@ -486,6 +569,7 @@ module.exports = 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;
@@ -496,7 +580,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				return true;
 			});
 		const { hotAcceptCallback, hotAcceptWithoutCallback } =
-			HotModuleReplacementPlugin.getParserHooks(parser);
+			getParserHooks(parser);
 		hotAcceptCallback.tap(PLUGIN_NAME, (expr, requests) => {
 			if (!HarmonyExports.isEnabled(parser.state)) {
 				// This is not a harmony module, skip it
@@ -567,6 +651,8 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			return { consequent, alternate };
 		});
 	}
-};
+}
+
+HarmonyImportDependencyParserPlugin.harmonySpecifierTag = harmonySpecifierTag;
 
-module.exports.harmonySpecifierTag = harmonySpecifierTag;
+module.exports = HarmonyImportDependencyParserPlugin;