webpack 5.107.0 → 5.107.2

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 */
@@ -87,6 +88,10 @@ const parseJson = require("./util/parseJson");
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @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 +131,488 @@ 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)}`
+		);
+};
+
+// Maximum recursive descent depth before switching to the iterative walker.
+// #20986 reported overflow around 1300 modules in webpack 5.107.0 where each
+// step consumed two stack frames (`NormalModule.getSideEffectsConnectionState`
+// plus `HarmonyImportSideEffectDependency.getModuleEvaluationSideEffectsState`).
+// `walkSideEffectsRecursive` folds the second call into the first and uses
+// one frame per module, so this limit caps the native stack at half the depth
+// where the original code overflowed — well within the safe range across
+// platforms while keeping the common (shallow) case purely recursive.
+const SIDE_EFFECTS_RECURSION_LIMIT = 2000;
+
+/**
+ * Iterative form of the side-effects walker. Used as a fallback once the
+ * recursive form reaches `SIDE_EFFECTS_RECURSION_LIMIT` so deep chains
+ * (#20986) don't overflow V8's stack. Safe to enter while ancestors set
+ * `_isEvaluatingSideEffects` on their own modules — those are treated as
+ * `CIRCULAR_CONNECTION` if revisited, matching the original recursive
+ * behavior.
+ * @param {NormalModule} rootMod the module to walk
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @returns {ConnectionState} the side-effects connection state
+ */
+const walkSideEffectsIterative = (rootMod, moduleGraph) => {
+	const SideEffectDep = getHarmonyImportSideEffectDependency();
+
+	/** @type {NormalModule[]} */
+	const modStack = [rootMod];
+	/** @type {Dependency[][]} */
+	const depsStack = [rootMod.dependencies];
+	const indexStack = [0];
+	/** @type {ConnectionState[]} */
+	const currentStack = [false];
+	rootMod._isEvaluatingSideEffects = true;
+
+	/**
+	 * Result from a just-popped child frame, to be applied to the new
+	 * top's current dep. `undefined` means "no pending; advance".
+	 * @type {ConnectionState | undefined}
+	 */
+	let pending;
+
+	while (modStack.length > 0) {
+		const top = modStack.length - 1;
+		const topMod = modStack[top];
+		const deps = depsStack[top];
+		let index = indexStack[top];
+		let current = currentStack[top];
+
+		if (pending !== undefined) {
+			const state = pending;
+			pending = undefined;
+			const dep = deps[index];
+
+			if (state === true) {
+				recordSideEffectsBailout(topMod, moduleGraph, dep);
+				topMod._isEvaluatingSideEffects = false;
+				// `true` is monotonic — safe to memoize regardless of cycle
+				// status, matching the direct-bailout branch below.
+				topMod._sideEffectsStateGraph = moduleGraph;
+				topMod._sideEffectsStateValue = true;
+				modStack.pop();
+				depsStack.pop();
+				indexStack.pop();
+				currentStack.pop();
+				pending = true;
+				continue;
+			}
+			if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
+				current = ModuleGraphConnection.addConnectionStates(current, state);
+			}
+			index++;
+		}
+
+		let descended = false;
+		const depCount = deps.length;
+		while (index < depCount) {
+			const dep = deps[index];
+			/** @type {ConnectionState} */
+			let state;
+
+			if (dep instanceof SideEffectDep) {
+				const refModule = moduleGraph.getModule(dep);
+				if (!refModule) {
+					state = true;
+				} else if (refModule instanceof NormalModule) {
+					// Cache hit
+					if (refModule._sideEffectsStateGraph === moduleGraph) {
+						state = /** @type {ConnectionState} */ (
+							refModule._sideEffectsStateValue
+						);
+					}
+					// Fast-path checks inlined to avoid the helper call.
+					else if (refModule.factoryMeta !== undefined) {
+						if (refModule.factoryMeta.sideEffectFree) {
+							state = false;
+						} else if (refModule.factoryMeta.sideEffectFree === false) {
+							state = true;
+						} else if (
+							!(
+								refModule.buildMeta !== undefined &&
+								refModule.buildMeta.sideEffectFree
+							)
+						) {
+							state = true;
+						} else if (refModule._isEvaluatingSideEffects) {
+							_sideEffectsCircularSeen = true;
+							state = ModuleGraphConnection.CIRCULAR_CONNECTION;
+						} else {
+							// Descend
+							indexStack[top] = index;
+							currentStack[top] = current;
+							refModule._isEvaluatingSideEffects = true;
+							modStack.push(refModule);
+							depsStack.push(refModule.dependencies);
+							indexStack.push(0);
+							currentStack.push(false);
+							descended = true;
+							break;
+						}
+					} else if (
+						!(
+							refModule.buildMeta !== undefined &&
+							refModule.buildMeta.sideEffectFree
+						)
+					) {
+						state = true;
+					} else if (refModule._isEvaluatingSideEffects) {
+						_sideEffectsCircularSeen = true;
+						state = ModuleGraphConnection.CIRCULAR_CONNECTION;
+					} else {
+						// Descend
+						indexStack[top] = index;
+						currentStack[top] = current;
+						refModule._isEvaluatingSideEffects = true;
+						modStack.push(refModule);
+						depsStack.push(refModule.dependencies);
+						indexStack.push(0);
+						currentStack.push(false);
+						descended = true;
+						break;
+					}
+				} else {
+					_sideEffectsCircularSeen = true;
+					state = refModule.getSideEffectsConnectionState(moduleGraph);
+				}
+			} else {
+				state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
+			}
+
+			if (state === true) {
+				recordSideEffectsBailout(topMod, moduleGraph, dep);
+				topMod._isEvaluatingSideEffects = false;
+				topMod._sideEffectsStateGraph = moduleGraph;
+				topMod._sideEffectsStateValue = true;
+				modStack.pop();
+				depsStack.pop();
+				indexStack.pop();
+				currentStack.pop();
+				pending = true;
+				descended = true;
+				break;
+			}
+			if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
+				current = ModuleGraphConnection.addConnectionStates(current, state);
+			}
+			index++;
+		}
+
+		if (descended) continue;
+
+		topMod._isEvaluatingSideEffects = false;
+		if (!_sideEffectsCircularSeen) {
+			topMod._sideEffectsStateGraph = moduleGraph;
+			topMod._sideEffectsStateValue = current;
+		}
+		pending = current;
+		modStack.pop();
+		depsStack.pop();
+		indexStack.pop();
+		currentStack.pop();
+	}
+
+	return /** @type {ConnectionState} */ (pending);
+};
+
+/**
+ * Tracks whether a cycle (CIRCULAR_CONNECTION) was encountered anywhere
+ * in the currently-executing walk. The walker uses this to decide whether
+ * an intermediate result is safe to memoize on the module: a result
+ * computed in the presence of a cycle can differ from the result computed
+ * fresh, because cycle short-circuiting hides the contribution of the
+ * back-edge target. Reset to `false` at the top-level entry; read and
+ * propagated by each recursive frame.
+ */
+let _sideEffectsCircularSeen = false;
+
+/**
+ * Walks back up a stack of linear-chain ancestors, applying the result
+ * `state` of the chain's tail to each ancestor. Each ancestor in the
+ * stack had exactly one `HarmonyImportSideEffectDependency` returning
+ * `state`, so its result is just `state` (with the usual aggregation
+ * rules) and we can avoid building per-frame `current` accumulators.
+ * @param {(NormalModule | Dependency)[] | null} ancestors interleaved stack of `[mod, sideEffectDep, mod, sideEffectDep, …]` in descent order; `null` if there were none
+ * @param {ConnectionState} state result from the chain's tail
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @returns {ConnectionState} the root ancestor's result
+ */
+const propagateLinearResult = (ancestors, state, moduleGraph) => {
+	if (ancestors === null) return state;
+	while (ancestors.length > 0) {
+		const dep = /** @type {Dependency} */ (ancestors.pop());
+		const ancestor = /** @type {NormalModule} */ (ancestors.pop());
+		ancestor._isEvaluatingSideEffects = false;
+
+		if (state === true) {
+			recordSideEffectsBailout(ancestor, moduleGraph, dep);
+			// `true` is monotonic — safe to cache regardless of cycle status.
+			ancestor._sideEffectsStateGraph = moduleGraph;
+			ancestor._sideEffectsStateValue = true;
+		} else if (state === ModuleGraphConnection.CIRCULAR_CONNECTION) {
+			// CIRCULAR_CONNECTION is filtered before folding into `current`,
+			// so the ancestor's `current` stays at its initial `false`. From
+			// this point upward the propagated state is `false`, and the
+			// cycle taint prevents memoization further up (handled by
+			// `_sideEffectsCircularSeen`).
+			state = false;
+		} else if (!_sideEffectsCircularSeen) {
+			ancestor._sideEffectsStateGraph = moduleGraph;
+			ancestor._sideEffectsStateValue = state;
+		}
+	}
+	return state;
+};
+
+/**
+ * Recursive form of the side-effects walker. Folds the descent through
+ * `HarmonyImportSideEffectDependency.getModuleEvaluationSideEffectsState`
+ * directly into the loop so each module costs only one V8 stack frame
+ * (vs. two in the original recursive code).
+ *
+ * Linear-chain heads (modules with exactly one
+ * `HarmonyImportSideEffectDependency` to another `NormalModule`) are
+ * walked iteratively inside the function via an explicit
+ * `linearAncestors` stack — no additional V8 frame per descent — and
+ * their results are propagated back up by `propagateLinearResult`. This
+ * keeps stack consumption at O(1) for the common deep-import-chain
+ * pattern that motivated #20986 and also avoids the heavier iterative
+ * fallback.
+ *
+ * Falls back to `walkSideEffectsIterative` only when a *non-linear*
+ * walk reaches `SIDE_EFFECTS_RECURSION_LIMIT` — i.e. a deep tree, where
+ * each level genuinely needs its own recursion frame.
+ *
+ * Caches the result on the module when the walk did not encounter a
+ * cycle, so subsequent queries (e.g. repeated lookups during
+ * `SideEffectsFlagPlugin`'s incoming-connection optimization and its
+ * `exportInfo.getTarget` callbacks) return in O(1).
+ * @param {NormalModule} mod the module being walked
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {number} depth current recursion depth (only counts true V8 frames)
+ * @param {EXPECTED_ANY} SideEffectDep `HarmonyImportSideEffectDependency` constructor, resolved once at the public entry to avoid repeated `require` lookups in the recursive call
+ * @returns {ConnectionState} the side-effects connection state
+ */
+const walkSideEffectsRecursive = (mod, moduleGraph, depth, SideEffectDep) => {
+	// Interleaved `[mod, linearDep, mod, linearDep, …]` for the linear
+	// chain head; `null` until the first descent.
+	/** @type {(NormalModule | Dependency)[] | null} */
+	let linearAncestors = null;
+
+	// Walk the linear-chain head iteratively. Every loop iteration peels
+	// off one module without consuming a V8 stack frame.
+	while (true) {
+		if (mod._sideEffectsStateGraph === moduleGraph) {
+			return propagateLinearResult(
+				linearAncestors,
+				/** @type {ConnectionState} */ (mod._sideEffectsStateValue),
+				moduleGraph
+			);
+		}
+
+		if (mod.factoryMeta !== undefined) {
+			if (mod.factoryMeta.sideEffectFree) {
+				return propagateLinearResult(linearAncestors, false, moduleGraph);
+			}
+			if (mod.factoryMeta.sideEffectFree === false) {
+				return propagateLinearResult(linearAncestors, true, moduleGraph);
+			}
+		}
+		if (!(mod.buildMeta !== undefined && mod.buildMeta.sideEffectFree)) {
+			return propagateLinearResult(linearAncestors, true, moduleGraph);
+		}
+		if (mod._isEvaluatingSideEffects) {
+			_sideEffectsCircularSeen = true;
+			return propagateLinearResult(
+				linearAncestors,
+				ModuleGraphConnection.CIRCULAR_CONNECTION,
+				moduleGraph
+			);
+		}
+
+		// A real ESM module's `dependencies` typically include one
+		// `HarmonyImportSideEffectDependency` plus several non-recursive deps
+		// (export specifiers, const dependencies, …) that report
+		// `false`/`CIRCULAR_CONNECTION` from
+		// `getModuleEvaluationSideEffectsState`. Walk the deps in order
+		// here: as long as at most one is a `SideEffectDep` and no
+		// non-recursive dep triggers a bailout or contributes a non-`false`
+		// state, we can still tail-call iteratively through that one
+		// `SideEffectDep` — no V8 frame needed. This is what keeps the
+		// 1300-module cyclic chain from #20986 from overflowing V8's stack
+		// even though each generated module has multiple `dependencies`.
+		const deps = mod.dependencies;
+		/** @type {Dependency | null} */
+		let linearDep = null;
+		/** @type {ConnectionState} */
+		let nonRecursiveCurrent = false;
+		let linearOk = true;
+		for (let i = 0; i < deps.length; i++) {
+			const dep = deps[i];
+			if (dep instanceof SideEffectDep) {
+				if (linearDep !== null) {
+					// Two `SideEffectDep`s in the same module — fall back to
+					// the general walk so each can recurse normally.
+					linearOk = false;
+					break;
+				}
+				linearDep = dep;
+			} else {
+				const state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
+				if (state === true) {
+					recordSideEffectsBailout(mod, moduleGraph, dep);
+					mod._sideEffectsStateGraph = moduleGraph;
+					mod._sideEffectsStateValue = true;
+					return propagateLinearResult(linearAncestors, true, moduleGraph);
+				}
+				if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
+					nonRecursiveCurrent = ModuleGraphConnection.addConnectionStates(
+						nonRecursiveCurrent,
+						state
+					);
+				}
+			}
+		}
+
+		if (!linearOk || nonRecursiveCurrent !== false) {
+			// Multiple `SideEffectDep`s, or a non-recursive dep contributed
+			// a non-`false` state (e.g. `TRANSITIVE_ONLY`). The linear
+			// propagation rule "ancestor's current = chain state" no longer
+			// holds, so fall back to the general walk.
+			break;
+		}
+
+		if (linearDep === null) {
+			// No `SideEffectDep` — the module is a leaf as far as the
+			// side-effects graph is concerned. Cache and propagate `false`.
+			if (!_sideEffectsCircularSeen) {
+				mod._sideEffectsStateGraph = moduleGraph;
+				mod._sideEffectsStateValue = false;
+			}
+			return propagateLinearResult(linearAncestors, false, moduleGraph);
+		}
+
+		const refModule = moduleGraph.getModule(linearDep);
+		if (!refModule) {
+			recordSideEffectsBailout(mod, moduleGraph, linearDep);
+			mod._sideEffectsStateGraph = moduleGraph;
+			mod._sideEffectsStateValue = true;
+			return propagateLinearResult(linearAncestors, true, moduleGraph);
+		}
+		if (!(refModule instanceof NormalModule)) {
+			// Non-NormalModule's `getSideEffectsConnectionState` re-enters
+			// the public method; defer to the general walk for safety.
+			break;
+		}
+
+		mod._isEvaluatingSideEffects = true;
+		if (linearAncestors === null) linearAncestors = [];
+		// Push (mod, linearDep) so `propagateLinearResult` records bailouts
+		// against the actual `SideEffectDep` that triggered the descent —
+		// which may not be `dependencies[0]` when the module also has
+		// export / const dependencies.
+		linearAncestors.push(mod, linearDep);
+		mod = refModule;
+		continue;
+	}
+
+	// Non-linear walk. Each genuine recursive call costs one V8 frame, so
+	// honour the depth limit here.
+	if (depth >= SIDE_EFFECTS_RECURSION_LIMIT) {
+		return propagateLinearResult(
+			linearAncestors,
+			walkSideEffectsIterative(mod, moduleGraph),
+			moduleGraph
+		);
+	}
+
+	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 = walkSideEffectsRecursive(
+					refModule,
+					moduleGraph,
+					depth + 1,
+					SideEffectDep
+				);
+			} else {
+				// Non-NormalModule's `getSideEffectsConnectionState` (notably
+				// `ConcatenatedModule` delegating to its root) re-enters the
+				// public method and may walk through modules that the outer
+				// walk has marked as evaluating. We can't observe whether
+				// the inner walk hit a cycle that reflected the outer's
+				// state, so treat the walk as cycle-tainted and skip the
+				// cache for safety.
+				_sideEffectsCircularSeen = true;
+				state = refModule.getSideEffectsConnectionState(moduleGraph);
+			}
+		} else {
+			state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
+		}
+
+		if (state === true) {
+			recordSideEffectsBailout(mod, moduleGraph, dep);
+			mod._isEvaluatingSideEffects = false;
+			// `true` is monotonic — once any dep declares side effects, the
+			// answer is `true` regardless of how cycles resolve, so it's
+			// always safe to memoize.
+			mod._sideEffectsStateGraph = moduleGraph;
+			mod._sideEffectsStateValue = true;
+			return propagateLinearResult(linearAncestors, true, moduleGraph);
+		}
+		if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
+			current = ModuleGraphConnection.addConnectionStates(current, state);
+		}
+	}
+
+	mod._isEvaluatingSideEffects = false;
+
+	// Only memoize when no cycle has been observed anywhere in the walk
+	// since the public entry. A cycle anywhere can affect any ancestor's
+	// result (the back-edge target's contribution is hidden by
+	// CIRCULAR_CONNECTION short-circuiting), so this single flag is the
+	// conservative-but-cheap approximation of "this subtree's result is
+	// independent of cycle context". The public entry resets the flag.
+	if (!_sideEffectsCircularSeen) {
+		mod._sideEffectsStateGraph = moduleGraph;
+		mod._sideEffectsStateValue = current;
+	}
+	return propagateLinearResult(linearAncestors, current, moduleGraph);
+};
+
 const ABSOLUTE_PATH_REGEX = /^(?:[a-z]:\\|\\\\|\/)/i;
 
 /**
@@ -229,9 +716,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 +728,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,15 +893,25 @@ class NormalModule extends Module {
 		 */
 		this._forceBuild = true;
 		/**
-		 * @private
 		 * @type {boolean}
 		 */
 		this._isEvaluatingSideEffects = false;
 		/**
-		 * @private
 		 * @type {WeakSet<ModuleGraph> | undefined}
 		 */
 		this._addedSideEffectsBailout = undefined;
+		/**
+		 * Memoizes the result of `getSideEffectsConnectionState`. The
+		 * graph slot keys the cached value to the `ModuleGraph` it was
+		 * computed against so stale values never leak across compilations
+		 * — a walk that targets a different graph just overwrites both
+		 * slots. Populated only for results computed without encountering
+		 * a circular connection (see `walkSideEffectsRecursive`).
+		 * @type {ModuleGraph | undefined}
+		 */
+		this._sideEffectsStateGraph = undefined;
+		/** @type {ConnectionState | undefined} */
+		this._sideEffectsStateValue = undefined;
 		/**
 		 * @private
 		 * @type {CodeGenerationResultData}
@@ -521,6 +1019,11 @@ class NormalModule extends Module {
 		this.parserOptions = undefined;
 		this.generator = undefined;
 		this.generatorOptions = undefined;
+		// Drop the side-effects memoization so a long-lived module doesn't
+		// strong-reference a stale `ModuleGraph`/`Compilation` for graphs
+		// that never get re-queried with a fresh one.
+		this._sideEffectsStateGraph = undefined;
+		this._sideEffectsStateValue = undefined;
 	}
 
 	/**
@@ -693,11 +1196,8 @@ class NormalModule extends Module {
 		/** @type {NormalModuleLoaderContext<T>} */
 		const loaderContext = {
 			version: 2,
-			/**
-			 * @param {import("../declarations/LoaderContext").Schema=} schema schema
-			 * @returns {T} options
-			 */
-			getOptions: (schema) => {
+			/** @type {LoaderContext<EXPECTED_ANY>["getOptions"]} */
+			getOptions: (/** @type {EXPECTED_ANY} */ schema = undefined) => {
 				const loader = this.getCurrentLoader(
 					/** @type {AnyLoaderContext} */
 					(loaderContext)
@@ -744,6 +1244,7 @@ class NormalModule extends Module {
 
 				return /** @type {T} */ (options);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["emitWarning"]} */
 			emitWarning: (warning) => {
 				if (!(warning instanceof Error)) {
 					warning = new NonErrorEmittedError(warning);
@@ -754,6 +1255,7 @@ class NormalModule extends Module {
 					})
 				);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["emitError"]} */
 			emitError: (error) => {
 				if (!(error instanceof Error)) {
 					error = new NonErrorEmittedError(error);
@@ -764,6 +1266,7 @@ class NormalModule extends Module {
 					})
 				);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["getLogger"]} */
 			getLogger: (name) => {
 				const currentLoader = this.getCurrentLoader(
 					/** @type {AnyLoaderContext} */
@@ -775,9 +1278,11 @@ class NormalModule extends Module {
 						.join("|")
 				);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["resolve"]} */
 			resolve(context, request, callback) {
 				resolver.resolve({}, context, request, getResolveContext(), callback);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["getResolve"]} */
 			getResolve(options) {
 				const child = options ? resolver.withOptions(options) : resolver;
 				return /** @type {ReturnType<import("../declarations/LoaderContext").NormalModuleLoaderContext<T>["getResolve"]>} */ (
@@ -807,6 +1312,7 @@ class NormalModule extends Module {
 					}
 				);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["emitFile"]} */
 			emitFile: (name, content, sourceMap, assetInfo) => {
 				const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
 
@@ -1453,47 +1959,19 @@ 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);
-				}
-			}
-			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;
+		// Save and restore the cycle-tracking flag so that re-entrant calls
+		// (e.g. `ConcatenatedModule.getSideEffectsConnectionState` delegating
+		// back through here) don't clobber the outer walk's state.
+		const savedCircular = _sideEffectsCircularSeen;
+		_sideEffectsCircularSeen = false;
+		const result = walkSideEffectsRecursive(
+			this,
+			moduleGraph,
+			0,
+			getHarmonyImportSideEffectDependency()
+		);
+		_sideEffectsCircularSeen = savedCircular;
+		return result;
 	}
 
 	/**