webpack 5.2.1 → 5.3.0

package/lib/optimize/ConcatenatedModule.js

@@ -25,6 +25,12 @@ const createHash = require("../util/createHash");
 const contextify = require("../util/identifier").contextify;
 const makeSerializable = require("../util/makeSerializable");
 const propertyAccess = require("../util/propertyAccess");
+const {
+	filterRuntime,
+	mergeRuntime,
+	runtimeToString,
+	intersectRuntime
+} = require("../util/runtime");
 
 /** @typedef {import("eslint-scope").Scope} Scope */
 /** @typedef {import("webpack-sources").Source} Source */
@@ -103,6 +109,7 @@ const propertyAccess = require("../util/propertyAccess");
  * @typedef {Object} ExternalModuleInfo
  * @property {"external"} type
  * @property {Module} module
+ * @property {RuntimeSpec | boolean} runtimeCondition
  * @property {number} index
  * @property {string} name
  * @property {boolean} interopNamespaceObjectUsed
@@ -185,6 +192,7 @@ const joinIterableWithComma = iterable => {
  * @typedef {Object} ConcatenationEntry
  * @property {"concatenated" | "external"} type
  * @property {Module} module
+ * @property {RuntimeSpec | boolean} runtimeCondition
  */
 
 /**
@@ -586,10 +594,11 @@ class ConcatenatedModule extends Module {
 	/**
 	 * @param {Module} rootModule the root module of the concatenation
 	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
+	 * @param {RuntimeSpec} runtime the runtime
 	 * @param {Object=} associatedObjectForCache object for caching
 	 * @returns {ConcatenatedModule} the module
 	 */
-	static create(rootModule, modules, associatedObjectForCache) {
+	static create(rootModule, modules, runtime, associatedObjectForCache) {
 		const identifier = ConcatenatedModule._createIdentifier(
 			rootModule,
 			modules,
@@ -598,7 +607,8 @@ class ConcatenatedModule extends Module {
 		return new ConcatenatedModule({
 			identifier,
 			rootModule,
-			modules
+			modules,
+			runtime
 		});
 	}
 
@@ -606,9 +616,10 @@ class ConcatenatedModule extends Module {
 	 * @param {Object} options options
 	 * @param {string} options.identifier the identifier of the module
 	 * @param {Module=} options.rootModule the root module of the concatenation
+	 * @param {RuntimeSpec} options.runtime the selected runtime
 	 * @param {Set<Module>=} options.modules all concatenated modules
 	 */
-	constructor({ identifier, rootModule, modules }) {
+	constructor({ identifier, rootModule, modules, runtime }) {
 		super("javascript/esm", null);
 
 		// Info from Factory
@@ -618,6 +629,7 @@ class ConcatenatedModule extends Module {
 		this.rootModule = rootModule;
 		/** @type {Set<Module>} */
 		this._modules = modules;
+		this._runtime = runtime;
 		this.factoryMeta = rootModule && rootModule.factoryMeta;
 
 		// Caching
@@ -637,6 +649,7 @@ class ConcatenatedModule extends Module {
 		this._identifier = m._identifier;
 		this.rootModule = m.rootModule;
 		this._modules = m._modules;
+		this._runtime = m._runtime;
 	}
 	/**
 	 * @returns {Set<string>} types available (do not mutate)
@@ -789,7 +802,7 @@ class ConcatenatedModule extends Module {
 
 		/**
 		 * @param {Module} module a module
-		 * @returns {ModuleGraphConnection[]} imported modules in order
+		 * @returns {Iterable<{ connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | boolean }>} imported modules in order
 		 */
 		const getConcatenatedImports = module => {
 			let connections = Array.from(moduleGraph.getOutgoingConnections(module));
@@ -816,14 +829,38 @@ class ConcatenatedModule extends Module {
 			references.sort(
 				concatComparators(bySourceOrder, keepOriginalOrder(references))
 			);
-			return references.map(({ connection }) => connection);
+			/** @type {Map<Module, { connection, runtimeCondition }>} */
+			const referencesMap = new Map();
+			for (const { connection } of references) {
+				const runtimeCondition = filterRuntime(runtime, r =>
+					connection.isTargetActive(r)
+				);
+				const module = connection.module;
+				const entry = referencesMap.get(module);
+				if (entry === undefined) {
+					referencesMap.set(module, { connection, runtimeCondition });
+					continue;
+				}
+				if (runtimeCondition === false || entry.runtimeCondition === true)
+					continue;
+				if (entry.runtimeCondition === false || runtimeCondition === true) {
+					entry.runtimeCondition = runtimeCondition;
+					continue;
+				}
+				entry.runtimeCondition = mergeRuntime(
+					entry.runtimeCondition,
+					runtimeCondition
+				);
+			}
+			return referencesMap.values();
 		};
 
 		/**
 		 * @param {ModuleGraphConnection} connection graph connection
+		 * @param {RuntimeSpec | boolean} runtimeCondition runtime condition
 		 * @returns {void}
 		 */
-		const enterModule = connection => {
+		const enterModule = (connection, runtimeCondition) => {
 			const module = connection.module;
 			if (!module) return;
 			if (existingEntries.has(module)) {
@@ -831,11 +868,20 @@ class ConcatenatedModule extends Module {
 			}
 			if (modulesSet.has(module)) {
 				existingEntries.add(module);
+				if (runtimeCondition !== true) {
+					throw new Error(
+						`Cannot runtime-conditional concatenate a module (${module.identifier()} in ${this.rootModule.identifier()}, ${
+							runtimeCondition && runtimeToString(runtimeCondition)
+						}). This should not happen.`
+					);
+				}
 				const imports = getConcatenatedImports(module);
-				imports.forEach(enterModule);
+				for (const { connection, runtimeCondition } of imports)
+					enterModule(connection, runtimeCondition);
 				list.push({
 					type: "concatenated",
-					module: connection.module
+					module: connection.module,
+					runtimeCondition
 				});
 			} else {
 				existingEntries.add(connection.module);
@@ -846,17 +892,20 @@ class ConcatenatedModule extends Module {
 						// could be replaced by some other process (i. e. also replaced with a
 						// concatenated module)
 						return connection.module;
-					}
+					},
+					runtimeCondition
 				});
 			}
 		};
 
 		existingEntries.add(rootModule);
 		const imports = getConcatenatedImports(rootModule);
-		imports.forEach(enterModule);
+		for (const { connection, runtimeCondition } of imports)
+			enterModule(connection, runtimeCondition);
 		list.push({
 			type: "concatenated",
-			module: rootModule
+			module: rootModule,
+			runtimeCondition: true
 		});
 
 		return list;
@@ -908,10 +957,11 @@ class ConcatenatedModule extends Module {
 		runtimeTemplate,
 		moduleGraph,
 		chunkGraph,
-		runtime
+		runtime: generationRuntime
 	}) {
 		/** @type {Set<string>} */
 		const runtimeRequirements = new Set();
+		const runtime = intersectRuntime(generationRuntime, this._runtime);
 
 		const requestShortener = runtimeTemplate.requestShortener;
 		// Meta info for each module
@@ -1337,6 +1387,7 @@ ${defineGetters}`
 		// evaluate modules in order
 		for (const info of modulesWithInfo) {
 			let name;
+			let isConditional = false;
 			switch (info.type) {
 				case "concatenated": {
 					result.add(
@@ -1353,13 +1404,23 @@ ${defineGetters}`
 					name = info.namespaceObjectName;
 					break;
 				}
-				case "external":
+				case "external": {
 					result.add(
 						`\n// EXTERNAL MODULE: ${info.module.readableIdentifier(
 							requestShortener
 						)}\n`
 					);
 					runtimeRequirements.add(RuntimeGlobals.require);
+					const condition = runtimeTemplate.runtimeConditionExpression({
+						chunkGraph,
+						runtimeCondition: info.runtimeCondition,
+						runtime,
+						runtimeRequirements
+					});
+					if (condition !== "true") {
+						isConditional = true;
+						result.add(`if (${condition}) {\n`);
+					}
 					result.add(
 						`var ${info.name} = __webpack_require__(${JSON.stringify(
 							chunkGraph.getModuleId(info.module)
@@ -1367,6 +1428,7 @@ ${defineGetters}`
 					);
 					name = info.name;
 					break;
+				}
 				default:
 					// @ts-expect-error never is expected here
 					throw new Error(`Unsupported concatenation entry type ${info.type}`);
@@ -1375,7 +1437,7 @@ ${defineGetters}`
 				if (info.module.buildMeta.exportsType === "default") {
 					runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
 					result.add(
-						`\nvar ${info.interopNamespaceObjectName} = /*#__PURE__*/${RuntimeGlobals.createFakeNamespaceObject}(${name}, 2);\n`
+						`\nvar ${info.interopNamespaceObjectName} = /*#__PURE__*/${RuntimeGlobals.createFakeNamespaceObject}(${name}, 2);`
 					);
 				} else if (
 					info.module.buildMeta.exportsType === "flagged" ||
@@ -1384,16 +1446,19 @@ ${defineGetters}`
 				) {
 					runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
 					result.add(
-						`\nvar ${info.interopNamespaceObjectName} = /*#__PURE__*/${RuntimeGlobals.createFakeNamespaceObject}(${name});\n`
+						`\nvar ${info.interopNamespaceObjectName} = /*#__PURE__*/${RuntimeGlobals.createFakeNamespaceObject}(${name});`
 					);
 				}
 			}
 			if (info.interopDefaultAccessUsed) {
 				runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
 				result.add(
-					`\nvar ${info.interopDefaultAccessName} = /*#__PURE__*/${RuntimeGlobals.compatGetDefaultExport}(${name});\n`
+					`\nvar ${info.interopDefaultAccessName} = /*#__PURE__*/${RuntimeGlobals.compatGetDefaultExport}(${name});`
 				);
 			}
+			if (isConditional) {
+				result.add("\n}");
+			}
 		}
 
 		/** @type {CodeGenerationResult} */
@@ -1539,6 +1604,7 @@ ${defineGetters}`
 					return {
 						type: "external",
 						module: info.module,
+						runtimeCondition: info.runtimeCondition,
 						index,
 						name: undefined,
 						interopNamespaceObjectUsed: false,
@@ -1601,7 +1667,7 @@ ${defineGetters}`
 		for (const info of this._createConcatenationList(
 			this.rootModule,
 			this._modules,
-			runtime,
+			intersectRuntime(runtime, this._runtime),
 			chunkGraph.moduleGraph
 		)) {
 			switch (info.type) {
@@ -1620,7 +1686,8 @@ ${defineGetters}`
 		const obj = new ConcatenatedModule({
 			identifier: undefined,
 			rootModule: undefined,
-			modules: undefined
+			modules: undefined,
+			runtime: undefined
 		});
 		obj.deserialize(context);
 		return obj;

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 runtime =
+								filteredRuntime === true
+									? chunkRuntime
+									: filteredRuntime === false
+									? undefined
+									: filteredRuntime;
 
 							// create a configuration with the root
-							const currentConfiguration = new ConcatConfiguration(currentRoot);
+							const currentConfiguration = new ConcatConfiguration(
+								currentRoot,
+								runtime
+							);
 
 							// cache failures to add modules
 							const failureCache = new Map();
@@ -313,6 +332,7 @@ class ModuleConcatenationPlugin {
 								let newModule = ConcatenatedModule.create(
 									rootModule,
 									modules,
+									concatConfiguration.runtime,
 									compiler.root
 								);
 
@@ -657,6 +677,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);
@@ -689,11 +753,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;