webpack 5.107.2 → 5.108.0

package/lib/optimize/InnerGraphPlugin.js

@@ -10,9 +10,14 @@ const {
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
+const {
+	harmonySpecifierTag
+} = require("../dependencies/HarmonyImportDependencyParserPlugin");
+const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
 const PureExpressionDependency = require("../dependencies/PureExpressionDependency");
-const InnerGraph = require("./InnerGraph");
+const { getInnerGraphUtils, topLevelSymbolTag } = require("./InnerGraph");
 
+/** @typedef {import("estree").CallExpression} CallExpression */
 /** @typedef {import("estree").ClassDeclaration} ClassDeclaration */
 /** @typedef {import("estree").ClassExpression} ClassExpression */
 /** @typedef {import("estree").Expression} Expression */
@@ -21,14 +26,16 @@ const InnerGraph = require("./InnerGraph");
 /** @typedef {import("estree").Node} Node */
 /** @typedef {import("estree").VariableDeclarator} VariableDeclarator */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("./InnerGraph").TopLevelSymbol} TopLevelSymbol */
 
-const { topLevelSymbolTag } = InnerGraph;
-
 const PLUGIN_NAME = "InnerGraphPlugin";
 const impureVariableDeclarationKinds = new Set(["using", "await using"]);
 
@@ -43,12 +50,24 @@ class InnerGraphPlugin {
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const logger = compilation.getLogger("webpack.InnerGraphPlugin");
+				const innerGraph = getInnerGraphUtils(compilation);
 
 				compilation.dependencyTemplates.set(
 					PureExpressionDependency,
 					new PureExpressionDependency.Template()
 				);
 
+				/**
+				 * Adds pure dependency added after parsing, with parents set so it survives persistent caching.
+				 * @param {Module} module module
+				 * @param {Dependency} dep pure dependency
+				 * @returns {void}
+				 */
+				const addPureDependency = (module, dep) => {
+					compilation.moduleGraph.setParents(dep, module, module, -1);
+					module.addDependency(dep);
+				};
+
 				/**
 				 * Handles the hook callback for this code path.
 				 * @param {JavascriptParser} parser the parser
@@ -61,7 +80,7 @@ class InnerGraphPlugin {
 					 * @param {Expression} sup sup
 					 */
 					const onUsageSuper = (sup) => {
-						InnerGraph.onUsage(parser.state, (usedByExports) => {
+						innerGraph.onUsage(parser.state, (usedByExports, module) => {
 							switch (usedByExports) {
 								case undefined:
 								case true:
@@ -73,7 +92,7 @@ class InnerGraphPlugin {
 									);
 									dep.loc = /** @type {DependencyLocation} */ (sup.loc);
 									dep.usedByExports = usedByExports;
-									parser.state.module.addDependency(dep);
+									addPureDependency(module, dep);
 									break;
 								}
 							}
@@ -81,21 +100,14 @@ class InnerGraphPlugin {
 					};
 
 					parser.hooks.program.tap(PLUGIN_NAME, () => {
-						InnerGraph.enable(parser.state);
+						innerGraph.enable(parser.state);
 
 						statementWithTopLevelSymbol = new WeakMap();
 						statementPurePart = new WeakMap();
 						classWithTopLevelSymbol = new WeakMap();
 						declWithTopLevelSymbol = new WeakMap();
 						pureDeclarators = new WeakSet();
-					});
-
-					parser.hooks.finish.tap(PLUGIN_NAME, () => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
-
-						logger.time("infer dependency usage");
-						InnerGraph.inferDependencyUsage(parser.state);
-						logger.timeAggregate("infer dependency usage");
+						pureConditionByCallExpr = new WeakMap();
 					});
 
 					// During prewalking the following datastructures are filled with
@@ -120,75 +132,151 @@ class InnerGraphPlugin {
 					/** @type {WeakSet<VariableDeclarator>} */
 					let pureDeclarators = new WeakSet();
 
+					/** @type {WeakMap<CallExpression, (compilation: Compilation, module: Module) => boolean>} */
+					let pureConditionByCallExpr = new WeakMap();
+
+					parser.hooks.isPure.for("CallExpression").tap(
+						{
+							name: PLUGIN_NAME,
+							stage: -10
+						},
+						(expression) => {
+							const expr = /** @type {CallExpression} */ (expression);
+							const callee = expr.callee;
+							/** @type {Node} */
+							let root;
+							/** @type {string[]} */
+							let chainMembers;
+							if (callee.type === "Identifier") {
+								root = callee;
+								chainMembers = [];
+							} else if (callee.type === "MemberExpression") {
+								const chain = parser.extractMemberExpressionChain(callee);
+								// optional chaining short-circuits and breaks straight purity
+								if (chain.membersOptionals.some(Boolean)) return;
+								root = /** @type {Node} */ (chain.object);
+								// extractMemberExpressionChain returns members in reverse
+								chainMembers = [...chain.members].reverse();
+							} else {
+								return;
+							}
+							if (root.type !== "Identifier") return;
+							const harmonySettings =
+								/** @type {{ source: string, ids: string[] } | undefined} */ (
+									parser.getTagData(root.name, harmonySpecifierTag)
+								);
+							if (!harmonySettings) return;
+							const ids = [...harmonySettings.ids, ...chainMembers];
+							if (ids.length === 0) return;
+							let pos = /** @type {Range} */ (callee.range)[1];
+							for (const arg of expr.arguments) {
+								if (arg.type === "SpreadElement") return;
+								if (!parser.isPure(arg, pos)) return;
+								pos = /** @type {Range} */ (arg.range)[1];
+							}
+							const source = harmonySettings.source;
+							pureConditionByCallExpr.set(expr, (compilation, module) => {
+								const moduleGraph = compilation.moduleGraph;
+								for (const dep of module.dependencies) {
+									if (
+										dep instanceof HarmonyImportSideEffectDependency &&
+										dep.request === source
+									) {
+										const m = moduleGraph.getModule(dep);
+										if (!m) return false;
+										const exportInfo = moduleGraph
+											.getExportsInfo(m)
+											.getReadOnlyExportInfoRecursive(ids);
+										if (!exportInfo) return false;
+										const target = exportInfo.getTarget(moduleGraph);
+										const final =
+											target && target.export
+												? moduleGraph
+														.getExportsInfo(target.module)
+														.getReadOnlyExportInfoRecursive(target.export)
+												: exportInfo;
+										return final !== undefined && final.pureProvide === true;
+									}
+								}
+								return false;
+							});
+						}
+					);
+
 					// The following hooks are used during prewalking:
 
 					parser.hooks.preStatement.tap(PLUGIN_NAME, (statement) => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
+						if (!innerGraph.isEnabled(parser.state)) return;
 
 						if (
 							parser.scope.topLevelScope === true &&
 							statement.type === "FunctionDeclaration"
 						) {
 							const name = statement.id ? statement.id.name : "*default*";
-							const symbol =
-								/** @type {TopLevelSymbol} */
-								(InnerGraph.tagTopLevelSymbol(parser, name));
+							const symbol = /** @type {TopLevelSymbol} */ (
+								innerGraph.tagTopLevelSymbol(
+									parser,
+									name,
+									parser.isPure(
+										statement,
+										/** @type {Range} */ (statement.range)[0]
+									)
+								)
+							);
 							statementWithTopLevelSymbol.set(statement, symbol);
 							return true;
 						}
 					});
 
 					parser.hooks.blockPreStatement.tap(PLUGIN_NAME, (statement) => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
+						if (!innerGraph.isEnabled(parser.state)) return;
 
 						if (parser.scope.topLevelScope === true) {
-							if (
-								statement.type === "ClassDeclaration" &&
-								parser.isPure(
+							if (statement.type === "ClassDeclaration") {
+								const name = statement.id ? statement.id.name : "*default*";
+								const pure = parser.isPure(
 									statement,
 									/** @type {Range} */ (statement.range)[0]
-								)
-							) {
-								const name = statement.id ? statement.id.name : "*default*";
+								);
 								const symbol = /** @type {TopLevelSymbol} */ (
-									InnerGraph.tagTopLevelSymbol(parser, name)
+									innerGraph.tagTopLevelSymbol(parser, name, pure)
 								);
 								classWithTopLevelSymbol.set(statement, symbol);
 								return true;
 							}
 							if (statement.type === "ExportDefaultDeclaration") {
 								const name = "*default*";
+								const decl = statement.declaration;
+								/** @type {boolean | ((compilation: Compilation, module: Module) => boolean)} */
+								let pure = parser.isPure(
+									decl,
+									/** @type {Range} */ (statement.range)[0]
+								);
+								if (!pure && decl.type === "CallExpression") {
+									const deferred = pureConditionByCallExpr.get(decl);
+									if (deferred) pure = deferred;
+								}
 								const symbol =
 									/** @type {TopLevelSymbol} */
-									(InnerGraph.tagTopLevelSymbol(parser, name));
-								const decl = statement.declaration;
+									(innerGraph.tagTopLevelSymbol(parser, name, pure));
 								if (
-									(decl.type === "ClassExpression" ||
-										decl.type === "ClassDeclaration") &&
-									parser.isPure(
-										/** @type {ClassExpression | ClassDeclaration} */
-										(decl),
-										/** @type {Range} */
-										(decl.range)[0]
-									)
+									decl.type === "ClassExpression" ||
+									decl.type === "ClassDeclaration"
 								) {
 									classWithTopLevelSymbol.set(
 										/** @type {ClassExpression | ClassDeclaration} */
 										(decl),
 										symbol
 									);
-								} else if (
-									parser.isPure(
-										/** @type {Expression} */
-										(decl),
-										/** @type {Range} */
-										(statement.range)[0]
-									)
-								) {
+								} else {
 									statementWithTopLevelSymbol.set(statement, symbol);
 									if (
+										pure &&
+										// body deferred to call-time, no eager read
 										!decl.type.endsWith("FunctionExpression") &&
+										// only FunctionDeclaration here (classes routed above), body deferred
 										!decl.type.endsWith("Declaration") &&
+										// literal references nothing
 										decl.type !== "Literal"
 									) {
 										statementPurePart.set(
@@ -203,7 +291,7 @@ class InnerGraphPlugin {
 					});
 
 					parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, statement) => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
+						if (!innerGraph.isEnabled(parser.state)) return;
 						if (impureVariableDeclarationKinds.has(statement.kind)) return;
 						if (
 							parser.scope.topLevelScope === true &&
@@ -218,28 +306,28 @@ class InnerGraphPlugin {
 							) {
 								return;
 							}
-							if (
-								decl.init.type === "ClassExpression" &&
-								parser.isPure(
-									decl.init,
-									/** @type {Range} */ (decl.id.range)[1]
-								)
-							) {
+							/** @type {boolean | ((compilation: Compilation, module: Module) => boolean)} */
+							let pure = parser.isPure(
+								decl.init,
+								/** @type {Range} */ (decl.id.range)[1]
+							);
+							if (!pure && decl.init.type === "CallExpression") {
+								const deferred = pureConditionByCallExpr.get(decl.init);
+								if (deferred) pure = deferred;
+							}
+
+							if (decl.init.type === "ClassExpression") {
 								const symbol =
 									/** @type {TopLevelSymbol} */
-									(InnerGraph.tagTopLevelSymbol(parser, name));
+									(innerGraph.tagTopLevelSymbol(parser, name, pure));
 								classWithTopLevelSymbol.set(decl.init, symbol);
-							} else if (
-								parser.isPure(
-									decl.init,
-									/** @type {Range} */ (decl.id.range)[1]
-								)
-							) {
+							} else {
 								const symbol =
 									/** @type {TopLevelSymbol} */
-									(InnerGraph.tagTopLevelSymbol(parser, name));
+									(innerGraph.tagTopLevelSymbol(parser, name, pure));
 								declWithTopLevelSymbol.set(decl, symbol);
 								if (
+									pure &&
 									!decl.init.type.endsWith("FunctionExpression") &&
 									decl.init.type !== "Literal"
 								) {
@@ -266,16 +354,16 @@ class InnerGraphPlugin {
 					// The following hooks are called during walking:
 
 					parser.hooks.statement.tap(PLUGIN_NAME, (statement) => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
+						if (!innerGraph.isEnabled(parser.state)) return;
 						if (parser.scope.topLevelScope === true) {
-							InnerGraph.setTopLevelSymbol(parser.state, undefined);
+							innerGraph.setTopLevelSymbol(parser.state, undefined);
 
 							const symbol = statementWithTopLevelSymbol.get(statement);
 							if (symbol) {
-								InnerGraph.setTopLevelSymbol(parser.state, symbol);
+								innerGraph.setTopLevelSymbol(parser.state, symbol);
 								const purePart = statementPurePart.get(statement);
 								if (purePart) {
-									InnerGraph.onUsage(parser.state, (usedByExports) => {
+									innerGraph.onUsage(parser.state, (usedByExports, module) => {
 										switch (usedByExports) {
 											case undefined:
 											case true:
@@ -288,7 +376,7 @@ class InnerGraphPlugin {
 													/** @type {DependencyLocation} */
 													(statement.loc);
 												dep.usedByExports = usedByExports;
-												parser.state.module.addDependency(dep);
+												addPureDependency(module, dep);
 												break;
 											}
 										}
@@ -301,7 +389,7 @@ class InnerGraphPlugin {
 					parser.hooks.classExtendsExpression.tap(
 						PLUGIN_NAME,
 						(expr, statement) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (!innerGraph.isEnabled(parser.state)) return;
 							if (parser.scope.topLevelScope === true) {
 								const symbol = classWithTopLevelSymbol.get(statement);
 								if (
@@ -313,7 +401,7 @@ class InnerGraphPlugin {
 											: /** @type {Range} */ (statement.range)[0]
 									)
 								) {
-									InnerGraph.setTopLevelSymbol(parser.state, symbol);
+									innerGraph.setTopLevelSymbol(parser.state, symbol);
 									onUsageSuper(expr);
 								}
 							}
@@ -323,11 +411,11 @@ class InnerGraphPlugin {
 					parser.hooks.classBodyElement.tap(
 						PLUGIN_NAME,
 						(element, classDefinition) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (!innerGraph.isEnabled(parser.state)) return;
 							if (parser.scope.topLevelScope === true) {
 								const symbol = classWithTopLevelSymbol.get(classDefinition);
 								if (symbol) {
-									InnerGraph.setTopLevelSymbol(parser.state, undefined);
+									innerGraph.setTopLevelSymbol(parser.state, undefined);
 								}
 							}
 						}
@@ -336,7 +424,7 @@ class InnerGraphPlugin {
 					parser.hooks.classBodyValue.tap(
 						PLUGIN_NAME,
 						(expression, element, classDefinition) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (!innerGraph.isEnabled(parser.state)) return;
 							if (parser.scope.topLevelScope === true) {
 								const symbol = classWithTopLevelSymbol.get(classDefinition);
 								if (symbol) {
@@ -349,29 +437,32 @@ class InnerGraphPlugin {
 												: /** @type {Range} */ (element.range)[0]
 										)
 									) {
-										InnerGraph.setTopLevelSymbol(parser.state, symbol);
+										innerGraph.setTopLevelSymbol(parser.state, symbol);
 										if (element.type !== "MethodDefinition" && element.static) {
-											InnerGraph.onUsage(parser.state, (usedByExports) => {
-												switch (usedByExports) {
-													case undefined:
-													case true:
-														return;
-													default: {
-														const dep = new PureExpressionDependency(
-															/** @type {Range} */ (expression.range)
-														);
-														dep.loc =
-															/** @type {DependencyLocation} */
-															(expression.loc);
-														dep.usedByExports = usedByExports;
-														parser.state.module.addDependency(dep);
-														break;
+											innerGraph.onUsage(
+												parser.state,
+												(usedByExports, module) => {
+													switch (usedByExports) {
+														case undefined:
+														case true:
+															return;
+														default: {
+															const dep = new PureExpressionDependency(
+																/** @type {Range} */ (expression.range)
+															);
+															dep.loc =
+																/** @type {DependencyLocation} */
+																(expression.loc);
+															dep.usedByExports = usedByExports;
+															addPureDependency(module, dep);
+															break;
+														}
 													}
 												}
-											});
+											);
 										}
 									} else {
-										InnerGraph.setTopLevelSymbol(parser.state, undefined);
+										innerGraph.setTopLevelSymbol(parser.state, undefined);
 									}
 								}
 							}
@@ -379,11 +470,11 @@ class InnerGraphPlugin {
 					);
 
 					parser.hooks.declarator.tap(PLUGIN_NAME, (decl, _statement) => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
+						if (!innerGraph.isEnabled(parser.state)) return;
 						const symbol = declWithTopLevelSymbol.get(decl);
 
 						if (symbol) {
-							InnerGraph.setTopLevelSymbol(parser.state, symbol);
+							innerGraph.setTopLevelSymbol(parser.state, symbol);
 							if (pureDeclarators.has(decl)) {
 								if (
 									/** @type {ClassExpression} */
@@ -393,7 +484,7 @@ class InnerGraphPlugin {
 										onUsageSuper(decl.init.superClass);
 									}
 								} else {
-									InnerGraph.onUsage(parser.state, (usedByExports) => {
+									innerGraph.onUsage(parser.state, (usedByExports, module) => {
 										switch (usedByExports) {
 											case undefined:
 											case true:
@@ -407,7 +498,7 @@ class InnerGraphPlugin {
 												);
 												dep.loc = /** @type {DependencyLocation} */ (decl.loc);
 												dep.usedByExports = usedByExports;
-												parser.state.module.addDependency(dep);
+												addPureDependency(module, dep);
 												break;
 											}
 										}
@@ -419,7 +510,7 @@ class InnerGraphPlugin {
 									decl.init
 								)
 							);
-							InnerGraph.setTopLevelSymbol(parser.state, undefined);
+							innerGraph.setTopLevelSymbol(parser.state, undefined);
 							return true;
 						} else if (
 							decl.id.type === "Identifier" &&
@@ -428,7 +519,7 @@ class InnerGraphPlugin {
 							classWithTopLevelSymbol.has(decl.init)
 						) {
 							parser.walkExpression(decl.init);
-							InnerGraph.setTopLevelSymbol(parser.state, undefined);
+							innerGraph.setTopLevelSymbol(parser.state, undefined);
 							return true;
 						}
 					});
@@ -439,10 +530,10 @@ class InnerGraphPlugin {
 							const topLevelSymbol = /** @type {TopLevelSymbol} */ (
 								parser.currentTagData
 							);
-							const currentTopLevelSymbol = InnerGraph.getTopLevelSymbol(
+							const currentTopLevelSymbol = innerGraph.getTopLevelSymbol(
 								parser.state
 							);
-							InnerGraph.addUsage(
+							innerGraph.addUsage(
 								parser.state,
 								topLevelSymbol,
 								currentTopLevelSymbol || true
@@ -451,7 +542,7 @@ class InnerGraphPlugin {
 					parser.hooks.assign
 						.for(topLevelSymbolTag)
 						.tap(PLUGIN_NAME, (expr) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (!innerGraph.isEnabled(parser.state)) return;
 							if (expr.operator === "=") return true;
 						});
 				};
@@ -462,8 +553,14 @@ class InnerGraphPlugin {
 					.for(JAVASCRIPT_MODULE_TYPE_ESM)
 					.tap(PLUGIN_NAME, handler);
 
-				compilation.hooks.finishModules.tap(PLUGIN_NAME, () => {
-					logger.timeAggregateEnd("infer dependency usage");
+				compilation.hooks.finishModules.tap(PLUGIN_NAME, (modules) => {
+					logger.time("infer dependency usage");
+					for (const module of modules) {
+						innerGraph.inferDependencyUsage(module);
+						// state is dead after inference; release it to not retain ASTs via callbacks
+						innerGraph.release(module);
+					}
+					logger.timeEnd("infer dependency usage");
 				});
 			}
 		);