webpack 5.108.3 → 5.109.0

package/lib/dependencies/HarmonyDetectionParserPlugin.js

@@ -10,10 +10,16 @@ const EnvironmentNotSupportAsyncWarning = require("../errors/EnvironmentNotSuppo
 const DynamicExports = require("./DynamicExports");
 const HarmonyCompatibilityDependency = require("./HarmonyCompatibilityDependency");
 const HarmonyExports = require("./HarmonyExports");
-const { IMPORT_META_NAMES } = require("./ImportMetaPlugin");
+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";
 
@@ -68,34 +74,58 @@ module.exports = class HarmonyDetectionParserPlugin {
 			}
 		});
 
-		parser.hooks.topLevelAwait.tap(PLUGIN_NAME, () => {
+		parser.hooks.topLevelAwait.tap(PLUGIN_NAME, (node) => {
 			const module = parser.state.module;
 			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 and run before ImportMetaPlugin so its handling still runs;
-		// unknown members go through `unhandledExpressionMemberChain`.
+		// 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(PLUGIN_NAME, onImportMeta);
-			parser.hooks.typeof.for(name).tap(PLUGIN_NAME, onImportMeta);
+			parser.hooks.expression.for(name).tap(earlyTapOptions, onImportMeta);
+			parser.hooks.typeof.for(name).tap(earlyTapOptions, onImportMeta);
 		}
 		parser.hooks.expressionMemberChain
 			.for("import.meta")
-			.tap(PLUGIN_NAME, onImportMeta);
+			.tap(earlyTapOptions, onImportMeta);
 		parser.hooks.unhandledExpressionMemberChain
 			.for("import.meta")
-			.tap(PLUGIN_NAME, onImportMeta);
+			.tap(earlyTapOptions, onImportMeta);
 
 		/**
 		 * Returns true if in harmony.

package/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -70,10 +70,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 				),
 				/** @type {Range} */ (statement.range)
 			);
-			dep.setLocWithIndex(
-				/** @type {DependencyLocation} */ (statement.loc),
-				-1
-			);
+			dep.setLocWithIndex(parser.getLocation(statement), -1);
 			parser.state.module.addPresentationalDependency(dep);
 			return true;
 		});
@@ -84,10 +81,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 				"",
 				/** @type {Range} */ (statement.range)
 			);
-			clearDep.setLocWithIndex(
-				/** @type {DependencyLocation} */ (statement.loc),
-				-1
-			);
+			clearDep.setLocWithIndex(parser.getLocation(statement), -1);
 			parser.state.module.addPresentationalDependency(clearDep);
 
 			const phase = getImportPhase(parser, statement);
@@ -95,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(
@@ -104,10 +98,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 				phase,
 				getImportAttributes(statement)
 			);
-			sideEffectDep.setLocWithIndex(
-				/** @type {DependencyLocation} */ (statement.loc),
-				-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) {
@@ -168,10 +159,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 						node.type === "ClassDeclaration" ||
 						node.type === "ClassExpression") &&
 						!node.id));
-			dep.setLocWithIndex(
-				/** @type {DependencyLocation} */ (statement.loc),
-				-1
-			);
+			dep.setLocWithIndex(parser.getLocation(statement), -1);
 			parser.state.current.addDependency(dep);
 			getInnerGraphUtils(parser.state.compilation).addVariableUsage(
 				parser,
@@ -241,7 +229,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 					dep.setLazy(true);
 				}
 				dep.setLocWithIndex(
-					/** @type {DependencyLocation} */ (statement.loc),
+					parser.getLocation(statement),
 					/** @type {number} */ (idx)
 				);
 				const isAsiSafe = !parser.isAsiPosition(
@@ -296,7 +284,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 					dep.setLazy(true);
 				}
 				dep.setLocWithIndex(
-					/** @type {DependencyLocation} */ (statement.loc),
+					parser.getLocation(statement),
 					/** @type {number} */ (idx)
 				);
 				const isAsiSafe = !parser.isAsiPosition(

package/lib/dependencies/HarmonyImportDependency.js

@@ -10,6 +10,7 @@ const Dependency = require("../Dependency");
 const InitFragment = require("../InitFragment");
 const Template = require("../Template");
 const AwaitDependenciesInitFragment = require("../async-modules/AwaitDependenciesInitFragment");
+const isGeneratorLowered = require("../async-modules/isGeneratorLowered");
 const { filterRuntime, mergeRuntime } = require("../util/runtime");
 const HarmonyLinkingError = require("./HarmonyLinkingError");
 const { ImportPhase, ImportPhaseUtils } = require("./ImportPhase");
@@ -475,8 +476,18 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 				)
 			);
 			const importVar = dep.getImportVar(templateContext.moduleGraph);
+			// When the consuming module is emitted as a generator (target without
+			// `async`/`await`), the dependency `await` must become `yield`.
+			const generatorLowered = isGeneratorLowered(
+				/** @type {Module} */ (module),
+				moduleGraph,
+				templateContext.runtimeTemplate
+			);
 			templateContext.initFragments.push(
-				new AwaitDependenciesInitFragment(new Map([[importVar, importVar]]))
+				new AwaitDependenciesInitFragment(
+					new Map([[importVar, importVar]]),
+					generatorLowered
+				)
 			);
 			templateContext.initFragments.push(
 				new ConditionalInitFragment(

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -12,7 +12,6 @@ const {
 	getImportAttributes
 } = require("../javascript/JavascriptParser");
 const { getInnerGraphUtils } = require("../optimize/InnerGraph");
-const memoize = require("../util/memoize");
 const ConstDependency = require("./ConstDependency");
 const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
 const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
@@ -22,6 +21,10 @@ const {
 	ExportPresenceModes,
 	getNonOptionalPart
 } = require("./HarmonyImportDependency");
+const {
+	attachDependencyGuards,
+	isPresentByGuards
+} = require("./HarmonyImportGuard");
 const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
 const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
 const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
@@ -46,10 +49,6 @@ const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
 /** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 /** @typedef {import("./HarmonyImportGuard").GuardFrame} GuardFrame */
 
-/** @typedef {Map<string, Set<string>>} Guards Map of import root to guarded member keys */
-
-const getHarmonyImportGuard = memoize(() => require("./HarmonyImportGuard"));
-
 const harmonySpecifierTag = Symbol("harmony import");
 
 // Shared placeholder: plain specifier references have no member ranges, so they
@@ -137,6 +136,12 @@ const findImportSpecifier = (parser, node) => {
 				parser,
 				/** @type {Expression} */ (node.object)
 			);
+		case "BinaryExpression":
+			// `"x" in ns` presence guard
+			return (
+				node.operator === "in" &&
+				findImportSpecifier(parser, /** @type {Expression} */ (node.right))
+			);
 		default:
 			return false;
 	}
@@ -175,21 +180,18 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 		);
 		if (!harmonySettings) return this.exportPresenceMode;
 
+		if (this.exportPresenceMode === ExportPresenceModes.NONE) {
+			return this.exportPresenceMode;
+		}
+
 		const stack = /** @type {GuardFrame[] | undefined} */ (
 			parser.state.guardStack
 		);
-		if (stack !== undefined) {
-			const name = harmonySettings.name;
-			const member = ids[0];
-			for (let i = stack.length - 1; i >= 0; i--) {
-				const presence = stack[i].presence;
-				if (presence !== undefined) {
-					const members = presence.get(name);
-					if (members !== undefined && members.has(member)) {
-						return ExportPresenceModes.NONE;
-					}
-				}
-			}
+		if (
+			stack !== undefined &&
+			isPresentByGuards(parser, stack, harmonySettings.name, ids[0])
+		) {
+			return ExportPresenceModes.NONE;
 		}
 
 		return this.exportPresenceMode;
@@ -235,7 +237,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					: "",
 				/** @type {Range} */ (statement.range)
 			);
-			clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
+			clearDep.loc = parser.getLocation(statement);
 			parser.state.module.addPresentationalDependency(clearDep);
 			parser.unsetAsiPosition(/** @type {Range} */ (statement.range)[1]);
 			const attributes = getImportAttributes(statement);
@@ -248,7 +250,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				const error = new WebpackError(
 					"Deferred import can only be used with `import * as namespace from '...'` syntax."
 				);
-				error.loc = statement.loc || undefined;
+				error.loc = parser.getLocation(statement) || undefined;
 				parser.state.current.addError(error);
 			}
 
@@ -258,7 +260,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				phase,
 				attributes
 			);
-			sideEffectDep.loc = /** @type {DependencyLocation} */ (statement.loc);
+			sideEffectDep.loc = parser.getLocation(statement);
 			parser.state.module.addDependency(sideEffectDep);
 			return true;
 		});
@@ -305,7 +307,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			dep.asiSafe = !parser.isAsiPosition(
 				/** @type {Range} */ (expression.range)[0]
 			);
-			dep.loc = /** @type {DependencyLocation} */ (expression.loc);
+			dep.loc = parser.getLocation(expression);
 			parser.state.module.addDependency(dep);
 			getInnerGraphUtils(parser.state.compilation).onUsage(
 				parser.state,
@@ -351,10 +353,10 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				dep.asiSafe = !parser.isAsiPosition(
 					/** @type {Range} */ (expr.range)[0]
 				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.loc = parser.getLocation(expr);
 				dep.call = parser.scope.inTaggedTemplateTag;
 				parser.state.module.addDependency(dep);
-				getHarmonyImportGuard().attachDependencyGuards(parser, dep);
+				attachDependencyGuards(parser, dep);
 				getInnerGraphUtils(parser.state.compilation).onUsage(
 					parser.state,
 					(e) => (dep.usedByExports = e)
@@ -404,9 +406,9 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						/** @type {Range} */
 						(expr.range)[0]
 					);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					dep.loc = parser.getLocation(expr);
 					parser.state.module.addDependency(dep);
-					getHarmonyImportGuard().attachDependencyGuards(parser, dep);
+					attachDependencyGuards(parser, dep);
 					getInnerGraphUtils(parser.state.compilation).onUsage(
 						parser.state,
 						(e) => (dep.usedByExports = e)
@@ -461,9 +463,9 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					dep.namespaceObjectAsContext =
 						members.length > 0 &&
 						/** @type {boolean} */ (this.strictThisContextOnImports);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					dep.loc = parser.getLocation(expr);
 					parser.state.module.addDependency(dep);
-					getHarmonyImportGuard().attachDependencyGuards(parser, dep);
+					attachDependencyGuards(parser, dep);
 					if (args) parser.walkExpressions(args);
 					getInnerGraphUtils(parser.state.compilation).onUsage(
 						parser.state,
@@ -502,7 +504,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			}
 			const dependencies = requests.map((request) => {
 				const dep = new HarmonyAcceptImportDependency(request);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.loc = parser.getLocation(expr);
 				parser.state.module.addDependency(dep);
 				return dep;
 			});
@@ -513,7 +515,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					dependencies,
 					true
 				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.loc = parser.getLocation(expr);
 				parser.state.module.addDependency(dep);
 			}
 		});
@@ -524,7 +526,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			}
 			const dependencies = requests.map((request) => {
 				const dep = new HarmonyAcceptImportDependency(request);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.loc = parser.getLocation(expr);
 				parser.state.module.addDependency(dep);
 				return dep;
 			});
@@ -535,7 +537,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					dependencies,
 					false
 				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.loc = parser.getLocation(expr);
 				parser.state.module.addDependency(dep);
 			}
 		});
@@ -543,90 +545,15 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 		parser.hooks.collectGuards.tap(PLUGIN_NAME, (expression) => {
 			if (parser.scope.isAsmJs) return;
 
-			// Presence guards: `"x" in ns` checks that suppress export-presence errors
-			// (consequent only).
-			/** @type {Guards | undefined} */
-			let presence;
-			if (this.exportPresenceMode !== ExportPresenceModes.NONE) {
-				/** @type {Guards} */
-				const guards = new Map();
-
-				/**
-				 * Processes the provided expression.
-				 * @param {Expression} expression expression
-				 * @param {boolean} needTruthy need to be truthy
-				 */
-				const collect = (expression, needTruthy) => {
-					if (
-						expression.type === "UnaryExpression" &&
-						expression.operator === "!"
-					) {
-						collect(expression.argument, !needTruthy);
-						return;
-					} else if (expression.type === "LogicalExpression" && needTruthy) {
-						if (expression.operator === "&&") {
-							collect(expression.left, true);
-							collect(expression.right, true);
-						} else if (expression.operator === "||") {
-							const leftEvaluation = parser.evaluateExpression(expression.left);
-							const leftBool = leftEvaluation.asBool();
-							if (leftBool === false) {
-								collect(expression.right, true);
-							}
-						} else if (expression.operator === "??") {
-							const leftEvaluation = parser.evaluateExpression(expression.left);
-							const leftNullish = leftEvaluation.asNullish();
-							if (leftNullish === true) {
-								collect(expression.right, true);
-							}
-						}
-						return;
-					}
-					if (!needTruthy) return;
-
-					// Direct `"x" in ns` guards
-					if (
-						expression.type === "BinaryExpression" &&
-						expression.operator === "in"
-					) {
-						if (expression.right.type !== "Identifier") {
-							return;
-						}
-						const info = getInOperatorHarmonyImportInfo(
-							parser,
-							expression.left,
-							expression.right
-						);
-						if (!info) return;
-
-						const { settings, leftPart, members } = info;
-						// Only direct namespace guards
-						if (members.length > 0) return;
-						const guarded = guards.get(settings.name);
-						if (guarded) {
-							guarded.add(leftPart);
-							return;
-						}
-
-						guards.set(settings.name, new Set([leftPart]));
-					}
-				};
-
-				collect(expression, true);
-
-				if (guards.size > 0) presence = guards;
-			}
-
 			const hasSpecifier = findImportSpecifier(parser, expression);
 			const depStart = hasSpecifier
 				? /** @type {Module} */ (parser.state.module).dependencies.length
 				: undefined;
 
-			if (presence === undefined && depStart === undefined) return;
+			if (depStart === undefined) return;
 
 			/** @type {GuardFrame} */
 			const consequent = {
-				presence,
 				test: expression,
 				depStart,
 				condition: true