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

package/lib/dependencies/HarmonyImportBareSideEffectDependency.js

@@ -0,0 +1,59 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const { ASSET_TYPE } = require("../ModuleSourceTypeConstants");
+const makeSerializable = require("../util/makeSerializable");
+const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
+
+/** @import Module from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { GetConditionFn } from "../Dependency" */
+
+/**
+ * Whether a module is emitted as a file of its own, asked of the module so a
+ * plugin emitting the same way is treated alike. `buildInfo.filename` cannot
+ * serve here: generation sets it long after a connection has to know whether
+ * it is active.
+ * @param {Module} module the module to look up
+ * @returns {boolean} true when it emits a file
+ */
+const emitsOwnFile = (module) => module.getSourceTypes().has(ASSET_TYPE);
+
+/**
+ * An `import "..."` that declares no binding. It is a separate class rather
+ * than a flag so it costs nothing per instance, and the bound form — much the
+ * more common one — keeps the base class and its inline caches untouched.
+ */
+class HarmonyImportBareSideEffectDependency extends HarmonyImportSideEffectDependency {
+	/**
+	 * Returns function to determine if the connection is active.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return (connection) => {
+			const refModule = connection.resolvedModule;
+
+			if (!refModule) return true;
+			// Nothing reads the module, so emitting its file is the only thing the
+			// import can have been written for.
+			if (emitsOwnFile(refModule)) return true;
+
+			return refModule.getSideEffectsConnectionState(moduleGraph);
+		};
+	}
+}
+
+makeSerializable(
+	HarmonyImportBareSideEffectDependency,
+	"webpack/lib/dependencies/HarmonyImportBareSideEffectDependency"
+);
+
+HarmonyImportBareSideEffectDependency.Template =
+	HarmonyImportSideEffectDependency.Template;
+
+module.exports = HarmonyImportBareSideEffectDependency;

package/lib/dependencies/HarmonyImportDependency.js

@@ -114,7 +114,12 @@ const getDeferredExports = (module) => {
 	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 (
+			typeof dep.getLazyUntil !== "function" ||
+			typeof dep.isLazy !== "function"
+		) {
+			continue;
+		}
 		if (!dep.isLazy()) continue;
 		const until = dep.getLazyUntil();
 		if (until === Dependency.LAZY_UNTIL_FALLBACK) return true;

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -18,6 +18,7 @@ const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
 const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
 const HarmonyEvaluatedImportSpecifierDependency = require("./HarmonyEvaluatedImportSpecifierDependency");
 const HarmonyExports = require("./HarmonyExports");
+const HarmonyImportBareSideEffectDependency = require("./HarmonyImportBareSideEffectDependency");
 const {
 	ExportPresenceModes,
 	getNonOptionalPart
@@ -35,7 +36,9 @@ const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
  * 	Expression,
  * 	PrivateIdentifier,
  * 	Identifier,
- * 	MemberExpression
+ * 	MemberExpression,
+ * 	Pattern,
+ * 	UpdateExpression
  * } from "estree"
  */
 /**
@@ -49,7 +52,8 @@ const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
  * @import JavascriptParser, {
  * 	ImportAttributes,
  * 	Range,
- * 	Members
+ * 	Members,
+ * 	WriteStatement
  * } from "../javascript/JavascriptParser"
  */
 /** @import { Ids, ExportPresenceMode } from "./HarmonyImportDependency" */
@@ -233,15 +237,18 @@ class HarmonyImportDependencyParserPlugin {
 			this.options.sourceImport
 		);
 
-		// Parsers are reused across modules, so both are reset per program.
+		// Parsers are reused across modules, so all three are reset per program.
 		/** @type {HarmonySettings[]} */
 		const declaredSpecifiers = [];
 		/** @type {HarmonyImportSideEffectDependency | undefined} */
 		let lastSideEffectDependency;
+		/** @type {Identifier | MemberExpression | undefined} */
+		let assignmentTarget;
 
 		parser.hooks.program.tap(PLUGIN_NAME, () => {
 			declaredSpecifiers.length = 0;
 			lastSideEffectDependency = undefined;
+			assignmentTarget = undefined;
 		});
 		parser.hooks.finish.tap(PLUGIN_NAME, () => {
 			for (const settings of declaredSpecifiers) {
@@ -260,6 +267,7 @@ class HarmonyImportDependencyParserPlugin {
 			}
 			declaredSpecifiers.length = 0;
 			lastSideEffectDependency = undefined;
+			assignmentTarget = undefined;
 		});
 
 		/**
@@ -311,7 +319,13 @@ class HarmonyImportDependencyParserPlugin {
 				parser.state.current.addError(error);
 			}
 
-			const sideEffectDep = new HarmonyImportSideEffectDependency(
+			// A declaration binding nothing was written for what importing produces,
+			// which for a module emitting its own file is that file.
+			const SideEffectDependency =
+				statement.specifiers.length === 0
+					? HarmonyImportBareSideEffectDependency
+					: HarmonyImportSideEffectDependency;
+			const sideEffectDep = new SideEffectDependency(
 				/** @type {string} */ (source),
 				parser.state.lastHarmonyImportOrder,
 				phase,
@@ -392,14 +406,48 @@ class HarmonyImportDependencyParserPlugin {
 				}
 			}
 		);
-		// 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);
+		/**
+		 * The reference a write lands on, which is a pattern for a
+		 * destructuring write.
+		 * @param {WriteStatement} node the construct performing the write
+		 * @returns {Pattern | MemberExpression} the written reference
+		 */
+		const writeTargetOf = (node) =>
+			/** @type {Pattern | MemberExpression} */ (
+				node.type === "UpdateExpression" ? node.argument : node.left
+			);
+
+		/**
+		 * Whether a member write lands on the namespace object itself, which is
+		 * read-only. A property of an imported object is an ordinary write.
+		 * @param {HarmonySettings} settings the specifier's settings
+		 * @param {Members} members the member chain
+		 * @returns {boolean} true when the write targets a namespace member
+		 */
+		const isNamespaceMemberWrite = (settings, members) =>
+			settings.ids.length === 0 && members.length === 1;
+
+		/**
+		 * Keeps the module whole, for a write whose reference the output has no
+		 * way to flag.
+		 * @returns {void}
+		 */
+		const bailOutOfConcatenation = () => {
 			/** @type {JavascriptModuleBuildInfo} */
 			(parser.state.module.buildInfo).moduleConcatenationBailout =
 				"assignment to an imported binding";
+		};
+
+		/**
+		 * Records the write target of an assignment or update to an imported
+		 * binding, so the reference walked next renders as a throwing write.
+		 * @param {WriteStatement} expr the write
+		 * @param {Identifier | MemberExpression | undefined} target the written reference, if any
+		 * @returns {void}
+		 */
+		const markImportedBindingWrite = (expr, target) => {
+			const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+			markUsed(settings);
 			// 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.
@@ -407,8 +455,48 @@ class HarmonyImportDependencyParserPlugin {
 				const error = new ImportedBindingAssignmentError(settings.name);
 				error.loc = parser.getLocation(expr);
 				parser.state.module.addError(error);
+			} else if (target) {
+				assignmentTarget = target;
+			} else {
+				// A destructuring target emits no reference to flag, so the whole
+				// module stays out of concatenation.
+				bailOutOfConcatenation();
 			}
+		};
+
+		parser.hooks.assign.for(harmonySpecifierTag).tap(PLUGIN_NAME, (expr) => {
+			markImportedBindingWrite(
+				expr,
+				expr.left.type === "Identifier" ? expr.left : undefined
+			);
+		});
+		parser.hooks.write.for(harmonySpecifierTag).tap(PLUGIN_NAME, (node) => {
+			const written = writeTargetOf(node);
+			const target =
+				written.type === "Identifier"
+					? /** @type {Identifier} */ (written)
+					: undefined;
+			markImportedBindingWrite(node, target);
+			// A loop's binding walks nothing on its own, so the reference the
+			// write renders as has to be walked here to exist at all.
+			if (!target || node.type === "UpdateExpression") return;
+			parser.walkExpression(target);
+			return true;
 		});
+		// A namespace member is written through the reference its member chain
+		// emits, so both write forms flag that reference rather than the binding.
+		parser.hooks.writeMemberChain
+			.for(harmonySpecifierTag)
+			.tap(PLUGIN_NAME, (node, members) => {
+				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				if (!isNamespaceMemberWrite(settings, members)) return;
+				const written = writeTargetOf(node);
+				if (written.type === "MemberExpression") {
+					assignmentTarget = written;
+				} else {
+					bailOutOfConcatenation();
+				}
+			});
 		parser.hooks.expression
 			.for(harmonySpecifierTag)
 			.tap(PLUGIN_NAME, (expr) => {
@@ -436,6 +524,10 @@ class HarmonyImportDependencyParserPlugin {
 				);
 				dep.loc = parser.getLocation(expr);
 				dep.call = parser.scope.inTaggedTemplateTag;
+				if (assignmentTarget === expr) {
+					dep.assignment = true;
+					assignmentTarget = undefined;
+				}
 				parser.state.module.addDependency(dep);
 				attachDependencyGuards(parser, dep);
 				getInnerGraphUtils(parser.state.compilation).onUsage(
@@ -489,6 +581,10 @@ class HarmonyImportDependencyParserPlugin {
 						(expr.range)[0]
 					);
 					dep.loc = parser.getLocation(expr);
+					if (assignmentTarget === expression) {
+						dep.assignment = true;
+						assignmentTarget = undefined;
+					}
 					parser.state.module.addDependency(dep);
 					attachDependencyGuards(parser, dep);
 					getInnerGraphUtils(parser.state.compilation).onUsage(
@@ -557,19 +653,17 @@ class HarmonyImportDependencyParserPlugin {
 					return true;
 				}
 			);
-		// Per the TC39 import-defer spec, [[Set]] on a Module Namespace
-		// Exotic Object returns false without triggering evaluation. The
-		// default expressionMemberChain path produces `<importVar>.a.foo`
-		// whose `.a` getter eagerly requires (and thus evaluates) the
-		// deferred module. For top-level `ns.foo = value`, walk only the
-		// bare `ns` identifier so it gets replaced with the deferred
-		// namespace proxy (whose set trap returns false), and leave the
-		// `.foo = value` part as plain code.
+		// `[[Set]]` on a Module Namespace returns false without evaluating, yet the
+		// member-chain path emits `<importVar>.a.foo`, whose getter evaluates. So
+		// only the bare `ns` is walked, leaving `.foo = value` as plain code.
 		parser.hooks.assignMemberChain
 			.for(harmonySpecifierTag)
 			.tap(PLUGIN_NAME, (expression, members) => {
 				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
 				settings.used = true;
+				if (isNamespaceMemberWrite(settings, members)) {
+					assignmentTarget = /** @type {MemberExpression} */ (expression.left);
+				}
 				if (!ImportPhaseUtils.isDefer(settings.phase)) return;
 				if (expression.operator !== "=") return;
 				if (members.length !== 1) return;

package/lib/dependencies/HarmonyImportSideEffectDependency.js

@@ -226,10 +226,9 @@ HarmonyImportSideEffectDependency.Template = class HarmonyImportSideEffectDepend
 				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.
+				// A hoisted body cannot be deferred, so its imports evaluate in their own
+				// slots; calling from here would run them after everything hoisted in
+				// between. Eagerness stops at one level, generation order allowing no more.
 				if (concatenationScope.isWrapped()) {
 					initFragments.push(
 						new InitFragment(

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -26,10 +26,11 @@ const HarmonyImportGuard = require("./HarmonyImportGuard");
 const { ImportPhaseUtils } = require("./ImportPhase");
 
 /** @import { ReplaceSource } from "webpack-sources" */
-/** @import { GetConditionFn, ReferencedExports } from "../Dependency" */
+/** @import { GetConditionFn, ReferencedExports, UpdateHashContext } from "../Dependency" */
 /** @import { DependencyTemplateContext } from "../DependencyTemplate" */
 /** @import Module, { BuildMeta } from "../Module" */
 /** @import ModuleGraph from "../ModuleGraph" */
+/** @import Hash from "../util/Hash" */
 /**
  * @import ModuleGraphConnection, {
  * 	ConnectionState
@@ -133,6 +134,8 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		this.referencedPropertiesInDestructuring = undefined;
 		/** @type {DependencyGuard[] | undefined} */
 		this.branchGuards = undefined;
+		/** @type {undefined | boolean} this reference is an assignment target */
+		this.assignment = undefined;
 	}
 
 	// TODO webpack 6 remove
@@ -262,6 +265,28 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		return condition;
 	}
 
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		const { chunkGraph, runtime } = context;
+		const moduleGraph = chunkGraph.moduleGraph;
+		if (!isInlineExportsEnabled(moduleGraph)) return;
+		const module = moduleGraph.getModule(this);
+		if (!module || !isInlineEnabled(module)) return;
+		const ids = this.getIds(moduleGraph);
+		if (ids.length === 0) return;
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+		if (!exportsInfo.hasInlinedUsedName(ids, runtime)) return;
+		const usedName = exportsInfo.getUsedName(ids, runtime);
+		if (usedName instanceof InlinedUsedName) {
+			usedName.updateHash(hash);
+		}
+	}
+
 	/**
 	 * Gets module evaluation side effects state.
 	 * @param {ModuleGraph} moduleGraph the module graph
@@ -356,8 +381,9 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 					{
 						name: ids,
 						canMangle: true,
-						// Need access the export value to trigger side effects for deferred module
-						canInline: !ImportPhaseUtils.isDefer(this.phase)
+						// Need access the export value to trigger side effects for deferred module.
+						// An inlined literal cannot be an assignment target at all.
+						canInline: !this.assignment && !ImportPhaseUtils.isDefer(this.phase)
 					}
 				]
 			: Dependency.EXPORTS_OBJECT_REFERENCED;
@@ -450,6 +476,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		write(this.usedByExports);
 		write(this.referencedPropertiesInDestructuring);
 		write(this.branchGuards);
+		write(this.assignment);
 		super.serialize(context);
 	}
 
@@ -472,6 +499,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		this.usedByExports = read();
 		this.referencedPropertiesInDestructuring = read();
 		this.branchGuards = read();
+		this.assignment = read();
 		super.deserialize(context);
 	}
 }
@@ -654,6 +682,15 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 						deferredImport: ImportPhaseUtils.isDefer(dep.phase)
 					}
 				);
+				// Concatenation merges the binding into a plain local a write would
+				// succeed against. Routing the write at a getter-only property of a
+				// throwaway object restores the TypeError the namespace gave it.
+				if (dep.assignment) {
+					// the local binding, the one name here an export is free not to
+					// spell as an identifier: `import { "a-b" as ab }`
+					const holder = `{ get ${dep.name}() { return ${exportExpr}; } }`;
+					exportExpr = `${dep.asiSafe ? "" : ";"}(${holder}).${dep.name}`;
+				}
 			}
 		} else {
 			super.apply(dep, source, templateContext);

package/lib/dependencies/HarmonyModulesPlugin.js

@@ -20,6 +20,7 @@ const HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDepe
 const HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency");
 const HarmonyExportImportedSpecifierDependency = require("./HarmonyExportImportedSpecifierDependency");
 const HarmonyExportSpecifierDependency = require("./HarmonyExportSpecifierDependency");
+const HarmonyImportBareSideEffectDependency = require("./HarmonyImportBareSideEffectDependency");
 const HarmonyImportDependencyParserPlugin = require("./HarmonyImportDependencyParserPlugin");
 const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
 const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
@@ -34,6 +35,7 @@ const TopLevelAwaitDependency = require("./TopLevelAwaitDependency");
  */
 /** @import Compiler from "../Compiler" */
 /** @import Parser from "../javascript/JavascriptParser" */
+/** @import { BuildInfo } from "../Module" */
 
 /**
  * Defines the harmony modules plugin options type used by this module.
@@ -81,6 +83,15 @@ class HarmonyModulesPlugin {
 					new HarmonyImportSideEffectDependency.Template()
 				);
 
+				compilation.dependencyFactories.set(
+					HarmonyImportBareSideEffectDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					HarmonyImportBareSideEffectDependency,
+					new HarmonyImportBareSideEffectDependency.Template()
+				);
+
 				compilation.dependencyFactories.set(
 					HarmonyImportSpecifierDependency,
 					normalModuleFactory
@@ -149,6 +160,15 @@ class HarmonyModulesPlugin {
 						return;
 					}
 
+					if (parserOptions.specNamespaceObject) {
+						// Recorded on the module, because an importer asks the module it
+						// imports whether its namespace is a spec exotic object.
+						parser.hooks.program.tap(PLUGIN_NAME, () => {
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo).specNamespaceObject = true;
+						});
+					}
+
 					new HarmonyDetectionParserPlugin().apply(parser);
 					new HarmonyImportDependencyParserPlugin(parserOptions).apply(parser);
 					new HarmonyExportDependencyParserPlugin(parserOptions).apply(parser);