init commit

remotion/node_modules/webpack/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -0,0 +1,669 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const HotModuleReplacementPlugin = require("../HotModuleReplacementPlugin");
+const WebpackError = require("../WebpackError");
+const {
+	VariableInfo,
+	getImportAttributes
+} = require("../javascript/JavascriptParser");
+const InnerGraph = require("../optimize/InnerGraph");
+const AppendOnlyStackedSet = require("../util/AppendOnlyStackedSet");
+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");
+const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
+
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").MemberExpression} MemberExpression */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @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").Range} Range */
+/** @typedef {import("../javascript/JavascriptParser").Members} Members */
+/** @typedef {import("../javascript/JavascriptParser").MembersOptionals} MembersOptionals */
+/** @typedef {import("./HarmonyImportDependency").Ids} Ids */
+/** @typedef {import("./HarmonyImportDependency").ExportPresenceMode} ExportPresenceMode */
+/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
+
+/**
+ * @typedef {object} HarmonySpecifierGuards
+ * @property {AppendOnlyStackedSet<string> | undefined} guards
+ */
+
+/** @typedef {Map<string, Set<string>>} Guards Map of import root to guarded member keys */
+
+const harmonySpecifierTag = Symbol("harmony import");
+const harmonySpecifierGuardTag = Symbol("harmony import guard");
+
+/**
+ * @typedef {object} HarmonySettings
+ * @property {Ids} ids
+ * @property {string} source
+ * @property {number} sourceOrder
+ * @property {string} name
+ * @property {boolean} await
+ * @property {ImportAttributes=} attributes
+ * @property {ImportPhaseType} phase
+ */
+
+const PLUGIN_NAME = "HarmonyImportDependencyParserPlugin";
+
+/** @type {(members: Members) => string} */
+const getMembersKey = (members) => members.join(".");
+
+/**
+ * Strip the root binding name if needed
+ * @param {HarmonySettings} settings settings
+ * @param {Ids} ids ids
+ * @returns {Ids} ids for presence check
+ */
+const getIdsForPresence = (settings, ids) =>
+	settings.ids.length ? ids.slice(1) : ids;
+
+module.exports = class HarmonyImportDependencyParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options options
+	 */
+	constructor(options) {
+		this.options = options;
+		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;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {Ids} ids ids
+	 * @returns {ExportPresenceMode} exportPresenceMode
+	 */
+	getExportPresenceMode(parser, ids) {
+		const harmonySettings = /** @type {HarmonySettings=} */ (
+			parser.currentTagData
+		);
+		if (!harmonySettings) return this.exportPresenceMode;
+
+		const data = /** @type {HarmonySpecifierGuards=} */ (
+			parser.getTagData(harmonySettings.name, harmonySpecifierGuardTag)
+		);
+		return data && data.guards && data.guards.has(getMembersKey(ids))
+			? false
+			: this.exportPresenceMode;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		const getImportPhase = createGetImportPhase(this.options.deferImport);
+
+		/**
+		 * @param {Members} members members
+		 * @param {MembersOptionals} membersOptionals members Optionals
+		 * @returns {Ids} 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 {MemberExpression} node member expression
+		 * @param {number} count count
+		 * @returns {Expression} member expression
+		 */
+		function getNonOptionalMemberChain(node, count) {
+			while (count--) node = /** @type {MemberExpression} */ (node.object);
+			return node;
+		}
+
+		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(
+			PLUGIN_NAME,
+			(statement, source, id, name) => {
+				const ids = id === null ? [] : [id];
+				const phase = getImportPhase(parser, statement);
+				parser.tagVariable(
+					name,
+					harmonySpecifierTag,
+					/** @type {HarmonySettings} */ ({
+						name,
+						source,
+						ids,
+						sourceOrder: parser.state.lastHarmonyImportOrder,
+						attributes: getImportAttributes(statement),
+						phase
+					})
+				);
+				return true;
+			}
+		);
+		parser.hooks.binaryExpression.tap(PLUGIN_NAME, (expression) => {
+			if (expression.operator !== "in") 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 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 (
+					nameInfo &&
+					nameInfo.rootInfo instanceof VariableInfo &&
+					nameInfo.rootInfo.name &&
+					parser.getTagData(nameInfo.rootInfo.name, harmonySpecifierTag)
+				) {
+					return true;
+				}
+			}
+		);
+		parser.hooks.expression
+			.for(harmonySpecifierTag)
+			.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),
+					this.getExportPresenceMode(
+						parser,
+						getIdsForPresence(settings, settings.ids)
+					),
+					settings.phase,
+					settings.attributes,
+					[]
+				);
+				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(
+				PLUGIN_NAME,
+				(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, ...nonOptionalMembers];
+					const dep = new HarmonyImportSpecifierDependency(
+						settings.source,
+						settings.sourceOrder,
+						ids,
+						settings.name,
+						/** @type {Range} */
+						(expr.range),
+						this.getExportPresenceMode(
+							parser,
+							getIdsForPresence(settings, ids)
+						),
+						settings.phase,
+						settings.attributes,
+						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(
+				PLUGIN_NAME,
+				(expression, members, membersOptionals, memberRanges) => {
+					const { arguments: args } = expression;
+					const callee = /** @type {MemberExpression} */ (expression.callee);
+					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, ...nonOptionalMembers];
+					const dep = new HarmonyImportSpecifierDependency(
+						settings.source,
+						settings.sourceOrder,
+						ids,
+						settings.name,
+						/** @type {Range} */ (expr.range),
+						this.getExportPresenceMode(
+							parser,
+							getIdsForPresence(settings, ids)
+						),
+						settings.phase,
+						settings.attributes,
+						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(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,
+					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);
+			}
+		});
+
+		/**
+		 * @param {Expression} expression expression
+		 * @returns {{ root: string, members: Members } | undefined} info
+		 */
+		const getHarmonyImportInfo = (expression) => {
+			const nameInfo = parser.getNameForExpression(expression);
+			if (!nameInfo) return;
+
+			const rootInfo = nameInfo.rootInfo;
+			const root =
+				typeof rootInfo === "string"
+					? rootInfo
+					: rootInfo instanceof VariableInfo
+						? rootInfo.name
+						: undefined;
+			if (!root) return;
+			if (!parser.getTagData(root, harmonySpecifierTag)) return;
+			return { root, members: nameInfo.getMembers() };
+		};
+
+		/**
+		 * @param {Guards} guards guards
+		 * @param {string} root root name
+		 * @param {Members} members members
+		 */
+		const addToGuards = (guards, root, members) => {
+			const membersKey = getMembersKey(members);
+			const guardedMembers = guards.get(root);
+			if (guardedMembers) {
+				guardedMembers.add(membersKey);
+				return;
+			}
+
+			guards.set(
+				root,
+				// Adding `foo.bar` implies guarding `foo` as well
+				membersKey === "" ? new Set([""]) : new Set([membersKey, ""])
+			);
+		};
+
+		/**
+		 * @param {Expression} expression expression
+		 * @param {Guards} guards guards
+		 * @param {boolean} needTruthy need to be truthy
+		 */
+		const collect = (expression, guards, needTruthy) => {
+			// !foo
+			if (
+				expression.type === "UnaryExpression" &&
+				expression.operator === "!"
+			) {
+				collect(expression.argument, guards, !needTruthy);
+				return;
+			} else if (expression.type === "LogicalExpression" && needTruthy) {
+				// foo && bar
+				if (expression.operator === "&&") {
+					collect(expression.left, guards, true);
+					collect(expression.right, guards, true);
+				}
+				// falsy || foo
+				else if (expression.operator === "||") {
+					const leftEvaluation = parser.evaluateExpression(expression.left);
+					const leftBool = leftEvaluation.asBool();
+					if (leftBool === false) {
+						collect(expression.right, guards, true);
+					}
+				}
+				// nullish ?? foo
+				else if (expression.operator === "??") {
+					const leftEvaluation = parser.evaluateExpression(expression.left);
+					const leftNullish = leftEvaluation.asNullish();
+					if (leftNullish === true) {
+						collect(expression.right, guards, true);
+					}
+				}
+				return;
+			}
+			if (!needTruthy) return;
+
+			/**
+			 * @param {Expression} targetExpression expression
+			 * @returns {boolean} is added
+			 */
+			const addGuardForExpression = (targetExpression) => {
+				const info = getHarmonyImportInfo(targetExpression);
+				if (!info) return false;
+				addToGuards(guards, info.root, info.members);
+				return true;
+			};
+
+			/**
+			 * @param {Expression} left left expression
+			 * @param {Expression} right right expression
+			 * @param {(evaluation: ReturnType<JavascriptParser["evaluateExpression"]>) => boolean} matcher matcher
+			 * @returns {boolean} is added
+			 */
+			const addGuardForNullishCompare = (left, right, matcher) => {
+				const leftEval = parser.evaluateExpression(left);
+				if (leftEval && matcher(leftEval)) {
+					return addGuardForExpression(right);
+				}
+				const rightEval = parser.evaluateExpression(right);
+				if (rightEval && matcher(rightEval)) {
+					return addGuardForExpression(/** @type {Expression} */ (left));
+				}
+				return false;
+			};
+
+			if (expression.type === "BinaryExpression") {
+				// "bar" in foo
+				if (expression.operator === "in") {
+					const leftEvaluation = parser.evaluateExpression(expression.left);
+					if (leftEvaluation.couldHaveSideEffects()) return;
+					const propertyName = leftEvaluation.asString();
+					if (!propertyName) return;
+					parser.evaluateExpression(expression.right);
+					const info = getHarmonyImportInfo(expression.right);
+					if (!info) return;
+
+					if (info.members.length) {
+						for (const member of info.members) {
+							addToGuards(guards, info.root, [member]);
+						}
+					}
+					addToGuards(guards, info.root, [...info.members, propertyName]);
+					return;
+				}
+				// foo !== undefined
+				else if (
+					expression.operator === "!==" &&
+					addGuardForNullishCompare(
+						/** @type {Expression} */ (expression.left),
+						expression.right,
+						(evaluation) => evaluation.isUndefined()
+					)
+				) {
+					return;
+				}
+				// foo != undefined
+				// foo != null
+				else if (
+					expression.operator === "!=" &&
+					addGuardForNullishCompare(
+						/** @type {Expression} */ (expression.left),
+						expression.right,
+						(evaluation) => Boolean(evaluation.asNullish())
+					)
+				) {
+					return;
+				}
+			}
+			addGuardForExpression(expression);
+		};
+
+		/**
+		 * @param {Guards} guards guards
+		 * @param {() => void} walk walk callback
+		 * @returns {void}
+		 */
+		const withGuards = (guards, walk) => {
+			const applyGuards = () => {
+				/** @type {(() => void)[]} */
+				const restoreFns = [];
+
+				for (const [rootName, members] of guards) {
+					const previous = parser.getVariableInfo(rootName);
+					const exist = /** @type {HarmonySpecifierGuards=} */ (
+						parser.getTagData(rootName, harmonySpecifierGuardTag)
+					);
+
+					const mergedGuards =
+						exist && exist.guards
+							? exist.guards.createChild()
+							: new AppendOnlyStackedSet();
+
+					for (const memberKey of members) mergedGuards.add(memberKey);
+					parser.tagVariable(rootName, harmonySpecifierGuardTag, {
+						guards: mergedGuards
+					});
+					restoreFns.push(() => {
+						parser.setVariable(rootName, previous);
+					});
+				}
+
+				return () => {
+					for (const restore of restoreFns) {
+						restore();
+					}
+				};
+			};
+
+			const restore = applyGuards();
+			try {
+				walk();
+			} finally {
+				restore();
+			}
+		};
+
+		parser.hooks.collectGuards.tap(PLUGIN_NAME, (expression) => {
+			if (parser.scope.isAsmJs) return;
+			/** @type {Guards} */
+			const guards = new Map();
+			collect(expression, guards, true);
+
+			if (guards.size === 0) return;
+			return (walk) => {
+				withGuards(guards, walk);
+			};
+		});
+	}
+};
+
+module.exports.harmonySpecifierGuardTag = harmonySpecifierGuardTag;
+module.exports.harmonySpecifierTag = harmonySpecifierTag;