webpack 5.97.1 → 5.104.1

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -6,7 +6,11 @@
 "use strict";
 
 const HotModuleReplacementPlugin = require("../HotModuleReplacementPlugin");
-const { getImportAttributes } = require("../javascript/JavascriptParser");
+const WebpackError = require("../WebpackError");
+const {
+	VariableInfo,
+	getImportAttributes
+} = require("../javascript/JavascriptParser");
 const InnerGraph = require("../optimize/InnerGraph");
 const ConstDependency = require("./ConstDependency");
 const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
@@ -16,44 +20,45 @@ const HarmonyExports = require("./HarmonyExports");
 const { ExportPresenceModes } = require("./HarmonyImportDependency");
 const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
 const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
+const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
 
+/** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("estree").Identifier} Identifier */
-/** @typedef {import("estree").Literal} Literal */
 /** @typedef {import("estree").MemberExpression} MemberExpression */
-/** @typedef {import("estree").ObjectExpression} ObjectExpression */
-/** @typedef {import("estree").Property} Property */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperty} DestructuringAssignmentProperty */
 /** @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").ImportExpression} ImportExpression */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../optimize/InnerGraph").InnerGraph} InnerGraph */
-/** @typedef {import("../optimize/InnerGraph").TopLevelSymbol} TopLevelSymbol */
-/** @typedef {import("./HarmonyImportDependency")} HarmonyImportDependency */
+/** @typedef {import("../javascript/JavascriptParser").Members} Members */
+/** @typedef {import("../javascript/JavascriptParser").MembersOptionals} MembersOptionals */
+/** @typedef {import("./HarmonyImportDependency").Ids} Ids */
+/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 
 const harmonySpecifierTag = Symbol("harmony import");
 
 /**
  * @typedef {object} HarmonySettings
- * @property {string[]} ids
+ * @property {Ids} ids
  * @property {string} source
  * @property {number} sourceOrder
  * @property {string} name
  * @property {boolean} await
- * @property {Record<string, any> | undefined} assertions
+ * @property {ImportAttributes=} attributes
+ * @property {ImportPhaseType} phase
  */
 
+const PLUGIN_NAME = "HarmonyImportDependencyParserPlugin";
+
 module.exports = class HarmonyImportDependencyParserPlugin {
 	/**
 	 * @param {JavascriptParserOptions} options options
 	 */
 	constructor(options) {
+		this.options = options;
 		this.exportPresenceMode =
 			options.importExportsPresence !== undefined
 				? ExportPresenceModes.fromUserOption(options.importExportsPresence)
@@ -72,10 +77,12 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 	apply(parser) {
 		const { exportPresenceMode } = this;
 
+		const getImportPhase = createGetImportPhase(this.options.deferImport);
+
 		/**
-		 * @param {string[]} members members
-		 * @param {boolean[]} membersOptionals members Optionals
-		 * @returns {string[]} a non optional part
+		 * @param {Members} members members
+		 * @param {MembersOptionals} membersOptionals members Optionals
+		 * @returns {Ids} a non optional part
 		 */
 		function getNonOptionalPart(members, membersOptionals) {
 			let i = 0;
@@ -84,121 +91,153 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 		}
 
 		/**
-		 * @param {TODO} node member expression
+		 * @param {MemberExpression} node member expression
 		 * @param {number} count count
-		 * @returns {TODO} member expression
+		 * @returns {Expression} member expression
 		 */
 		function getNonOptionalMemberChain(node, count) {
-			while (count--) node = node.object;
+			while (count--) node = /** @type {MemberExpression} */ (node.object);
 			return node;
 		}
 
-		parser.hooks.isPure
-			.for("Identifier")
-			.tap("HarmonyImportDependencyParserPlugin", expression => {
-				const expr = /** @type {Identifier} */ (expression);
-				if (
-					parser.isVariableDefined(expr.name) ||
-					parser.getTagData(expr.name, harmonySpecifierTag)
-				) {
-					return true;
-				}
-			});
-		parser.hooks.import.tap(
-			"HarmonyImportDependencyParserPlugin",
-			(statement, source) => {
-				parser.state.lastHarmonyImportOrder =
-					(parser.state.lastHarmonyImportOrder || 0) + 1;
-				const clearDep = new ConstDependency(
-					parser.isAsiPosition(/** @type {Range} */ (statement.range)[0])
-						? ";"
-						: "",
-					/** @type {Range} */ (statement.range)
-				);
-				clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
-				parser.state.module.addPresentationalDependency(clearDep);
-				parser.unsetAsiPosition(/** @type {Range} */ (statement.range)[1]);
-				const attributes = getImportAttributes(statement);
-				const sideEffectDep = new HarmonyImportSideEffectDependency(
-					/** @type {string} */ (source),
-					parser.state.lastHarmonyImportOrder,
-					attributes
-				);
-				sideEffectDep.loc = /** @type {DependencyLocation} */ (statement.loc);
-				parser.state.module.addDependency(sideEffectDep);
+		parser.hooks.isPure.for("Identifier").tap(PLUGIN_NAME, (expression) => {
+			const expr = /** @type {Identifier} */ (expression);
+			if (
+				parser.isVariableDefined(expr.name) ||
+				parser.getTagData(expr.name, harmonySpecifierTag)
+			) {
 				return true;
 			}
-		);
+		});
+		parser.hooks.import.tap(PLUGIN_NAME, (statement, source) => {
+			parser.state.lastHarmonyImportOrder =
+				(parser.state.lastHarmonyImportOrder || 0) + 1;
+			const clearDep = new ConstDependency(
+				parser.isAsiPosition(/** @type {Range} */ (statement.range)[0])
+					? ";"
+					: "",
+				/** @type {Range} */ (statement.range)
+			);
+			clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
+			parser.state.module.addPresentationalDependency(clearDep);
+			parser.unsetAsiPosition(/** @type {Range} */ (statement.range)[1]);
+			const attributes = getImportAttributes(statement);
+			const phase = getImportPhase(parser, statement);
+			if (
+				ImportPhaseUtils.isDefer(phase) &&
+				(statement.specifiers.length !== 1 ||
+					statement.specifiers[0].type !== "ImportNamespaceSpecifier")
+			) {
+				const error = new WebpackError(
+					"Deferred import can only be used with `import * as namespace from '...'` syntax."
+				);
+				error.loc = statement.loc || undefined;
+				parser.state.current.addError(error);
+			}
+
+			const sideEffectDep = new HarmonyImportSideEffectDependency(
+				/** @type {string} */ (source),
+				parser.state.lastHarmonyImportOrder,
+				phase,
+				attributes
+			);
+			sideEffectDep.loc = /** @type {DependencyLocation} */ (statement.loc);
+			parser.state.module.addDependency(sideEffectDep);
+			return true;
+		});
 		parser.hooks.importSpecifier.tap(
-			"HarmonyImportDependencyParserPlugin",
+			PLUGIN_NAME,
 			(statement, source, id, name) => {
 				const ids = id === null ? [] : [id];
-				parser.tagVariable(name, harmonySpecifierTag, {
+				const phase = getImportPhase(parser, statement);
+				parser.tagVariable(
 					name,
-					source,
-					ids,
-					sourceOrder: parser.state.lastHarmonyImportOrder,
-					assertions: getImportAttributes(statement)
-				});
+					harmonySpecifierTag,
+					/** @type {HarmonySettings} */ ({
+						name,
+						source,
+						ids,
+						sourceOrder: parser.state.lastHarmonyImportOrder,
+						attributes: getImportAttributes(statement),
+						phase
+					})
+				);
 				return true;
 			}
 		);
-		parser.hooks.binaryExpression.tap(
-			"HarmonyImportDependencyParserPlugin",
-			expression => {
-				if (expression.operator !== "in") return;
+		parser.hooks.binaryExpression.tap(PLUGIN_NAME, (expression) => {
+			if (expression.operator !== "in") return;
 
-				const leftPartEvaluated = parser.evaluateExpression(expression.left);
-				if (leftPartEvaluated.couldHaveSideEffects()) return;
-				const leftPart = leftPartEvaluated.asString();
-				if (!leftPart) return;
+			const leftPartEvaluated = parser.evaluateExpression(expression.left);
+			if (leftPartEvaluated.couldHaveSideEffects()) return;
+			/** @type {string | undefined} */
+			const leftPart = leftPartEvaluated.asString();
+			if (!leftPart) return;
 
-				const rightPart = parser.evaluateExpression(expression.right);
-				if (!rightPart.isIdentifier()) return;
+			const rightPart = parser.evaluateExpression(expression.right);
+			if (!rightPart.isIdentifier()) return;
 
-				const rootInfo = rightPart.rootInfo;
+			const rootInfo = rightPart.rootInfo;
+			if (
+				typeof rootInfo === "string" ||
+				!rootInfo ||
+				!rootInfo.tagInfo ||
+				rootInfo.tagInfo.tag !== harmonySpecifierTag
+			) {
+				return;
+			}
+			const settings =
+				/** @type {HarmonySettings} */
+				(rootInfo.tagInfo.data);
+			const members =
+				/** @type {(() => Members)} */
+				(rightPart.getMembers)();
+			const dep = new HarmonyEvaluatedImportSpecifierDependency(
+				settings.source,
+				settings.sourceOrder,
+				[...settings.ids, ...members, leftPart],
+				settings.name,
+				/** @type {Range} */ (expression.range),
+				settings.attributes,
+				"in"
+			);
+			dep.directImport = members.length === 0;
+			dep.asiSafe = !parser.isAsiPosition(
+				/** @type {Range} */ (expression.range)[0]
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expression.loc);
+			parser.state.module.addDependency(dep);
+			InnerGraph.onUsage(parser.state, (e) => (dep.usedByExports = e));
+			return true;
+		});
+		parser.hooks.collectDestructuringAssignmentProperties.tap(
+			PLUGIN_NAME,
+			(expr) => {
+				const nameInfo = parser.getNameForExpression(expr);
 				if (
-					typeof rootInfo === "string" ||
-					!rootInfo ||
-					!rootInfo.tagInfo ||
-					rootInfo.tagInfo.tag !== harmonySpecifierTag
-				)
-					return;
-				const settings = rootInfo.tagInfo.data;
-				const members =
-					/** @type {(() => string[])} */
-					(rightPart.getMembers)();
-				const dep = new HarmonyEvaluatedImportSpecifierDependency(
-					settings.source,
-					settings.sourceOrder,
-					settings.ids.concat(members).concat([leftPart]),
-					settings.name,
-					/** @type {Range} */ (expression.range),
-					settings.assertions,
-					"in"
-				);
-				dep.directImport = members.length === 0;
-				dep.asiSafe = !parser.isAsiPosition(
-					/** @type {Range} */ (expression.range)[0]
-				);
-				dep.loc = /** @type {DependencyLocation} */ (expression.loc);
-				parser.state.module.addDependency(dep);
-				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
-				return true;
+					nameInfo &&
+					nameInfo.rootInfo instanceof VariableInfo &&
+					nameInfo.rootInfo.name &&
+					parser.getTagData(nameInfo.rootInfo.name, harmonySpecifierTag)
+				) {
+					return true;
+				}
 			}
 		);
 		parser.hooks.expression
 			.for(harmonySpecifierTag)
-			.tap("HarmonyImportDependencyParserPlugin", expr => {
+			.tap(PLUGIN_NAME, (expr) => {
 				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
 				const dep = new HarmonyImportSpecifierDependency(
 					settings.source,
 					settings.sourceOrder,
 					settings.ids,
 					settings.name,
-					/** @type {Range} */ (expr.range),
+					/** @type {Range} */
+					(expr.range),
 					exportPresenceMode,
-					settings.assertions,
+					settings.phase,
+					settings.attributes,
 					[]
 				);
 				dep.referencedPropertiesInDestructuring =
@@ -211,17 +250,17 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				dep.call = parser.scope.inTaggedTemplateTag;
 				parser.state.module.addDependency(dep);
-				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+				InnerGraph.onUsage(parser.state, (e) => (dep.usedByExports = e));
 				return true;
 			});
 		parser.hooks.expressionMemberChain
 			.for(harmonySpecifierTag)
 			.tap(
-				"HarmonyImportDependencyParserPlugin",
+				PLUGIN_NAME,
 				(expression, members, membersOptionals, memberRanges) => {
-					const settings = /** @type {HarmonySettings} */ (
-						parser.currentTagData
-					);
+					const settings =
+						/** @type {HarmonySettings} */
+						(parser.currentTagData);
 					const nonOptionalMembers = getNonOptionalPart(
 						members,
 						membersOptionals
@@ -238,34 +277,38 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 									members.length - nonOptionalMembers.length
 								)
 							: expression;
-					const ids = settings.ids.concat(nonOptionalMembers);
+					const ids = [...settings.ids, ...nonOptionalMembers];
 					const dep = new HarmonyImportSpecifierDependency(
 						settings.source,
 						settings.sourceOrder,
 						ids,
 						settings.name,
-						/** @type {Range} */ (expr.range),
+						/** @type {Range} */
+						(expr.range),
 						exportPresenceMode,
-						settings.assertions,
+						settings.phase,
+						settings.attributes,
 						ranges
 					);
 					dep.referencedPropertiesInDestructuring =
 						parser.destructuringAssignmentPropertiesFor(expr);
 					dep.asiSafe = !parser.isAsiPosition(
-						/** @type {Range} */ (expr.range)[0]
+						/** @type {Range} */
+						(expr.range)[0]
 					);
 					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 					parser.state.module.addDependency(dep);
-					InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+					InnerGraph.onUsage(parser.state, (e) => (dep.usedByExports = e));
 					return true;
 				}
 			);
 		parser.hooks.callMemberChain
 			.for(harmonySpecifierTag)
 			.tap(
-				"HarmonyImportDependencyParserPlugin",
+				PLUGIN_NAME,
 				(expression, members, membersOptionals, memberRanges) => {
-					const { arguments: args, callee } = expression;
+					const { arguments: args } = expression;
+					const callee = /** @type {MemberExpression} */ (expression.callee);
 					const settings = /** @type {HarmonySettings} */ (
 						parser.currentTagData
 					);
@@ -285,7 +328,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 									members.length - nonOptionalMembers.length
 								)
 							: callee;
-					const ids = settings.ids.concat(nonOptionalMembers);
+					const ids = [...settings.ids, ...nonOptionalMembers];
 					const dep = new HarmonyImportSpecifierDependency(
 						settings.source,
 						settings.sourceOrder,
@@ -293,7 +336,8 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						settings.name,
 						/** @type {Range} */ (expr.range),
 						exportPresenceMode,
-						settings.assertions,
+						settings.phase,
+						settings.attributes,
 						ranges
 					);
 					dep.directImport = members.length === 0;
@@ -308,62 +352,56 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 					parser.state.module.addDependency(dep);
 					if (args) parser.walkExpressions(args);
-					InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+					InnerGraph.onUsage(parser.state, (e) => (dep.usedByExports = e));
 					return true;
 				}
 			);
 		const { hotAcceptCallback, hotAcceptWithoutCallback } =
 			HotModuleReplacementPlugin.getParserHooks(parser);
-		hotAcceptCallback.tap(
-			"HarmonyImportDependencyParserPlugin",
-			(expr, requests) => {
-				if (!HarmonyExports.isEnabled(parser.state)) {
-					// This is not a harmony module, skip it
-					return;
-				}
-				const dependencies = requests.map(request => {
-					const dep = new HarmonyAcceptImportDependency(request);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-					parser.state.module.addDependency(dep);
-					return dep;
-				});
-				if (dependencies.length > 0) {
-					const dep = new HarmonyAcceptDependency(
-						/** @type {Range} */
-						(expr.range),
-						dependencies,
-						true
-					);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-					parser.state.module.addDependency(dep);
-				}
+		hotAcceptCallback.tap(PLUGIN_NAME, (expr, requests) => {
+			if (!HarmonyExports.isEnabled(parser.state)) {
+				// This is not a harmony module, skip it
+				return;
 			}
-		);
-		hotAcceptWithoutCallback.tap(
-			"HarmonyImportDependencyParserPlugin",
-			(expr, requests) => {
-				if (!HarmonyExports.isEnabled(parser.state)) {
-					// This is not a harmony module, skip it
-					return;
-				}
-				const dependencies = requests.map(request => {
-					const dep = new HarmonyAcceptImportDependency(request);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-					parser.state.module.addDependency(dep);
-					return dep;
-				});
-				if (dependencies.length > 0) {
-					const dep = new HarmonyAcceptDependency(
-						/** @type {Range} */
-						(expr.range),
-						dependencies,
-						false
-					);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-					parser.state.module.addDependency(dep);
-				}
+			const dependencies = requests.map((request) => {
+				const dep = new HarmonyAcceptImportDependency(request);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addDependency(dep);
+				return dep;
+			});
+			if (dependencies.length > 0) {
+				const dep = new HarmonyAcceptDependency(
+					/** @type {Range} */
+					(expr.range),
+					dependencies,
+					true
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addDependency(dep);
 			}
-		);
+		});
+		hotAcceptWithoutCallback.tap(PLUGIN_NAME, (expr, requests) => {
+			if (!HarmonyExports.isEnabled(parser.state)) {
+				// This is not a harmony module, skip it
+				return;
+			}
+			const dependencies = requests.map((request) => {
+				const dep = new HarmonyAcceptImportDependency(request);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addDependency(dep);
+				return dep;
+			});
+			if (dependencies.length > 0) {
+				const dep = new HarmonyAcceptDependency(
+					/** @type {Range} */
+					(expr.range),
+					dependencies,
+					false
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addDependency(dep);
+			}
+		});
 	}
 };
 

package/lib/dependencies/HarmonyImportSideEffectDependency.js

@@ -14,20 +14,19 @@ const HarmonyImportDependency = require("./HarmonyImportDependency");
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 
 class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
 	/**
 	 * @param {string} request the request string
 	 * @param {number} sourceOrder source order
+	 * @param {ImportPhaseType} phase import phase
 	 * @param {ImportAttributes=} attributes import attributes
 	 */
-	constructor(request, sourceOrder, attributes) {
-		super(request, sourceOrder, attributes);
+	constructor(request, sourceOrder, phase, attributes) {
+		super(request, sourceOrder, phase, attributes);
 	}
 
 	get type() {
@@ -39,7 +38,7 @@ class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
 	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
 	 */
 	getCondition(moduleGraph) {
-		return connection => {
+		return (connection) => {
 			const refModule = connection.resolvedModule;
 			if (!refModule) return true;
 			return refModule.getSideEffectsConnectionState(moduleGraph);