webpack 5.59.0 → 5.94.0

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -6,30 +6,43 @@
 "use strict";
 
 const glob2regexp = require("glob-to-regexp");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC
+} = require("../ModuleTypeConstants");
 const { STAGE_DEFAULT } = require("../OptimizationStages");
 const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
 const HarmonyImportSpecifierDependency = require("../dependencies/HarmonyImportSpecifierDependency");
 const formatLocation = require("../formatLocation");
 
+/** @typedef {import("estree").ModuleDeclaration} ModuleDeclaration */
+/** @typedef {import("estree").Statement} Statement */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
 /**
- * @typedef {Object} ExportInModule
+ * @typedef {object} ExportInModule
  * @property {Module} module the module
  * @property {string} exportName the name of the export
  * @property {boolean} checked if the export is conditional
  */
 
 /**
- * @typedef {Object} ReexportInfo
+ * @typedef {object} ReexportInfo
  * @property {Map<string, ExportInModule[]>} static
  * @property {Map<Module, Set<string>>} dynamic
  */
 
-/** @type {WeakMap<any, Map<string, RegExp>>} */
+/** @typedef {Map<string, RegExp>} CacheItem */
+
+/** @type {WeakMap<any, CacheItem>} */
 const globToRegexpCache = new WeakMap();
 
 /**
@@ -45,11 +58,13 @@ const globToRegexp = (glob, cache) => {
 	}
 	const baseRegexp = glob2regexp(glob, { globstar: true, extended: true });
 	const regexpSource = baseRegexp.source;
-	const regexp = new RegExp("^(\\./)?" + regexpSource.slice(1));
+	const regexp = new RegExp(`^(\\./)?${regexpSource.slice(1)}`);
 	cache.set(glob, regexp);
 	return regexp;
 };
 
+const PLUGIN_NAME = "SideEffectsFlagPlugin";
+
 class SideEffectsFlagPlugin {
 	/**
 	 * @param {boolean} analyseSource analyse source code for side effects
@@ -57,6 +72,7 @@ class SideEffectsFlagPlugin {
 	constructor(analyseSource = true) {
 		this._analyseSource = analyseSource;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -69,67 +85,64 @@ class SideEffectsFlagPlugin {
 			globToRegexpCache.set(compiler.root, cache);
 		}
 		compiler.hooks.compilation.tap(
-			"SideEffectsFlagPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const moduleGraph = compilation.moduleGraph;
-				normalModuleFactory.hooks.module.tap(
-					"SideEffectsFlagPlugin",
-					(module, data) => {
-						const resolveData = data.resourceResolveData;
-						if (
-							resolveData &&
-							resolveData.descriptionFileData &&
-							resolveData.relativePath
-						) {
-							const sideEffects = resolveData.descriptionFileData.sideEffects;
-							if (sideEffects !== undefined) {
-								if (module.factoryMeta === undefined) {
-									module.factoryMeta = {};
-								}
-								const hasSideEffects =
-									SideEffectsFlagPlugin.moduleHasSideEffects(
-										resolveData.relativePath,
-										sideEffects,
-										cache
-									);
-								module.factoryMeta.sideEffectFree = !hasSideEffects;
-							}
-						}
-
-						return module;
-					}
-				);
-				normalModuleFactory.hooks.module.tap(
-					"SideEffectsFlagPlugin",
-					(module, data) => {
-						if (typeof data.settings.sideEffects === "boolean") {
+				normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module, data) => {
+					const resolveData = data.resourceResolveData;
+					if (
+						resolveData &&
+						resolveData.descriptionFileData &&
+						resolveData.relativePath
+					) {
+						const sideEffects = resolveData.descriptionFileData.sideEffects;
+						if (sideEffects !== undefined) {
 							if (module.factoryMeta === undefined) {
 								module.factoryMeta = {};
 							}
-							module.factoryMeta.sideEffectFree = !data.settings.sideEffects;
+							const hasSideEffects = SideEffectsFlagPlugin.moduleHasSideEffects(
+								resolveData.relativePath,
+								sideEffects,
+								/** @type {CacheItem} */ (cache)
+							);
+							module.factoryMeta.sideEffectFree = !hasSideEffects;
 						}
-						return module;
 					}
-				);
+
+					return module;
+				});
+				normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module, data) => {
+					if (typeof data.settings.sideEffects === "boolean") {
+						if (module.factoryMeta === undefined) {
+							module.factoryMeta = {};
+						}
+						module.factoryMeta.sideEffectFree = !data.settings.sideEffects;
+					}
+					return module;
+				});
 				if (this._analyseSource) {
 					/**
 					 * @param {JavascriptParser} parser the parser
 					 * @returns {void}
 					 */
 					const parserHandler = parser => {
+						/** @type {undefined | Statement | ModuleDeclaration} */
 						let sideEffectsStatement;
-						parser.hooks.program.tap("SideEffectsFlagPlugin", () => {
+						parser.hooks.program.tap(PLUGIN_NAME, () => {
 							sideEffectsStatement = undefined;
 						});
 						parser.hooks.statement.tap(
-							{ name: "SideEffectsFlagPlugin", stage: -100 },
+							{ name: PLUGIN_NAME, stage: -100 },
 							statement => {
 								if (sideEffectsStatement) return;
 								if (parser.scope.topLevelScope !== true) return;
 								switch (statement.type) {
 									case "ExpressionStatement":
 										if (
-											!parser.isPure(statement.expression, statement.range[0])
+											!parser.isPure(
+												statement.expression,
+												/** @type {Range} */ (statement.range)[0]
+											)
 										) {
 											sideEffectsStatement = statement;
 										}
@@ -137,27 +150,35 @@ class SideEffectsFlagPlugin {
 									case "IfStatement":
 									case "WhileStatement":
 									case "DoWhileStatement":
-										if (!parser.isPure(statement.test, statement.range[0])) {
+										if (
+											!parser.isPure(
+												statement.test,
+												/** @type {Range} */ (statement.range)[0]
+											)
+										) {
 											sideEffectsStatement = statement;
 										}
 										// statement hook will be called for child statements too
 										break;
 									case "ForStatement":
 										if (
-											!parser.isPure(statement.init, statement.range[0]) ||
+											!parser.isPure(
+												statement.init,
+												/** @type {Range} */ (statement.range)[0]
+											) ||
 											!parser.isPure(
 												statement.test,
 												statement.init
-													? statement.init.range[1]
-													: statement.range[0]
+													? /** @type {Range} */ (statement.init.range)[1]
+													: /** @type {Range} */ (statement.range)[0]
 											) ||
 											!parser.isPure(
 												statement.update,
 												statement.test
-													? statement.test.range[1]
+													? /** @type {Range} */ (statement.test.range)[1]
 													: statement.init
-													? statement.init.range[1]
-													: statement.range[0]
+														? /** @type {Range} */ (statement.init.range)[1]
+														: /** @type {Range} */ (statement.range)[0]
 											)
 										) {
 											sideEffectsStatement = statement;
@@ -166,7 +187,10 @@ class SideEffectsFlagPlugin {
 										break;
 									case "SwitchStatement":
 										if (
-											!parser.isPure(statement.discriminant, statement.range[0])
+											!parser.isPure(
+												statement.discriminant,
+												/** @type {Range} */ (statement.range)[0]
+											)
 										) {
 											sideEffectsStatement = statement;
 										}
@@ -175,14 +199,22 @@ class SideEffectsFlagPlugin {
 									case "VariableDeclaration":
 									case "ClassDeclaration":
 									case "FunctionDeclaration":
-										if (!parser.isPure(statement, statement.range[0])) {
+										if (
+											!parser.isPure(
+												statement,
+												/** @type {Range} */ (statement.range)[0]
+											)
+										) {
 											sideEffectsStatement = statement;
 										}
 										break;
 									case "ExportNamedDeclaration":
 									case "ExportDefaultDeclaration":
 										if (
-											!parser.isPure(statement.declaration, statement.range[0])
+											!parser.isPure(
+												statement.declaration,
+												/** @type {Range} */ (statement.range)[0]
+											)
 										) {
 											sideEffectsStatement = statement;
 										}
@@ -203,9 +235,10 @@ class SideEffectsFlagPlugin {
 								}
 							}
 						);
-						parser.hooks.finish.tap("SideEffectsFlagPlugin", () => {
+						parser.hooks.finish.tap(PLUGIN_NAME, () => {
 							if (sideEffectsStatement === undefined) {
-								parser.state.module.buildMeta.sideEffectFree = true;
+								/** @type {BuildMeta} */
+								(parser.state.module.buildMeta).sideEffectFree = true;
 							} else {
 								const { loc, type } = sideEffectsStatement;
 								moduleGraph
@@ -213,25 +246,25 @@ class SideEffectsFlagPlugin {
 									.push(
 										() =>
 											`Statement (${type}) with side effects in source code at ${formatLocation(
-												loc
+												/** @type {DependencyLocation} */ (loc)
 											)}`
 									);
 							}
 						});
 					};
 					for (const key of [
-						"javascript/auto",
-						"javascript/esm",
-						"javascript/dynamic"
+						JAVASCRIPT_MODULE_TYPE_AUTO,
+						JAVASCRIPT_MODULE_TYPE_ESM,
+						JAVASCRIPT_MODULE_TYPE_DYNAMIC
 					]) {
 						normalModuleFactory.hooks.parser
 							.for(key)
-							.tap("SideEffectsFlagPlugin", parserHandler);
+							.tap(PLUGIN_NAME, parserHandler);
 					}
 				}
 				compilation.hooks.optimizeDependencies.tap(
 					{
-						name: "SideEffectsFlagPlugin",
+						name: PLUGIN_NAME,
 						stage: STAGE_DEFAULT
 					},
 					modules => {
@@ -240,7 +273,15 @@ class SideEffectsFlagPlugin {
 						);
 
 						logger.time("update dependencies");
-						for (const module of modules) {
+
+						const optimizedModules = new Set();
+
+						/**
+						 * @param {Module} module module
+						 */
+						const optimizeIncomingConnections = module => {
+							if (optimizedModules.has(module)) return;
+							optimizedModules.add(module);
 							if (module.getSideEffectsConnectionState(moduleGraph) === false) {
 								const exportsInfo = moduleGraph.getExportsInfo(module);
 								for (const connection of moduleGraph.getIncomingConnections(
@@ -255,10 +296,13 @@ class SideEffectsFlagPlugin {
 										(dep instanceof HarmonyImportSpecifierDependency &&
 											!dep.namespaceObjectAsContext)
 									) {
+										if (connection.originModule !== null) {
+											optimizeIncomingConnections(connection.originModule);
+										}
 										// TODO improve for export *
 										if (isReexport && dep.name) {
 											const exportInfo = moduleGraph.getExportInfo(
-												connection.originModule,
+												/** @type {Module} */ (connection.originModule),
 												dep.name
 											);
 											exportInfo.moveTarget(
@@ -279,7 +323,9 @@ class SideEffectsFlagPlugin {
 															? [...exportName, ...ids.slice(1)]
 															: ids.slice(1)
 													);
-													return moduleGraph.getConnection(dep);
+													return /** @type {ModuleGraphConnection} */ (
+														moduleGraph.getConnection(dep)
+													);
 												}
 											);
 											continue;
@@ -311,6 +357,10 @@ class SideEffectsFlagPlugin {
 									}
 								}
 							}
+						};
+
+						for (const module of modules) {
+							optimizeIncomingConnections(module);
 						}
 						logger.timeEnd("update dependencies");
 					}
@@ -319,6 +369,12 @@ class SideEffectsFlagPlugin {
 		);
 	}
 
+	/**
+	 * @param {string} moduleName the module name
+	 * @param {undefined | boolean | string | string[]} flagValue the flag value
+	 * @param {Map<string, RegExp>} cache cache for glob to regexp
+	 * @returns {boolean | undefined} true, when the module has side effects, undefined or false when not
+	 */
 	static moduleHasSideEffects(moduleName, flagValue, cache) {
 		switch (typeof flagValue) {
 			case "undefined":