webpack 5.107.0 → 5.107.1

package/lib/NormalModule.js

@@ -61,6 +61,7 @@ const parseJson = require("./util/parseJson");
 /** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../declarations/WebpackOptions").NoParse} NoParse */
 /** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
+/** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./Generator")} Generator */
 /** @typedef {import("./Generator").GenerateErrorFn} GenerateErrorFn */
@@ -85,8 +86,13 @@ const parseJson = require("./util/parseJson");
 /** @typedef {import("./Module").UnsafeCacheData} UnsafeCacheData */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {Iterator<SideEffectsWalk, ConnectionState, ConnectionState>} SideEffectsWalk */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 /** @typedef {import("./NormalModuleFactory").NormalModuleTypes} NormalModuleTypes */
+/** @typedef {import("./NormalModuleFactory").ParserByType} ParserByType */
+/** @typedef {import("./NormalModuleFactory").ParserOptionsByType} ParserOptionsByType */
+/** @typedef {import("./NormalModuleFactory").GeneratorByType} GeneratorByType */
+/** @typedef {import("./NormalModuleFactory").GeneratorOptionsByType} GeneratorOptionsByType */
 /** @typedef {import("./NormalModuleFactory").ResourceSchemeData} ResourceSchemeData */
 /** @typedef {import("./Parser")} Parser */
 /** @typedef {import("./Parser").PreparsedAst} PreparsedAst */
@@ -126,6 +132,87 @@ const getExtractSourceMap = memoize(() => require("./util/extractSourceMap"));
 
 const getValidate = memoize(() => require("schema-utils").validate);
 
+const getHarmonyImportSideEffectDependency = memoize(() =>
+	require("./dependencies/HarmonyImportSideEffectDependency")
+);
+
+/**
+ * @param {NormalModule} mod the module
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {Dependency} dep the dep that triggered the bailout
+ */
+const recordSideEffectsBailout = (mod, moduleGraph, dep) => {
+	if (mod._addedSideEffectsBailout === undefined) {
+		mod._addedSideEffectsBailout = new WeakSet();
+	} else if (mod._addedSideEffectsBailout.has(moduleGraph)) {
+		return;
+	}
+	mod._addedSideEffectsBailout.add(moduleGraph);
+	moduleGraph
+		.getOptimizationBailout(mod)
+		.push(
+			() =>
+				`Dependency (${dep.type}) with side effects at ${formatLocation(dep.loc)}`
+		);
+};
+
+/**
+ * Generator form of `getSideEffectsConnectionState` — descends through
+ * `HarmonyImportSideEffectDependency` via `yield` so the trampoline in
+ * `getSideEffectsConnectionState` can drive the walk iteratively (#20986).
+ * @param {NormalModule} mod the module being evaluated
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @returns {SideEffectsWalk} the generator
+ */
+function* walkSideEffects(mod, moduleGraph) {
+	if (mod.factoryMeta !== undefined) {
+		if (mod.factoryMeta.sideEffectFree) return false;
+		if (mod.factoryMeta.sideEffectFree === false) return true;
+	}
+	if (!(mod.buildMeta !== undefined && mod.buildMeta.sideEffectFree)) {
+		return true;
+	}
+	if (mod._isEvaluatingSideEffects) {
+		return ModuleGraphConnection.CIRCULAR_CONNECTION;
+	}
+
+	const SideEffectDep = getHarmonyImportSideEffectDependency();
+	mod._isEvaluatingSideEffects = true;
+	/** @type {ConnectionState} */
+	let current = false;
+
+	for (const dep of mod.dependencies) {
+		/** @type {ConnectionState} */
+		let state;
+		if (dep instanceof SideEffectDep) {
+			const refModule = moduleGraph.getModule(dep);
+			if (!refModule) {
+				state = true;
+			} else if (refModule instanceof NormalModule) {
+				state = yield walkSideEffects(refModule, moduleGraph);
+			} else {
+				state = refModule.getSideEffectsConnectionState(moduleGraph);
+			}
+		} else {
+			state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
+		}
+
+		if (state === true) {
+			recordSideEffectsBailout(mod, moduleGraph, dep);
+			mod._isEvaluatingSideEffects = false;
+			return true;
+		}
+		if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
+			current = ModuleGraphConnection.addConnectionStates(current, state);
+		}
+	}
+
+	mod._isEvaluatingSideEffects = false;
+	// When caching is implemented here, make sure to not cache when
+	// at least one circular connection was folded into `current`.
+	return current;
+}
+
 const ABSOLUTE_PATH_REGEX = /^(?:[a-z]:\\|\\\\|\/)/i;
 
 /**
@@ -229,9 +316,10 @@ const asBuffer = (input) => {
  */
 
 /**
+ * @template {NormalModuleTypes | ""} [T=NormalModuleTypes | ""]
  * @typedef {object} NormalModuleCreateData
  * @property {string=} layer an optional layer in which the module is
- * @property {NormalModuleTypes | ""} type module type. When deserializing, this is set to an empty string "".
+ * @property {T} type module type. When deserializing, this is set to an empty string "".
  * @property {string} request request string
  * @property {string} userRequest request intended by user (without loaders from config)
  * @property {string} rawRequest request without resolving
@@ -240,10 +328,10 @@ const asBuffer = (input) => {
  * @property {(ResourceSchemeData & Partial<ResolveRequest>)=} resourceResolveData resource resolve data
  * @property {string} context context directory for resolving
  * @property {string=} matchResource path + query of the matched resource (virtual)
- * @property {Parser} parser the parser used
- * @property {ParserOptions=} parserOptions the options of the parser used
- * @property {Generator} generator the generator used
- * @property {GeneratorOptions=} generatorOptions the options of the generator used
+ * @property {ParserByType[T]} parser the parser used
+ * @property {ParserOptionsByType[T]=} parserOptions the options of the parser used
+ * @property {GeneratorByType[T]} generator the generator used
+ * @property {GeneratorOptionsByType[T]=} generatorOptions the options of the generator used
  * @property {ResolveOptions=} resolveOptions options used for resolving requests from this module
  * @property {boolean} extractSourceMap enable/disable extracting source map
  */
@@ -405,12 +493,10 @@ class NormalModule extends Module {
 		 */
 		this._forceBuild = true;
 		/**
-		 * @private
 		 * @type {boolean}
 		 */
 		this._isEvaluatingSideEffects = false;
 		/**
-		 * @private
 		 * @type {WeakSet<ModuleGraph> | undefined}
 		 */
 		this._addedSideEffectsBailout = undefined;
@@ -1453,47 +1539,21 @@ class NormalModule extends Module {
 	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
 	 */
 	getSideEffectsConnectionState(moduleGraph) {
-		if (this.factoryMeta !== undefined) {
-			if (this.factoryMeta.sideEffectFree) return false;
-			if (this.factoryMeta.sideEffectFree === false) return true;
-		}
-		if (this.buildMeta !== undefined && this.buildMeta.sideEffectFree) {
-			if (this._isEvaluatingSideEffects) {
-				return ModuleGraphConnection.CIRCULAR_CONNECTION;
-			}
-			this._isEvaluatingSideEffects = true;
-			/** @type {ConnectionState} */
-			let current = false;
-			for (const dep of this.dependencies) {
-				const state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
-				if (state === true) {
-					if (
-						this._addedSideEffectsBailout === undefined
-							? ((this._addedSideEffectsBailout = new WeakSet()), true)
-							: !this._addedSideEffectsBailout.has(moduleGraph)
-					) {
-						this._addedSideEffectsBailout.add(moduleGraph);
-						moduleGraph
-							.getOptimizationBailout(this)
-							.push(
-								() =>
-									`Dependency (${
-										dep.type
-									}) with side effects at ${formatLocation(dep.loc)}`
-							);
-					}
-					this._isEvaluatingSideEffects = false;
-					return true;
-				} else if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
-					current = ModuleGraphConnection.addConnectionStates(current, state);
-				}
+		// Trampoline `walkSideEffects` so the descent doesn't consume the
+		// call stack (#20986).
+		const stack = [walkSideEffects(this, moduleGraph)];
+		/** @type {ConnectionState} */
+		let r = false;
+		while (stack.length > 0) {
+			const step = stack[stack.length - 1].next(r);
+			if (step.done) {
+				stack.pop();
+				r = step.value;
+			} else {
+				stack.push(step.value);
 			}
-			this._isEvaluatingSideEffects = false;
-			// When caching is implemented here, make sure to not cache when
-			// at least one circular connection was in the loop above
-			return current;
 		}
-		return true;
+		return r;
 	}
 
 	/**

package/lib/NormalModuleFactory.js

@@ -69,7 +69,7 @@ const {
  */
 
 /** @typedef {Pick<RuleSetRule, "type" | "sideEffects" | "parser" | "generator" | "resolve" | "layer" | "extractSourceMap">} ModuleSettings */
-/** @typedef {Partial<NormalModuleCreateData & { settings: ModuleSettings }>} CreateData */
+/** @typedef {NormalModuleCreateData & { settings: ModuleSettings }} CreateData */
 
 /**
  * Defines the resolve data type used by this module.
@@ -82,7 +82,7 @@ const {
  * @property {ImportAttributes=} attributes
  * @property {ModuleDependency[]} dependencies
  * @property {string} dependencyType
- * @property {CreateData} createData
+ * @property {Partial<CreateData>} createData
  * @property {FileSystemDependencies} fileDependencies
  * @property {FileSystemDependencies} missingDependencies
  * @property {FileSystemDependencies} contextDependencies
@@ -324,7 +324,7 @@ const ruleSetCompiler = new RuleSetCompiler([
 /** @typedef {import("./html/HtmlParser")} HtmlParser */
 /** @typedef {import("../declarations/WebpackOptions").EmptyParserOptions} HtmlParserOptions */
 /** @typedef {import("./html/HtmlGenerator")} HtmlGenerator */
-/** @typedef {import("../declarations/WebpackOptions").EmptyGeneratorOptions} HtmlGeneratorOptions */
+/** @typedef {import("../declarations/WebpackOptions").HtmlGeneratorOptions} HtmlGeneratorOptions */
 
 /* eslint-disable jsdoc/type-formatting */
 /**
@@ -339,8 +339,8 @@ const ruleSetCompiler = new RuleSetCompiler([
  * [ASSET_MODULE_TYPE_RESOURCE, AssetParser, EmptyParserOptions, AssetGenerator, AssetGeneratorOptions],
  * [ASSET_MODULE_TYPE_SOURCE, AssetSourceParser, EmptyParserOptions, AssetSourceGenerator, EmptyGeneratorOptions],
  * [ASSET_MODULE_TYPE_BYTES, AssetBytesParser, EmptyParserOptions, AssetBytesGenerator, EmptyGeneratorOptions],
- * [WEBASSEMBLY_MODULE_TYPE_ASYNC, AsyncWebAssemblyParser, EmptyParserOptions, Generator, EmptyParserOptions],
- * [WEBASSEMBLY_MODULE_TYPE_SYNC, WebAssemblyParser, EmptyParserOptions, Generator, EmptyParserOptions],
+ * [WEBASSEMBLY_MODULE_TYPE_ASYNC, AsyncWebAssemblyParser, EmptyParserOptions, Generator, EmptyGeneratorOptions],
+ * [WEBASSEMBLY_MODULE_TYPE_SYNC, WebAssemblyParser, EmptyParserOptions, Generator, EmptyGeneratorOptions],
  * [CSS_MODULE_TYPE, CssParser, CssParserOptions, CssGenerator, CssGeneratorOptions],
  * [CSS_MODULE_TYPE_AUTO, CssParser, CssModuleParserOptions, CssGenerator, CssModuleGeneratorOptions],
  * [CSS_MODULE_TYPE_MODULE, CssParser, CssModuleParserOptions, CssGenerator, CssModuleGeneratorOptions],
@@ -366,6 +366,18 @@ const ruleSetCompiler = new RuleSetCompiler([
  * @typedef {T extends [infer Head extends [string, ...unknown[]], ...infer Tail extends [string, ...unknown[]][]] ? Record<Head[0], SyncBailHook<ExtractTupleElements<Head, A>, R extends number ? Head[R] : R>> & RecordFactoryFromTuple<Tail, A, R> : unknown } RecordFactoryFromTuple
  */
 
+/**
+ * Maps each tuple in `T` to a record from its `[0]` key to its `[I]` value.
+ * @template {unknown[]} T
+ * @template {number} I
+ * @typedef {T extends [infer Head extends [string, ...unknown[]], ...infer Tail extends [string, ...unknown[]][]] ? Record<Head[0], I extends keyof Head ? Head[I] : never> & TupleToTypeMap<Tail, I> : unknown } TupleToTypeMap
+ */
+
+/** @typedef {TupleToTypeMap<ParsersAndGeneratorsByTypes, 1>} ParserByType */
+/** @typedef {TupleToTypeMap<ParsersAndGeneratorsByTypes, 2>} ParserOptionsByType */
+/** @typedef {TupleToTypeMap<ParsersAndGeneratorsByTypes, 3>} GeneratorByType */
+/** @typedef {TupleToTypeMap<ParsersAndGeneratorsByTypes, 4>} GeneratorOptionsByType */
+
 class NormalModuleFactory extends ModuleFactory {
 	/**
 	 * Creates an instance of NormalModuleFactory.
@@ -493,7 +505,9 @@ class NormalModuleFactory extends ModuleFactory {
 						// Ignored
 						if (result === false) return callback();
 
-						const createData = resolveData.createData;
+						const createData =
+							/** @type {CreateData} */
+							(resolveData.createData);
 
 						this.hooks.createModule.callAsync(
 							createData,
@@ -506,18 +520,12 @@ class NormalModuleFactory extends ModuleFactory {
 
 									// TODO webpack 6 make it required and move javascript/wasm/asset properties to own module
 									createdModule = this.hooks.createModuleClass
-										.for(
-											/** @type {ModuleSettings} */
-											(createData.settings).type
-										)
+										.for(createData.settings.type)
 										.call(createData, resolveData);
 
 									if (!createdModule) {
 										createdModule = /** @type {Module} */ (
-											new NormalModule(
-												/** @type {NormalModuleCreateData} */
-												(createData)
-											)
+											new NormalModule(createData)
 										);
 									}
 								}
@@ -1405,9 +1413,10 @@ If changing the source code is not an option there is also a resolve options cal
 
 	/**
 	 * Returns parser.
-	 * @param {string} type type
+	 * @template {string} T
+	 * @param {T} type type
 	 * @param {ParserOptions} parserOptions parser options
-	 * @returns {Parser} parser
+	 * @returns {ParserByType[T]} parser
 	 */
 	getParser(type, parserOptions = EMPTY_PARSER_OPTIONS) {
 		let cache = this.parserCache.get(type);
@@ -1424,14 +1433,15 @@ If changing the source code is not an option there is also a resolve options cal
 			cache.set(parserOptions, parser);
 		}
 
-		return parser;
+		return /** @type {ParserByType[T]} */ (parser);
 	}
 
 	/**
 	 * Creates a parser from the provided type.
-	 * @param {string} type type
+	 * @template {string} T
+	 * @param {T} type type
 	 * @param {ParserOptions} parserOptions parser options
-	 * @returns {Parser} parser
+	 * @returns {ParserByType[T]} parser
 	 */
 	createParser(type, parserOptions = {}) {
 		parserOptions = mergeGlobalOptions(
@@ -1444,14 +1454,15 @@ If changing the source code is not an option there is also a resolve options cal
 			throw new Error(`No parser registered for ${type}`);
 		}
 		this.hooks.parser.for(type).call(parser, parserOptions);
-		return parser;
+		return /** @type {ParserByType[T]} */ (parser);
 	}
 
 	/**
 	 * Returns generator.
-	 * @param {string} type type of generator
+	 * @template {string} T
+	 * @param {T} type type of generator
 	 * @param {GeneratorOptions} generatorOptions generator options
-	 * @returns {Generator} generator
+	 * @returns {GeneratorByType[T]} generator
 	 */
 	getGenerator(type, generatorOptions = EMPTY_GENERATOR_OPTIONS) {
 		let cache = this.generatorCache.get(type);
@@ -1468,14 +1479,15 @@ If changing the source code is not an option there is also a resolve options cal
 			cache.set(generatorOptions, generator);
 		}
 
-		return generator;
+		return /** @type {GeneratorByType[T]} */ (generator);
 	}
 
 	/**
 	 * Creates a generator.
-	 * @param {string} type type of generator
+	 * @template {string} T
+	 * @param {T} type type of generator
 	 * @param {GeneratorOptions} generatorOptions generator options
-	 * @returns {Generator} generator
+	 * @returns {GeneratorByType[T]} generator
 	 */
 	createGenerator(type, generatorOptions = {}) {
 		generatorOptions = mergeGlobalOptions(
@@ -1490,7 +1502,7 @@ If changing the source code is not an option there is also a resolve options cal
 			throw new Error(`No generator registered for ${type}`);
 		}
 		this.hooks.generator.for(type).call(generator, generatorOptions);
-		return generator;
+		return /** @type {GeneratorByType[T]} */ (generator);
 	}
 
 	/**

package/lib/RuntimePlugin.js

@@ -281,7 +281,7 @@ class RuntimePlugin {
 
 						if (
 							typeof publicPath !== "string" ||
-							/\[(?:full)?hash\]/.test(publicPath)
+							FULLHASH_REGEXP.test(publicPath)
 						) {
 							module.fullHash = true;
 						}