@depup/webpack 5.106.0-depup.0 → 5.109.0-depup.0

package/lib/dependencies/HarmonyDetectionParserPlugin.js

@@ -5,23 +5,58 @@
 
 "use strict";
 
-const EnvironmentNotSupportAsyncWarning = require("../EnvironmentNotSupportAsyncWarning");
 const { JAVASCRIPT_MODULE_TYPE_ESM } = require("../ModuleTypeConstants");
+const EnvironmentNotSupportAsyncWarning = require("../errors/EnvironmentNotSupportAsyncWarning");
 const DynamicExports = require("./DynamicExports");
 const HarmonyCompatibilityDependency = require("./HarmonyCompatibilityDependency");
 const HarmonyExports = require("./HarmonyExports");
+const {
+	IMPORT_META_NAMES,
+	IMPORT_META_STAGE_ESM_DETECTION
+} = require("./ImportMetaPlugin");
+const TopLevelAwaitDependency = require("./TopLevelAwaitDependency");
 
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
 const PLUGIN_NAME = "HarmonyDetectionParserPlugin";
 
 module.exports = class HarmonyDetectionParserPlugin {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
 	apply(parser) {
+		// `import.meta`/top-level `await` only parse as modules, so their presence
+		// alone marks the module as ESM (matching Node.js syntax detection).
+		/**
+		 * @param {boolean} isStrictHarmony strict harmony mode should be enabled
+		 * @returns {void}
+		 */
+		const enableHarmony = (isStrictHarmony) => {
+			if (HarmonyExports.isEnabled(parser.state)) return;
+			const module = parser.state.module;
+			const compatDep = new HarmonyCompatibilityDependency();
+			compatDep.loc = {
+				start: {
+					line: -1,
+					column: 0
+				},
+				end: {
+					line: -1,
+					column: 0
+				},
+				index: -3
+			};
+			module.addPresentationalDependency(compatDep);
+			DynamicExports.bailout(parser.state);
+			HarmonyExports.enable(parser.state, isStrictHarmony);
+			parser.scope.isStrict = true;
+		};
+
 		parser.hooks.program.tap(PLUGIN_NAME, (ast) => {
 			const isStrictHarmony =
 				parser.state.module.type === JAVASCRIPT_MODULE_TYPE_ESM;
@@ -35,43 +70,65 @@ module.exports = class HarmonyDetectionParserPlugin {
 						statement.type === "ExportAllDeclaration"
 				);
 			if (isHarmony) {
-				const module = parser.state.module;
-				const compatDep = new HarmonyCompatibilityDependency();
-				compatDep.loc = {
-					start: {
-						line: -1,
-						column: 0
-					},
-					end: {
-						line: -1,
-						column: 0
-					},
-					index: -3
-				};
-				module.addPresentationalDependency(compatDep);
-				DynamicExports.bailout(parser.state);
-				HarmonyExports.enable(parser.state, isStrictHarmony);
-				parser.scope.isStrict = true;
+				enableHarmony(isStrictHarmony);
 			}
 		});
 
-		parser.hooks.topLevelAwait.tap(PLUGIN_NAME, () => {
+		parser.hooks.topLevelAwait.tap(PLUGIN_NAME, (node) => {
 			const module = parser.state.module;
-			if (!HarmonyExports.isEnabled(parser.state)) {
-				throw new Error(
-					"Top-level-await is only supported in EcmaScript Modules"
-				);
-			}
+			enableHarmony(false);
 			/** @type {BuildMeta} */
 			(module.buildMeta).async = true;
-			EnvironmentNotSupportAsyncWarning.check(
-				module,
-				parser.state.compilation.runtimeTemplate,
-				"topLevelAwait"
-			);
+			const buildInfo = /** @type {BuildInfo} */ (module.buildInfo);
+			if (node.type === "AwaitExpression") {
+				// Record for a possible `await` -> `(yield …)` rewrite when the module
+				// is lowered to a generator (target without `async`/`await`).
+				module.addPresentationalDependency(
+					new TopLevelAwaitDependency(
+						/** @type {Range} */ (node.range),
+						/** @type {Range} */ (node.argument.range)
+					)
+				);
+			} else {
+				// `for await…of` can't be expressed as a generator; never lower it.
+				buildInfo.usesTopLevelAwaitForOf = true;
+			}
+			const { runtimeTemplate } = parser.state.compilation;
+			if (
+				!runtimeTemplate.supportsAsyncFunction() &&
+				(!runtimeTemplate.supportsGenerator() ||
+					buildInfo.usesTopLevelAwaitForOf)
+			) {
+				module.addWarning(
+					new EnvironmentNotSupportAsyncWarning(module, "topLevelAwait")
+				);
+			}
 		});
 
+		// Using `import.meta` only parses as a module, so it marks the module ESM.
+		// Non-bailing; staged before the bailing DefinePlugin and ImportMetaPlugin
+		// replacement taps so it observes every access; unknown members go
+		// through `unhandledExpressionMemberChain`.
+		const onImportMeta = () => {
+			enableHarmony(false);
+		};
+		const earlyTapOptions = {
+			name: PLUGIN_NAME,
+			stage: IMPORT_META_STAGE_ESM_DETECTION
+		};
+		for (const name of IMPORT_META_NAMES) {
+			parser.hooks.expression.for(name).tap(earlyTapOptions, onImportMeta);
+			parser.hooks.typeof.for(name).tap(earlyTapOptions, onImportMeta);
+		}
+		parser.hooks.expressionMemberChain
+			.for("import.meta")
+			.tap(earlyTapOptions, onImportMeta);
+		parser.hooks.unhandledExpressionMemberChain
+			.for("import.meta")
+			.tap(earlyTapOptions, onImportMeta);
+
 		/**
+		 * Returns true if in harmony.
 		 * @returns {boolean | undefined} true if in harmony
 		 */
 		const skipInHarmony = () => {
@@ -81,6 +138,7 @@ module.exports = class HarmonyDetectionParserPlugin {
 		};
 
 		/**
+		 * Returns null if in harmony.
 		 * @returns {null | undefined} null if in harmony
 		 */
 		const nullInHarmony = () => {
@@ -89,6 +147,19 @@ module.exports = class HarmonyDetectionParserPlugin {
 			}
 		};
 
+		/**
+		 * Walks call arguments so import bindings used inside callbacks are
+		 * still tracked, then skips default AMD/CommonJS handling.
+		 * @param {import("estree").CallExpression} expr call expression
+		 * @returns {boolean | undefined} true if in harmony
+		 */
+		const walkArgumentsAndSkipInHarmony = (expr) => {
+			if (HarmonyExports.isEnabled(parser.state)) {
+				if (expr.arguments) parser.walkExpressions(expr.arguments);
+				return true;
+			}
+		};
+
 		const nonHarmonyIdentifiers = ["define", "exports"];
 		for (const identifier of nonHarmonyIdentifiers) {
 			parser.hooks.evaluateTypeof
@@ -97,7 +168,14 @@ module.exports = class HarmonyDetectionParserPlugin {
 			parser.hooks.typeof.for(identifier).tap(PLUGIN_NAME, skipInHarmony);
 			parser.hooks.evaluate.for(identifier).tap(PLUGIN_NAME, nullInHarmony);
 			parser.hooks.expression.for(identifier).tap(PLUGIN_NAME, skipInHarmony);
-			parser.hooks.call.for(identifier).tap(PLUGIN_NAME, skipInHarmony);
+			parser.hooks.call
+				.for(identifier)
+				.tap(
+					PLUGIN_NAME,
+					identifier === "define"
+						? walkArgumentsAndSkipInHarmony
+						: skipInHarmony
+				);
 		}
 	}
 };

package/lib/dependencies/HarmonyEvaluatedImportSpecifierDependency.js

@@ -5,6 +5,10 @@
 
 "use strict";
 
+const { InlinedUsedName } = require("../optimize/InlineExports");
+const {
+	getDependencyUsedByExportsCondition
+} = require("../optimize/InnerGraph");
 const makeSerializable = require("../util/makeSerializable");
 const { ExportPresenceModes } = require("./HarmonyImportDependency");
 const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
@@ -12,13 +16,15 @@ const { ImportPhase } = require("./ImportPhase");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<string[]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<string[]>} ObjectSerializerContext */
 /** @typedef {import("./HarmonyImportDependency").Ids} Ids */
 
 /**
@@ -30,6 +36,7 @@ const { ImportPhase } = require("./ImportPhase");
  */
 class HarmonyEvaluatedImportSpecifierDependency extends HarmonyImportSpecifierDependency {
 	/**
+	 * Creates an instance of HarmonyEvaluatedImportSpecifierDependency.
 	 * @param {string} request the request string
 	 * @param {number} sourceOrder source order
 	 * @param {Ids} ids ids
@@ -50,6 +57,7 @@ class HarmonyEvaluatedImportSpecifierDependency extends HarmonyImportSpecifierDe
 			attributes,
 			[]
 		);
+		/** @type {string} */
 		this.operator = operator;
 	}
 
@@ -58,6 +66,18 @@ class HarmonyEvaluatedImportSpecifierDependency extends HarmonyImportSpecifierDe
 	}
 
 	/**
+	 * 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) {
+		// Existence check is independent of inlining; skip the base class's
+		// inline-sensitivity, which would wrongly deactivate the connection.
+		return getDependencyUsedByExportsCondition(this, moduleGraph);
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
@@ -67,6 +87,7 @@ class HarmonyEvaluatedImportSpecifierDependency extends HarmonyImportSpecifierDe
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
@@ -85,6 +106,7 @@ HarmonyEvaluatedImportSpecifierDependency.Template = class HarmonyEvaluatedImpor
 	HarmonyImportSpecifierDependency.Template
 ) {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified
 	 * @param {DependencyTemplateContext} templateContext the context object
@@ -145,6 +167,14 @@ HarmonyEvaluatedImportSpecifierDependency.Template = class HarmonyEvaluatedImpor
 		} else {
 			const usedName = exportsInfo.getUsedName(ids, runtime);
 
+			if (usedName instanceof InlinedUsedName) {
+				// Inlined exports only work with ESM export dependency
+				// which only existed in modules with `namespace` exportsType.
+				throw new Error(
+					"Evaluated import specifier dependency has inlined export name: This should not happen"
+				);
+			}
+
 			const code = this._getCodeForIds(
 				dep,
 				source,

package/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -6,9 +6,11 @@
 "use strict";
 
 const CompatibilityPlugin = require("../CompatibilityPlugin");
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
 const { getImportAttributes } = require("../javascript/JavascriptParser");
-const InnerGraph = require("../optimize/InnerGraph");
+const { CONST_BINDING_TAG } = require("../optimize/ConstExportsPlugin");
+const { toInlinedValue } = require("../optimize/InlineExports");
+const { getInnerGraphUtils } = require("../optimize/InnerGraph");
 const ConstDependency = require("./ConstDependency");
 const HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDependency");
 const HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency");
@@ -21,6 +23,7 @@ const {
 const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
 const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
 
+/** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
@@ -36,9 +39,11 @@ const PLUGIN_NAME = "HarmonyExportDependencyParserPlugin";
 
 module.exports = class HarmonyExportDependencyParserPlugin {
 	/**
+	 * Creates an instance of HarmonyExportDependencyParserPlugin.
 	 * @param {JavascriptParserOptions} options options
 	 */
 	constructor(options) {
+		/** @type {JavascriptParserOptions} */
 		this.options = options;
 		this.exportPresenceMode = ExportPresenceModes.resolveFromOptions(
 			options.reexportExportsPresence,
@@ -47,6 +52,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 	}
 
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
@@ -64,10 +70,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 				),
 				/** @type {Range} */ (statement.range)
 			);
-			dep.loc = Object.create(
-				/** @type {DependencyLocation} */ (statement.loc)
-			);
-			dep.loc.index = -1;
+			dep.setLocWithIndex(parser.getLocation(statement), -1);
 			parser.state.module.addPresentationalDependency(dep);
 			return true;
 		});
@@ -78,8 +81,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 				"",
 				/** @type {Range} */ (statement.range)
 			);
-			clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
-			clearDep.loc.index = -1;
+			clearDep.setLocWithIndex(parser.getLocation(statement), -1);
 			parser.state.module.addPresentationalDependency(clearDep);
 
 			const phase = getImportPhase(parser, statement);
@@ -87,7 +89,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 				const error = new WebpackError(
 					"Deferred re-export (`export defer * as namespace from '...'`) is not a part of the Import Defer proposal.\nUse the following code instead:\n    import defer * as namespace from '...';\n    export { namespace };"
 				);
-				error.loc = statement.loc || undefined;
+				error.loc = parser.getLocation(statement) || undefined;
 				parser.state.current.addError(error);
 			}
 			const sideEffectDep = new HarmonyImportSideEffectDependency(
@@ -96,10 +98,12 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 				phase,
 				getImportAttributes(statement)
 			);
-			sideEffectDep.loc = Object.create(
-				/** @type {DependencyLocation} */ (statement.loc)
-			);
-			sideEffectDep.loc.index = -1;
+			sideEffectDep.setLocWithIndex(parser.getLocation(statement), -1);
+			// lazy barrel: defer at parse time when the importing module is side-effect-free
+			const moduleFactoryMeta = parser.state.module.factoryMeta;
+			if (moduleFactoryMeta !== undefined && moduleFactoryMeta.sideEffectFree) {
+				sideEffectDep.setLazy(true);
+			}
 			parser.state.current.addDependency(sideEffectDep);
 			return true;
 		});
@@ -108,6 +112,11 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 			const exprRange = /** @type {Range} */ (node.range);
 			const statementRange = /** @type {Range} */ (statement.range);
 			const comments = parser.getComments([statementRange[0], exprRange[0]]);
+			const constValue = node.type.endsWith("Declaration")
+				? undefined
+				: toInlinedValue(
+						parser.evaluateExpression(/** @type {Expression} */ (node))
+					);
 			const dep = new HarmonyExportExpressionDependency(
 				exprRange,
 				statementRange,
@@ -139,21 +148,20 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 								} `,
 								suffix: `(${node.params.length > 0 ? "" : ") "}`
 							}
-						: undefined
+						: undefined,
+				constValue
 			);
 			dep.isAnonymousDefault =
-				node.type === "ArrowFunctionExpression" ||
-				((node.type === "FunctionDeclaration" ||
-					node.type === "FunctionExpression" ||
-					node.type === "ClassDeclaration" ||
-					node.type === "ClassExpression") &&
-					!node.id);
-			dep.loc = Object.create(
-				/** @type {DependencyLocation} */ (statement.loc)
-			);
-			dep.loc.index = -1;
+				this.options.anonymousDefaultExportName !== false &&
+				(node.type === "ArrowFunctionExpression" ||
+					((node.type === "FunctionDeclaration" ||
+						node.type === "FunctionExpression" ||
+						node.type === "ClassDeclaration" ||
+						node.type === "ClassExpression") &&
+						!node.id));
+			dep.setLocWithIndex(parser.getLocation(statement), -1);
 			parser.state.current.addDependency(dep);
-			InnerGraph.addVariableUsage(
+			getInnerGraphUtils(parser.state.compilation).addVariableUsage(
 				parser,
 				node.type.endsWith("Declaration") &&
 					/** @type {FunctionDeclaration | ClassDeclaration} */ (node).id
@@ -184,7 +192,15 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 				const harmonyNamedExports = (parser.state.harmonyNamedExports =
 					parser.state.harmonyNamedExports || new Set());
 				harmonyNamedExports.add(name);
-				InnerGraph.addVariableUsage(parser, id, name);
+				getInnerGraphUtils(parser.state.compilation).addVariableUsage(
+					parser,
+					id,
+					name
+				);
+				const tagData = settings
+					? undefined
+					: /** @type {{ value?: import("../optimize/InlineExports").InlinedValue } | undefined} */
+						(parser.getTagData(id, CONST_BINDING_TAG));
 				const dep = settings
 					? new HarmonyExportImportedSpecifierDependency(
 							settings.source,
@@ -198,11 +214,24 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 							settings.phase,
 							settings.attributes
 						)
-					: new HarmonyExportSpecifierDependency(id, name);
-				dep.loc = Object.create(
-					/** @type {DependencyLocation} */ (statement.loc)
+					: new HarmonyExportSpecifierDependency(
+							id,
+							name,
+							tagData ? tagData.value || null : undefined
+						);
+				// lazy barrel: defer the re-export at parse time when the importing module is side-effect-free
+				const moduleFactoryMeta = parser.state.module.factoryMeta;
+				if (
+					settings &&
+					moduleFactoryMeta !== undefined &&
+					moduleFactoryMeta.sideEffectFree
+				) {
+					dep.setLazy(true);
+				}
+				dep.setLocWithIndex(
+					parser.getLocation(statement),
+					/** @type {number} */ (idx)
 				);
-				dep.loc.index = idx;
 				const isAsiSafe = !parser.isAsiPosition(
 					/** @type {Range} */
 					(statement.range)[0]
@@ -246,10 +275,18 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 				if (harmonyStarExports) {
 					harmonyStarExports.push(dep);
 				}
-				dep.loc = Object.create(
-					/** @type {DependencyLocation} */ (statement.loc)
+				// lazy barrel: defer the re-export at parse time when the importing module is side-effect-free
+				const moduleFactoryMeta = parser.state.module.factoryMeta;
+				if (
+					moduleFactoryMeta !== undefined &&
+					moduleFactoryMeta.sideEffectFree
+				) {
+					dep.setLazy(true);
+				}
+				dep.setLocWithIndex(
+					parser.getLocation(statement),
+					/** @type {number} */ (idx)
 				);
-				dep.loc.index = idx;
 				const isAsiSafe = !parser.isAsiPosition(
 					/** @type {Range} */
 					(statement.range)[0]