webpack 5.59.0 → 5.94.0

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -10,7 +10,9 @@ const InnerGraph = require("../optimize/InnerGraph");
 const ConstDependency = require("./ConstDependency");
 const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
 const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
+const HarmonyEvaluatedImportSpecifierDependency = require("./HarmonyEvaluatedImportSpecifierDependency");
 const HarmonyExports = require("./HarmonyExports");
+const { ExportPresenceModes } = require("./HarmonyImportDependency");
 const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
 const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
 
@@ -19,7 +21,17 @@ const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDepend
 /** @typedef {import("estree").Identifier} Identifier */
 /** @typedef {import("estree").ImportDeclaration} ImportDeclaration */
 /** @typedef {import("estree").ImportExpression} ImportExpression */
+/** @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").ImportAttributes} ImportAttributes */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../optimize/InnerGraph").InnerGraph} InnerGraph */
 /** @typedef {import("../optimize/InnerGraph").TopLevelSymbol} TopLevelSymbol */
 /** @typedef {import("./HarmonyImportDependency")} HarmonyImportDependency */
@@ -27,7 +39,7 @@ const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDepend
 const harmonySpecifierTag = Symbol("harmony import");
 
 /**
- * @typedef {Object} HarmonySettings
+ * @typedef {object} HarmonySettings
  * @property {string[]} ids
  * @property {string} source
  * @property {number} sourceOrder
@@ -37,31 +49,85 @@ const harmonySpecifierTag = Symbol("harmony import");
  */
 
 /**
- * @param {ImportDeclaration | ExportNamedDeclaration | ExportAllDeclaration | ImportExpression} node node with assertions
- * @returns {Record<string, any> | undefined} assertions
+ * @param {ImportDeclaration | ExportNamedDeclaration | ExportAllDeclaration | (ImportExpression & { arguments?: ObjectExpression[] })} node node with assertions
+ * @returns {ImportAttributes | undefined} import attributes
  */
-function getAssertions(node) {
+function getAttributes(node) {
+	if (
+		node.type === "ImportExpression" &&
+		node.arguments &&
+		node.arguments[0] &&
+		node.arguments[0].type === "ObjectExpression" &&
+		node.arguments[0].properties[0] &&
+		node.arguments[0].properties[0].type === "Property" &&
+		node.arguments[0].properties[0].value.type === "ObjectExpression" &&
+		node.arguments[0].properties[0].value.properties
+	) {
+		const properties =
+			/** @type {Property[]} */
+			(node.arguments[0].properties[0].value.properties);
+		const result = /** @type {ImportAttributes} */ ({});
+		for (const property of properties) {
+			const key =
+				/** @type {string} */
+				(
+					property.key.type === "Identifier"
+						? property.key.name
+						: /** @type {Literal} */ (property.key).value
+				);
+			result[key] =
+				/** @type {string} */
+				(/** @type {Literal} */ (property.value).value);
+		}
+		const key =
+			node.arguments[0].properties[0].key.type === "Identifier"
+				? node.arguments[0].properties[0].key.name
+				: /** @type {Literal} */ (node.arguments[0].properties[0].key).value;
+		if (key === "assert") {
+			result._isLegacyAssert = true;
+		}
+		return result;
+	}
 	// TODO remove cast when @types/estree has been updated to import assertions
-	const assertions = /** @type {{ assertions?: ImportAttributeNode[] }} */ (
-		node
-	).assertions;
-	if (assertions === undefined) {
-		return undefined;
+	const isImportAssertion =
+		/** @type {{ assertions?: ImportAttributeNode[] }} */ (node).assertions !==
+		undefined;
+	const attributes = isImportAssertion
+		? /** @type {{ assertions?: ImportAttributeNode[] }} */ (node).assertions
+		: /** @type {{ attributes?: ImportAttributeNode[] }} */ (node).attributes;
+	if (attributes === undefined) {
+		return;
 	}
-	const result = {};
-	for (const assertion of assertions) {
+	const result = /** @type {ImportAttributes} */ ({});
+	for (const attribute of attributes) {
 		const key =
-			assertion.key.type === "Identifier"
-				? assertion.key.name
-				: assertion.key.value;
-		result[key] = assertion.value.value;
+			/** @type {string} */
+			(
+				attribute.key.type === "Identifier"
+					? attribute.key.name
+					: attribute.key.value
+			);
+		result[key] = /** @type {string} */ (attribute.value.value);
+	}
+	if (isImportAssertion) {
+		result._isLegacyAssert = true;
 	}
 	return result;
 }
 
 module.exports = class HarmonyImportDependencyParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options options
+	 */
 	constructor(options) {
-		this.strictExportPresence = options.strictExportPresence;
+		this.exportPresenceMode =
+			options.importExportsPresence !== undefined
+				? ExportPresenceModes.fromUserOption(options.importExportsPresence)
+				: options.exportsPresence !== undefined
+					? ExportPresenceModes.fromUserOption(options.exportsPresence)
+					: options.strictExportPresence
+						? ExportPresenceModes.ERROR
+						: ExportPresenceModes.AUTO;
 		this.strictThisContextOnImports = options.strictThisContextOnImports;
 	}
 
@@ -70,6 +136,29 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 	 * @returns {void}
 	 */
 	apply(parser) {
+		const { exportPresenceMode } = this;
+
+		/**
+		 * @param {string[]} members members
+		 * @param {boolean[]} membersOptionals members Optionals
+		 * @returns {string[]} a non optional part
+		 */
+		function getNonOptionalPart(members, membersOptionals) {
+			let i = 0;
+			while (i < members.length && membersOptionals[i] === false) i++;
+			return i !== members.length ? members.slice(0, i) : members;
+		}
+
+		/**
+		 * @param {TODO} node member expression
+		 * @param {number} count count
+		 * @returns {TODO} member expression
+		 */
+		function getNonOptionalMemberChain(node, count) {
+			while (count--) node = node.object;
+			return node;
+		}
+
 		parser.hooks.isPure
 			.for("Identifier")
 			.tap("HarmonyImportDependencyParserPlugin", expression => {
@@ -87,19 +176,21 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				parser.state.lastHarmonyImportOrder =
 					(parser.state.lastHarmonyImportOrder || 0) + 1;
 				const clearDep = new ConstDependency(
-					parser.isAsiPosition(statement.range[0]) ? ";" : "",
-					statement.range
+					parser.isAsiPosition(/** @type {Range} */ (statement.range)[0])
+						? ";"
+						: "",
+					/** @type {Range} */ (statement.range)
 				);
-				clearDep.loc = statement.loc;
+				clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
 				parser.state.module.addPresentationalDependency(clearDep);
-				parser.unsetAsiPosition(statement.range[1]);
-				const assertions = getAssertions(statement);
+				parser.unsetAsiPosition(/** @type {Range} */ (statement.range)[1]);
+				const attributes = getAttributes(statement);
 				const sideEffectDep = new HarmonyImportSideEffectDependency(
-					source,
+					/** @type {string} */ (source),
 					parser.state.lastHarmonyImportOrder,
-					assertions
+					attributes
 				);
-				sideEffectDep.loc = statement.loc;
+				sideEffectDep.loc = /** @type {DependencyLocation} */ (statement.loc);
 				parser.state.module.addDependency(sideEffectDep);
 				return true;
 			}
@@ -113,79 +204,180 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					source,
 					ids,
 					sourceOrder: parser.state.lastHarmonyImportOrder,
-					assertions: getAssertions(statement)
+					assertions: getAttributes(statement)
 				});
 				return true;
 			}
 		);
-		parser.hooks.expression
-			.for(harmonySpecifierTag)
-			.tap("HarmonyImportDependencyParserPlugin", expr => {
-				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
-				const dep = new HarmonyImportSpecifierDependency(
+		parser.hooks.binaryExpression.tap(
+			"HarmonyImportDependencyParserPlugin",
+			expression => {
+				if (expression.operator !== "in") return;
+
+				const leftPartEvaluated = parser.evaluateExpression(expression.left);
+				if (leftPartEvaluated.couldHaveSideEffects()) return;
+				const leftPart = leftPartEvaluated.asString();
+				if (!leftPart) return;
+
+				const rightPart = parser.evaluateExpression(expression.right);
+				if (!rightPart.isIdentifier()) return;
+
+				const rootInfo = rightPart.rootInfo;
+				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,
+					settings.ids.concat(members).concat([leftPart]),
 					settings.name,
-					expr.range,
-					this.strictExportPresence,
-					settings.assertions
+					/** @type {Range} */ (expression.range),
+					settings.assertions,
+					"in"
 				);
-				dep.shorthand = parser.scope.inShorthand;
-				dep.directImport = true;
-				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
-				dep.loc = expr.loc;
+				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.expressionMemberChain
+			}
+		);
+		parser.hooks.expression
 			.for(harmonySpecifierTag)
-			.tap("HarmonyImportDependencyParserPlugin", (expr, members) => {
+			.tap("HarmonyImportDependencyParserPlugin", expr => {
 				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
-				const ids = settings.ids.concat(members);
 				const dep = new HarmonyImportSpecifierDependency(
 					settings.source,
 					settings.sourceOrder,
-					ids,
+					settings.ids,
 					settings.name,
-					expr.range,
-					this.strictExportPresence,
-					settings.assertions
+					/** @type {Range} */ (expr.range),
+					exportPresenceMode,
+					settings.assertions,
+					[]
 				);
-				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
-				dep.loc = expr.loc;
+				dep.referencedPropertiesInDestructuring =
+					parser.destructuringAssignmentPropertiesFor(expr);
+				dep.shorthand = parser.scope.inShorthand;
+				dep.directImport = true;
+				dep.asiSafe = !parser.isAsiPosition(
+					/** @type {Range} */ (expr.range)[0]
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.call = parser.scope.inTaggedTemplateTag;
 				parser.state.module.addDependency(dep);
 				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
 				return true;
 			});
+		parser.hooks.expressionMemberChain
+			.for(harmonySpecifierTag)
+			.tap(
+				"HarmonyImportDependencyParserPlugin",
+				(expression, members, membersOptionals, memberRanges) => {
+					const settings = /** @type {HarmonySettings} */ (
+						parser.currentTagData
+					);
+					const nonOptionalMembers = getNonOptionalPart(
+						members,
+						membersOptionals
+					);
+					/** @type {Range[]} */
+					const ranges = memberRanges.slice(
+						0,
+						memberRanges.length - (members.length - nonOptionalMembers.length)
+					);
+					const expr =
+						nonOptionalMembers !== members
+							? getNonOptionalMemberChain(
+									expression,
+									members.length - nonOptionalMembers.length
+								)
+							: expression;
+					const ids = settings.ids.concat(nonOptionalMembers);
+					const dep = new HarmonyImportSpecifierDependency(
+						settings.source,
+						settings.sourceOrder,
+						ids,
+						settings.name,
+						/** @type {Range} */ (expr.range),
+						exportPresenceMode,
+						settings.assertions,
+						ranges
+					);
+					dep.referencedPropertiesInDestructuring =
+						parser.destructuringAssignmentPropertiesFor(expr);
+					dep.asiSafe = !parser.isAsiPosition(
+						/** @type {Range} */ (expr.range)[0]
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					parser.state.module.addDependency(dep);
+					InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+					return true;
+				}
+			);
 		parser.hooks.callMemberChain
 			.for(harmonySpecifierTag)
-			.tap("HarmonyImportDependencyParserPlugin", (expr, members) => {
-				const { arguments: args, callee } = expr;
-				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
-				const ids = settings.ids.concat(members);
-				const dep = new HarmonyImportSpecifierDependency(
-					settings.source,
-					settings.sourceOrder,
-					ids,
-					settings.name,
-					callee.range,
-					this.strictExportPresence,
-					settings.assertions
-				);
-				dep.directImport = members.length === 0;
-				dep.call = true;
-				dep.asiSafe = !parser.isAsiPosition(callee.range[0]);
-				// only in case when we strictly follow the spec we need a special case here
-				dep.namespaceObjectAsContext =
-					members.length > 0 && this.strictThisContextOnImports;
-				dep.loc = callee.loc;
-				parser.state.module.addDependency(dep);
-				if (args) parser.walkExpressions(args);
-				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
-				return true;
-			});
+			.tap(
+				"HarmonyImportDependencyParserPlugin",
+				(expression, members, membersOptionals, memberRanges) => {
+					const { arguments: args, callee } = expression;
+					const settings = /** @type {HarmonySettings} */ (
+						parser.currentTagData
+					);
+					const nonOptionalMembers = getNonOptionalPart(
+						members,
+						membersOptionals
+					);
+					/** @type {Range[]} */
+					const ranges = memberRanges.slice(
+						0,
+						memberRanges.length - (members.length - nonOptionalMembers.length)
+					);
+					const expr =
+						nonOptionalMembers !== members
+							? getNonOptionalMemberChain(
+									callee,
+									members.length - nonOptionalMembers.length
+								)
+							: callee;
+					const ids = settings.ids.concat(nonOptionalMembers);
+					const dep = new HarmonyImportSpecifierDependency(
+						settings.source,
+						settings.sourceOrder,
+						ids,
+						settings.name,
+						/** @type {Range} */ (expr.range),
+						exportPresenceMode,
+						settings.assertions,
+						ranges
+					);
+					dep.directImport = members.length === 0;
+					dep.call = true;
+					dep.asiSafe = !parser.isAsiPosition(
+						/** @type {Range} */ (expr.range)[0]
+					);
+					// only in case when we strictly follow the spec we need a special case here
+					dep.namespaceObjectAsContext =
+						members.length > 0 &&
+						/** @type {boolean} */ (this.strictThisContextOnImports);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					parser.state.module.addDependency(dep);
+					if (args) parser.walkExpressions(args);
+					InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+					return true;
+				}
+			);
 		const { hotAcceptCallback, hotAcceptWithoutCallback } =
 			HotModuleReplacementPlugin.getParserHooks(parser);
 		hotAcceptCallback.tap(
@@ -240,4 +432,6 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 };
 
 module.exports.harmonySpecifierTag = harmonySpecifierTag;
-module.exports.getAssertions = getAssertions;
+// TODO remove it in webpack@6 in favor getAttributes
+module.exports.getAssertions = getAttributes;
+module.exports.getAttributes = getAttributes;

package/lib/dependencies/HarmonyImportSideEffectDependency.js

@@ -10,18 +10,24 @@ const HarmonyImportDependency = require("./HarmonyImportDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../InitFragment")} InitFragment */
 /** @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 */
 
 class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
-	constructor(request, sourceOrder, assertions) {
-		super(request, sourceOrder, assertions);
+	/**
+	 * @param {string} request the request string
+	 * @param {number} sourceOrder source order
+	 * @param {ImportAttributes=} attributes import attributes
+	 */
+	constructor(request, sourceOrder, attributes) {
+		super(request, sourceOrder, attributes);
 	}
 
 	get type() {
@@ -30,7 +36,7 @@ class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
 	 */
 	getCondition(moduleGraph) {
 		return connection => {
@@ -68,7 +74,7 @@ HarmonyImportSideEffectDependency.Template = class HarmonyImportSideEffectDepend
 	apply(dependency, source, templateContext) {
 		const { moduleGraph, concatenationScope } = templateContext;
 		if (concatenationScope) {
-			const module = moduleGraph.getModule(dependency);
+			const module = /** @type {Module} */ (moduleGraph.getModule(dependency));
 			if (concatenationScope.isModuleInScope(module)) {
 				return;
 			}