webpack 5.2.1 → 5.4.0

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -14,7 +14,13 @@ const { STAGE_DEFAULT } = require("../OptimizationStages");
 const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
 const StackedMap = require("../util/StackedMap");
 const { compareModulesByIdentifier } = require("../util/comparators");
-const { intersectRuntime, mergeRuntimeOwned } = require("../util/runtime");
+const {
+	intersectRuntime,
+	mergeRuntimeOwned,
+	filterRuntime,
+	runtimeToString,
+	mergeRuntime
+} = require("../util/runtime");
 const ConcatenatedModule = require("./ConcatenatedModule");
 
 /** @typedef {import("../Compilation")} Compilation */
@@ -211,13 +217,26 @@ class ModuleConcatenationPlugin {
 							// the other configuration is better and we can skip this one
 							if (usedAsInner.has(currentRoot)) continue;
 
-							let runtime = undefined;
+							let chunkRuntime = undefined;
 							for (const r of chunkGraph.getModuleRuntimes(currentRoot)) {
-								runtime = mergeRuntimeOwned(runtime, r);
+								chunkRuntime = mergeRuntimeOwned(chunkRuntime, r);
 							}
+							const exportsInfo = moduleGraph.getExportsInfo(currentRoot);
+							const filteredRuntime = filterRuntime(chunkRuntime, r =>
+								exportsInfo.isModuleUsed(r)
+							);
+							const activeRuntime =
+								filteredRuntime === true
+									? chunkRuntime
+									: filteredRuntime === false
+									? undefined
+									: filteredRuntime;
 
 							// create a configuration with the root
-							const currentConfiguration = new ConcatConfiguration(currentRoot);
+							const currentConfiguration = new ConcatConfiguration(
+								currentRoot,
+								activeRuntime
+							);
 
 							// cache failures to add modules
 							const failureCache = new Map();
@@ -230,7 +249,7 @@ class ModuleConcatenationPlugin {
 							for (const imp of this._getImports(
 								compilation,
 								currentRoot,
-								runtime
+								activeRuntime
 							)) {
 								candidates.add(imp);
 							}
@@ -244,7 +263,8 @@ class ModuleConcatenationPlugin {
 									compilation,
 									currentConfiguration,
 									imp,
-									runtime,
+									chunkRuntime,
+									activeRuntime,
 									possibleInners,
 									impCandidates,
 									failureCache,
@@ -313,6 +333,7 @@ class ModuleConcatenationPlugin {
 								let newModule = ConcatenatedModule.create(
 									rootModule,
 									modules,
+									concatConfiguration.runtime,
 									compiler.root
 								);
 
@@ -478,7 +499,8 @@ class ModuleConcatenationPlugin {
 	 * @param {Compilation} compilation webpack compilation
 	 * @param {ConcatConfiguration} config concat configuration (will be modified when added)
 	 * @param {Module} module the module to be added
-	 * @param {RuntimeSpec} runtime the runtime scope
+	 * @param {RuntimeSpec} runtime the runtime scope of the generated code
+	 * @param {RuntimeSpec} activeRuntime the runtime scope of the root module
 	 * @param {Set<Module>} possibleModules modules that are candidates
 	 * @param {Set<Module>} candidates list of potential candidates (will be added to)
 	 * @param {Map<Module, Module | function(RequestShortener): string>} failureCache cache for problematic modules to be more performant
@@ -490,6 +512,7 @@ class ModuleConcatenationPlugin {
 		config,
 		module,
 		runtime,
+		activeRuntime,
 		possibleModules,
 		candidates,
 		failureCache,
@@ -657,6 +680,50 @@ class ModuleConcatenationPlugin {
 			return problem;
 		}
 
+		if (runtime !== undefined && typeof runtime !== "string") {
+			// Module must be consistently referenced in the same runtimes
+			/** @type {Map<Module, boolean | RuntimeSpec>} */
+			const runtimeConditionMap = new Map();
+			for (const connection of incomingConnections) {
+				const runtimeCondition = filterRuntime(runtime, runtime => {
+					return connection.isTargetActive(runtime);
+				});
+				if (runtimeCondition === false) continue;
+				const old = runtimeConditionMap.get(connection.originModule) || false;
+				if (old === true) continue;
+				if (old !== false && runtimeCondition !== true) {
+					runtimeConditionMap.set(
+						connection.originModule,
+						mergeRuntime(old, runtimeCondition)
+					);
+				} else {
+					runtimeConditionMap.set(connection.originModule, runtimeCondition);
+				}
+			}
+			const otherRuntimeConnections = Array.from(runtimeConditionMap).filter(
+				([, runtimeCondition]) => typeof runtimeCondition !== "boolean"
+			);
+			if (otherRuntimeConnections.length > 0) {
+				const problem = requestShortener => {
+					return `Module ${module.readableIdentifier(
+						requestShortener
+					)} is runtime-dependent referenced by these modules: ${Array.from(
+						otherRuntimeConnections,
+						([module, runtimeCondition]) =>
+							`${module.readableIdentifier(
+								requestShortener
+							)} (expected runtime ${runtimeToString(
+								runtime
+							)}, module is only referenced in ${runtimeToString(
+								/** @type {RuntimeSpec} */ (runtimeCondition)
+							)})`
+					).join(", ")}`;
+				};
+				failureCache.set(module, problem); // cache failures for performance
+				return problem;
+			}
+		}
+
 		const incomingModules = Array.from(
 			new Set(incomingConnections.map(c => c.originModule))
 		).sort(compareModulesByIdentifier);
@@ -668,6 +735,7 @@ class ModuleConcatenationPlugin {
 				config,
 				originModule,
 				runtime,
+				activeRuntime,
 				possibleModules,
 				candidates,
 				failureCache,
@@ -689,11 +757,12 @@ class ModuleConcatenationPlugin {
 
 class ConcatConfiguration {
 	/**
-	 *
 	 * @param {Module} rootModule the root module
+	 * @param {RuntimeSpec} runtime the runtime
 	 */
-	constructor(rootModule) {
+	constructor(rootModule, runtime) {
 		this.rootModule = rootModule;
+		this.runtime = runtime;
 		/** @type {StackedMap<Module, true>} */
 		this.modules = new StackedMap();
 		this.modules.set(rootModule, true);

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -50,6 +50,12 @@ const globToRegexp = (glob, cache) => {
 };
 
 class SideEffectsFlagPlugin {
+	/**
+	 * @param {boolean} analyseSource analyse source code for side effects
+	 */
+	constructor(analyseSource = true) {
+		this._analyseSource = analyseSource;
+	}
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -98,108 +104,114 @@ class SideEffectsFlagPlugin {
 				}
 				return module;
 			});
-			/**
-			 * @param {JavascriptParser} parser the parser
-			 * @returns {void}
-			 */
-			const parserHandler = parser => {
-				let hasSideEffects = false;
-				parser.hooks.program.tap("SideEffectsFlagPlugin", () => {
-					hasSideEffects = false;
-				});
-				parser.hooks.statement.tap(
-					{ name: "SideEffectsFlagPlugin", stage: -100 },
-					statement => {
-						if (hasSideEffects) return;
-						if (parser.scope.topLevelScope !== true) return;
-						switch (statement.type) {
-							case "ExpressionStatement":
-								if (!parser.isPure(statement.expression, statement.range[0])) {
-									hasSideEffects = true;
-								}
-								break;
-							case "IfStatement":
-							case "WhileStatement":
-							case "DoWhileStatement":
-								if (!parser.isPure(statement.test, statement.range[0])) {
-									hasSideEffects = true;
-								}
-								// statement hook will be called for child statements too
-								break;
-							case "ForStatement":
-								if (
-									!parser.isPure(statement.init, statement.range[0]) ||
-									!parser.isPure(
-										statement.test,
-										statement.init
-											? statement.init.range[1]
-											: statement.range[0]
-									) ||
-									!parser.isPure(
-										statement.update,
-										statement.test
-											? statement.test.range[1]
-											: statement.init
-											? statement.init.range[1]
-											: statement.range[0]
-									)
-								) {
-									hasSideEffects = true;
-								}
-								// statement hook will be called for child statements too
-								break;
-							case "SwitchStatement":
-								if (
-									!parser.isPure(statement.discriminant, statement.range[0])
-								) {
-									hasSideEffects = true;
-								}
-								// statement hook will be called for child statements too
-								break;
-							case "VariableDeclaration":
-							case "ClassDeclaration":
-							case "FunctionDeclaration":
-								if (!parser.isPure(statement, statement.range[0])) {
-									hasSideEffects = true;
-								}
-								break;
-							case "ExportDefaultDeclaration":
-								if (!parser.isPure(statement.declaration, statement.range[0])) {
-									hasSideEffects = true;
-								}
-								break;
-							case "ExportNamedDeclaration":
-								if (statement.source) {
+			if (this._analyseSource) {
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @returns {void}
+				 */
+				const parserHandler = parser => {
+					let hasSideEffects = false;
+					parser.hooks.program.tap("SideEffectsFlagPlugin", () => {
+						hasSideEffects = false;
+					});
+					parser.hooks.statement.tap(
+						{ name: "SideEffectsFlagPlugin", stage: -100 },
+						statement => {
+							if (hasSideEffects) return;
+							if (parser.scope.topLevelScope !== true) return;
+							switch (statement.type) {
+								case "ExpressionStatement":
+									if (
+										!parser.isPure(statement.expression, statement.range[0])
+									) {
+										hasSideEffects = true;
+									}
+									break;
+								case "IfStatement":
+								case "WhileStatement":
+								case "DoWhileStatement":
+									if (!parser.isPure(statement.test, statement.range[0])) {
+										hasSideEffects = true;
+									}
+									// statement hook will be called for child statements too
+									break;
+								case "ForStatement":
+									if (
+										!parser.isPure(statement.init, statement.range[0]) ||
+										!parser.isPure(
+											statement.test,
+											statement.init
+												? statement.init.range[1]
+												: statement.range[0]
+										) ||
+										!parser.isPure(
+											statement.update,
+											statement.test
+												? statement.test.range[1]
+												: statement.init
+												? statement.init.range[1]
+												: statement.range[0]
+										)
+									) {
+										hasSideEffects = true;
+									}
+									// statement hook will be called for child statements too
+									break;
+								case "SwitchStatement":
+									if (
+										!parser.isPure(statement.discriminant, statement.range[0])
+									) {
+										hasSideEffects = true;
+									}
+									// statement hook will be called for child statements too
+									break;
+								case "VariableDeclaration":
+								case "ClassDeclaration":
+								case "FunctionDeclaration":
+									if (!parser.isPure(statement, statement.range[0])) {
+										hasSideEffects = true;
+									}
+									break;
+								case "ExportDefaultDeclaration":
+									if (
+										!parser.isPure(statement.declaration, statement.range[0])
+									) {
+										hasSideEffects = true;
+									}
+									break;
+								case "ExportNamedDeclaration":
+									if (statement.source) {
+										hasSideEffects = true;
+									}
+									break;
+								case "LabeledStatement":
+								case "BlockStatement":
+									// statement hook will be called for child statements too
+									break;
+								case "EmptyStatement":
+									break;
+								case "ImportDeclaration":
+									// imports will be handled by the dependencies
+									break;
+								default:
 									hasSideEffects = true;
-								}
-								break;
-							case "LabeledStatement":
-							case "BlockStatement":
-								// statement hook will be called for child statements too
-								break;
-							case "EmptyStatement":
-								break;
-							case "ImportDeclaration":
-								// imports will be handled by the dependencies
-								break;
-							default:
-								hasSideEffects = true;
-								break;
+									break;
+							}
 						}
-					}
-				);
-				parser.hooks.finish.tap("SideEffectsFlagPlugin", () => {
-					if (!hasSideEffects) {
-						parser.state.module.buildMeta.sideEffectFree = true;
-					}
-				});
-			};
-			for (const key of [
-				"javascript/auto",
-				"javascript/esm",
-				"javascript/dynamic"
-			]) {
-				nmf.hooks.parser.for(key).tap("SideEffectsFlagPlugin", parserHandler);
+					);
+					parser.hooks.finish.tap("SideEffectsFlagPlugin", () => {
+						if (!hasSideEffects) {
+							parser.state.module.buildMeta.sideEffectFree = true;
+						}
+					});
+				};
+				for (const key of [
+					"javascript/auto",
+					"javascript/esm",
+					"javascript/dynamic"
+				]) {
+					nmf.hooks.parser.for(key).tap("SideEffectsFlagPlugin", parserHandler);
+				}
 			}
 		});
 		compiler.hooks.compilation.tap("SideEffectsFlagPlugin", compilation => {

package/lib/runtime/RuntimeIdRuntimeModule.js

@@ -0,0 +1,29 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+
+class RuntimeIdRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("runtimeId");
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { chunk, compilation } = this;
+		const { chunkGraph } = compilation;
+		const runtime = chunk.runtime;
+		if (typeof runtime !== "string")
+			throw new Error("RuntimeIdRuntimeModule must be in a single runtime");
+		const id = chunkGraph.getRuntimeId(runtime);
+		return `${RuntimeGlobals.runtimeId} = ${JSON.stringify(id)};`;
+	}
+}
+
+module.exports = RuntimeIdRuntimeModule;

package/lib/util/compileBooleanMatcher.js

@@ -25,6 +25,17 @@ const compileBooleanMatcher = map => {
 	const negativeItems = Object.keys(map).filter(i => !map[i]);
 	if (positiveItems.length === 0) return false;
 	if (negativeItems.length === 0) return true;
+	return compileBooleanMatcherFromLists(positiveItems, negativeItems);
+};
+
+/**
+ * @param {string[]} positiveItems positive items
+ * @param {string[]} negativeItems negative items
+ * @returns {function(string): string} a template function to determine the value at runtime
+ */
+const compileBooleanMatcherFromLists = (positiveItems, negativeItems) => {
+	if (positiveItems.length === 0) return () => "false";
+	if (negativeItems.length === 0) return () => "true";
 	if (positiveItems.length === 1)
 		return value => `${toSimpleString(positiveItems[0])} == ${value}`;
 	if (negativeItems.length === 1)
@@ -188,5 +199,6 @@ const itemsToRegexp = itemsArr => {
 	return `(${conditional.join("|")})`;
 };
 
+compileBooleanMatcher.fromLists = compileBooleanMatcherFromLists;
+compileBooleanMatcher.itemsToRegexp = itemsToRegexp;
 module.exports = compileBooleanMatcher;
-module.exports.itemsToRegexp = itemsToRegexp;

package/lib/util/runtime.js

@@ -11,6 +11,7 @@ const SortableSet = require("./SortableSet");
 /** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
 
 /** @typedef {string | SortableSet<string> | undefined} RuntimeSpec */
+/** @typedef {RuntimeSpec | boolean} RuntimeCondition */
 
 /**
  * @param {Compilation} compilation the compilation
@@ -104,11 +105,22 @@ const getRuntimesString = set => {
  * @param {RuntimeSpec} runtime runtime(s)
  * @returns {string} readable version
  */
-exports.runtimeToString = runtime => {
+const runtimeToString = runtime => {
 	if (runtime === undefined) return "*";
 	if (typeof runtime === "string") return runtime;
 	return runtime.getFromUnorderedCache(getRuntimesString);
 };
+exports.runtimeToString = runtimeToString;
+
+/**
+ * @param {RuntimeCondition} runtimeCondition runtime condition
+ * @returns {string} readable version
+ */
+exports.runtimeConditionToString = runtimeCondition => {
+	if (runtimeCondition === true) return "true";
+	if (runtimeCondition === false) return "false";
+	return runtimeToString(runtimeCondition);
+};
 
 /**
  * @param {RuntimeSpec} a first
@@ -203,6 +215,46 @@ const mergeRuntime = (a, b) => {
 };
 exports.mergeRuntime = mergeRuntime;
 
+/**
+ * @param {RuntimeCondition} a first
+ * @param {RuntimeCondition} b second
+ * @param {RuntimeSpec} runtime full runtime
+ * @returns {RuntimeCondition} result
+ */
+exports.mergeRuntimeCondition = (a, b, runtime) => {
+	if (a === false) return b;
+	if (b === false) return a;
+	if (a === true || b === true) return true;
+	const merged = mergeRuntime(a, b);
+	if (merged === undefined) return undefined;
+	if (typeof merged === "string") {
+		if (typeof runtime === "string" && merged === runtime) return true;
+		return merged;
+	}
+	if (typeof runtime === "string" || runtime === undefined) return merged;
+	if (merged.size === runtime.size) return true;
+	return merged;
+};
+
+/**
+ * @param {RuntimeSpec | true} a first
+ * @param {RuntimeSpec | true} b second
+ * @param {RuntimeSpec} runtime full runtime
+ * @returns {RuntimeSpec | true} result
+ */
+exports.mergeRuntimeConditionNonFalse = (a, b, runtime) => {
+	if (a === true || b === true) return true;
+	const merged = mergeRuntime(a, b);
+	if (merged === undefined) return undefined;
+	if (typeof merged === "string") {
+		if (typeof runtime === "string" && merged === runtime) return true;
+		return merged;
+	}
+	if (typeof runtime === "string" || runtime === undefined) return merged;
+	if (merged.size === runtime.size) return true;
+	return merged;
+};
+
 /**
  * @param {RuntimeSpec} a first (may be modified)
  * @param {RuntimeSpec} b second
@@ -280,6 +332,88 @@ exports.intersectRuntime = (a, b) => {
 	}
 };
 
+/**
+ * @param {RuntimeSpec} a first
+ * @param {RuntimeSpec} b second
+ * @returns {RuntimeSpec} result
+ */
+const subtractRuntime = (a, b) => {
+	if (a === undefined) {
+		return undefined;
+	} else if (b === undefined) {
+		return a;
+	} else if (a === b) {
+		return undefined;
+	} else if (typeof a === "string") {
+		if (typeof b === "string") {
+			return undefined;
+		} else if (b.has(a)) {
+			return undefined;
+		} else {
+			return a;
+		}
+	} else {
+		if (typeof b === "string") {
+			if (!a.has(b)) return a;
+			if (a.size === 2) {
+				for (const item of a) {
+					if (item !== b) return item;
+				}
+			}
+			const set = new SortableSet(a);
+			set.delete(b);
+		} else {
+			const set = new SortableSet();
+			for (const item of a) {
+				if (!b.has(item)) set.add(item);
+			}
+			if (set.size === 0) return undefined;
+			if (set.size === 1) for (const item of set) return item;
+			return set;
+		}
+	}
+};
+exports.subtractRuntime = subtractRuntime;
+
+/**
+ * @param {RuntimeCondition} a first
+ * @param {RuntimeCondition} b second
+ * @param {RuntimeSpec} runtime runtime
+ * @returns {RuntimeCondition} result
+ */
+exports.subtractRuntimeCondition = (a, b, runtime) => {
+	if (b === true) return false;
+	if (b === false) return a;
+	if (a === false) return false;
+	const result = subtractRuntime(a === true ? runtime : a, b);
+	return result === undefined ? false : result;
+};
+
+/**
+ * @param {RuntimeSpec} runtime runtime
+ * @param {function(RuntimeSpec): boolean} filter filter function
+ * @returns {boolean | RuntimeSpec} true/false if filter is constant for all runtimes, otherwise runtimes that are active
+ */
+exports.filterRuntime = (runtime, filter) => {
+	if (runtime === undefined) return filter(undefined);
+	if (typeof runtime === "string") return filter(runtime);
+	let some = false;
+	let every = true;
+	let result = undefined;
+	for (const r of runtime) {
+		const v = filter(r);
+		if (v) {
+			some = true;
+			result = mergeRuntimeOwned(result, r);
+		} else {
+			every = false;
+		}
+	}
+	if (!some) return false;
+	if (every) return true;
+	return result;
+};
+
 /**
  * @template T
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.2.1",
+  "version": "5.4.0",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",
@@ -26,9 +26,9 @@
     "pkg-dir": "^4.2.0",
     "schema-utils": "^3.0.0",
     "tapable": "^2.0.0",
-    "terser-webpack-plugin": "^5.0.0",
+    "terser-webpack-plugin": "^5.0.3",
     "watchpack": "^2.0.0",
-    "webpack-sources": "^2.1.0"
+    "webpack-sources": "^2.1.1"
   },
   "peerDependenciesMeta": {
     "webpack-cli": {
@@ -92,13 +92,12 @@
     "style-loader": "^1.1.4",
     "terser": "^4.8.0",
     "toml": "^3.0.0",
-    "tooling": "webpack/tooling#v1.8.0",
+    "tooling": "webpack/tooling#v1.8.1",
     "ts-loader": "^8.0.2",
     "typescript": "^3.9.7",
     "url-loader": "^4.1.0",
     "wast-loader": "^1.9.0",
     "webassembly-feature": "1.3.0",
-    "worker-loader": "^3.0.1",
     "xxhashjs": "^0.2.2",
     "yamljs": "^0.3.0",
     "yarn-deduplicate": "^2.1.1"

package/schemas/WebpackOptions.json

@@ -1350,8 +1350,15 @@
           "$ref": "#/definitions/OptimizationRuntimeChunk"
         },
         "sideEffects": {
-          "description": "Skip over modules which are flagged to contain no side effects when exports are not used.",
-          "type": "boolean"
+          "description": "Skip over modules which contain no side effects when exports are not used (false: disabled, 'flag': only use manually placed side effects flag, true: also analyse source code for side effects).",
+          "anyOf": [
+            {
+              "enum": ["flag"]
+            },
+            {
+              "type": "boolean"
+            }
+          ]
         },
         "splitChunks": {
           "description": "Optimize duplication and caching by splitting chunks by shared modules and cache group.",