webpack 5.108.3 → 5.109.0

package/lib/NormalModule.js

@@ -6,7 +6,6 @@
 "use strict";
 
 const querystring = require("querystring");
-const { getContext, runLoaders } = require("loader-runner");
 const {
 	AsyncSeriesBailHook,
 	HookMap,
@@ -31,6 +30,11 @@ const ModuleParseError = require("./errors/ModuleParseError");
 const ModuleWarning = require("./errors/ModuleWarning");
 const NonErrorEmittedError = require("./errors/NonErrorEmittedError");
 const UnhandledSchemeError = require("./errors/UnhandledSchemeError");
+const {
+	createLoaderContext,
+	getContext,
+	runLoaders
+} = require("./loaders/LoaderRunner");
 const LazySet = require("./util/LazySet");
 const { isSubset } = require("./util/SetHelpers");
 const { getScheme } = require("./util/URLAbsoluteSpecifier");
@@ -157,83 +161,132 @@ const recordSideEffectsBailout = (mod, moduleGraph, dep) => {
 		);
 };
 
-// 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
+ * Walks the `HarmonyImportSideEffectDependency` graph to decide how `rootMod`
+ * connects to a referrer when consumed for its side effects only.
+ *
+ * Iterative (explicit work stack) so deep import chains never approach V8's
+ * recursion limit — the overflow behind #20986 — with no separate recursive
+ * form or depth cap. Cycles use Tarjan's `index`/`lowlink`: a module's result
+ * is memoized on `_sideEffectsStateGraph` only when it is context-independent
+ * (cycle-free, or the root of its strongly-connected component), i.e. exactly
+ * when the result cannot depend on which ancestors are mid-walk.
+ *
+ * The previous walker disabled memoization for the whole walk the moment any
+ * cycle appeared (one global `circular` flag). With diamond-shaped graphs that
+ * made the walk exponential, so a single circular import could blow up an
+ * otherwise-linear graph. Per-module lowlink keeps the cycle-free majority
+ * memoized while a cycle exists elsewhere.
+ *
+ * Caching under `lowlink === index` is conservative: an imprecise lowlink can
+ * only skip caching (a later recompute yields the same value), never memoize a
+ * state that depended on stack context. `true` is monotonic and always cached.
+ * A non-`NormalModule` dependency (e.g. `ConcatenatedModule` re-entering this
+ * method) is treated as a taint so its chain is never memoized, and any module
+ * already flagged `_isEvaluatingSideEffects` (this walk or an outer re-entrant
+ * one) counts as circular, matching the previous walker.
+ * @param {NormalModule} rootMod the module being walked
  * @param {ModuleGraph} moduleGraph the module graph
- * @param {SideEffectsWalkContext} ctx per-walk cycle-tracking context
+ * @param {EXPECTED_ANY} SideEffectDep `HarmonyImportSideEffectDependency` constructor, resolved once at the entry
  * @returns {ConnectionState} the side-effects connection state
  */
-const walkSideEffectsIterative = (rootMod, moduleGraph, ctx) => {
-	const SideEffectDep = getHarmonyImportSideEffectDependency();
+const walkSideEffects = (rootMod, moduleGraph, SideEffectDep) => {
+	// Context-independent state without descending; `undefined` => walk deps.
+	/**
+	 * @param {NormalModule} mod module
+	 * @returns {ConnectionState | undefined} resolved state or undefined
+	 */
+	const quick = (mod) => {
+		if (mod._sideEffectsStateGraph === moduleGraph) {
+			return /** @type {ConnectionState} */ (mod._sideEffectsStateValue);
+		}
+		const fm = mod.factoryMeta;
+		if (fm !== undefined) {
+			if (fm.sideEffectFree) return false;
+			if (fm.sideEffectFree === false) return true;
+		}
+		if (!(mod.buildMeta !== undefined && mod.buildMeta.sideEffectFree)) {
+			return true;
+		}
+		return undefined;
+	};
 
+	const q0 = quick(rootMod);
+	if (q0 !== undefined) return q0;
+
+	/** @type {Map<NormalModule, number>} module -> Tarjan index */
+	const indexOf = new Map();
+	/** @type {Map<NormalModule, number>} module -> Tarjan lowlink */
+	const lowOf = new Map();
+	// Parallel frame arrays, to avoid a per-frame object allocation.
 	/** @type {NormalModule[]} */
-	const modStack = [rootMod];
+	const fMod = [];
 	/** @type {Dependency[][]} */
-	const depsStack = [rootMod.dependencies];
-	const indexStack = [0];
+	const fDeps = [];
+	/** @type {number[]} */
+	const fIdx = [];
 	/** @type {ConnectionState[]} */
-	const currentStack = [false];
-	rootMod._isEvaluatingSideEffects = true;
+	const fCur = [];
+	let counter = 0;
 
 	/**
-	 * Result from a just-popped child frame, to be applied to the new
-	 * top's current dep. `undefined` means "no pending; advance".
+	 * @param {NormalModule} mod module to push a frame for
+	 */
+	const enter = (mod) => {
+		indexOf.set(mod, counter);
+		lowOf.set(mod, counter);
+		counter++;
+		mod._isEvaluatingSideEffects = true;
+		fMod.push(mod);
+		fDeps.push(mod.dependencies);
+		fIdx.push(0);
+		fCur.push(false);
+	};
+
+	enter(rootMod);
+	/** @type {ConnectionState} the just-popped frame's result */
+	let result = false;
+	/**
+	 * Result of a just-popped child frame, to apply to the new top's current
+	 * dep. `undefined` means "no pending; advance normally".
 	 * @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];
+	while (fMod.length > 0) {
+		const top = fMod.length - 1;
+		const mod = fMod[top];
+		const deps = fDeps[top];
+		let i = fIdx[top];
+		let current = fCur[top];
 
+		// Apply a popped child's result to the dep that spawned it.
 		if (pending !== undefined) {
 			const state = pending;
 			pending = undefined;
-			const dep = deps[index];
-
+			const dep = deps[i];
 			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();
+				recordSideEffectsBailout(mod, moduleGraph, dep);
+				mod._sideEffectsStateGraph = moduleGraph;
+				mod._sideEffectsStateValue = true;
+				mod._isEvaluatingSideEffects = false;
+				fMod.pop();
+				fDeps.pop();
+				fIdx.pop();
+				fCur.pop();
+				result = true;
 				pending = true;
 				continue;
 			}
 			if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
 				current = ModuleGraphConnection.addConnectionStates(current, state);
 			}
-			index++;
+			i++;
 		}
 
 		let descended = false;
-		const depCount = deps.length;
-		while (index < depCount) {
-			const dep = deps[index];
+		while (i < deps.length) {
+			const dep = deps[i];
 			/** @type {ConnectionState} */
 			let state;
 
@@ -242,79 +295,53 @@ const walkSideEffectsIterative = (rootMod, moduleGraph, ctx) => {
 				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
+					if (refModule._isEvaluatingSideEffects) {
+						// On the current stack (or an outer re-entrant walk) => cycle.
+						state = ModuleGraphConnection.CIRCULAR_CONNECTION;
+						const ri = indexOf.get(refModule);
+						lowOf.set(
+							mod,
+							Math.min(
+								/** @type {number} */ (lowOf.get(mod)),
+								ri === undefined ? -1 : ri
 							)
-						) {
-							state = true;
-						} else if (refModule._isEvaluatingSideEffects) {
-							ctx.circular = true;
-							state = ModuleGraphConnection.CIRCULAR_CONNECTION;
+						);
+					} else {
+						const q = quick(refModule);
+						if (q !== undefined) {
+							state = q;
 						} else {
-							// Descend
-							indexStack[top] = index;
-							currentStack[top] = current;
-							refModule._isEvaluatingSideEffects = true;
-							modStack.push(refModule);
-							depsStack.push(refModule.dependencies);
-							indexStack.push(0);
-							currentStack.push(false);
+							// Descend: pause this frame, walk the child next.
+							fIdx[top] = i;
+							fCur[top] = current;
+							enter(refModule);
 							descended = true;
 							break;
 						}
-					} else if (
-						!(
-							refModule.buildMeta !== undefined &&
-							refModule.buildMeta.sideEffectFree
-						)
-					) {
-						state = true;
-					} else if (refModule._isEvaluatingSideEffects) {
-						ctx.circular = 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 {
-					ctx.circular = true;
+					// Non-NormalModule (e.g. ConcatenatedModule delegating back
+					// through here) resolves via a re-entrant walk that may see our
+					// in-progress modules as circular, so taint this chain: never
+					// memoize it.
 					state = refModule.getSideEffectsConnectionState(moduleGraph);
+					lowOf.set(mod, -1);
 				}
 			} 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();
+				recordSideEffectsBailout(mod, moduleGraph, dep);
+				// `true` is monotonic — always safe to memoize.
+				mod._sideEffectsStateGraph = moduleGraph;
+				mod._sideEffectsStateValue = true;
+				mod._isEvaluatingSideEffects = false;
+				fMod.pop();
+				fDeps.pop();
+				fIdx.pop();
+				fCur.pop();
+				result = true;
 				pending = true;
 				descended = true;
 				break;
@@ -322,304 +349,38 @@ const walkSideEffectsIterative = (rootMod, moduleGraph, ctx) => {
 			if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
 				current = ModuleGraphConnection.addConnectionStates(current, state);
 			}
-			index++;
+			i++;
 		}
 
 		if (descended) continue;
 
-		topMod._isEvaluatingSideEffects = false;
-		if (!ctx.circular) {
-			topMod._sideEffectsStateGraph = moduleGraph;
-			topMod._sideEffectsStateValue = current;
+		// `mod` finished without a `true` bailout.
+		mod._isEvaluatingSideEffects = false;
+		// Memoize only when the result is context-independent: no back-edge in
+		// this subtree reached above `mod` (a cycle-free module or an SCC root).
+		if (lowOf.get(mod) === indexOf.get(mod)) {
+			mod._sideEffectsStateGraph = moduleGraph;
+			mod._sideEffectsStateValue = current;
 		}
+		fMod.pop();
+		fDeps.pop();
+		fIdx.pop();
+		fCur.pop();
+		result = current;
 		pending = current;
-		modStack.pop();
-		depsStack.pop();
-		indexStack.pop();
-		currentStack.pop();
-	}
-
-	return /** @type {ConnectionState} */ (pending);
-};
-
-/**
- * @typedef {object} SideEffectsWalkContext
- * @property {boolean} circular whether a cycle was seen anywhere in this walk
- */
-
-/**
- * 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
- * @param {SideEffectsWalkContext} ctx per-walk cycle-tracking context
- * @returns {ConnectionState} the root ancestor's result
- */
-const propagateLinearResult = (ancestors, state, moduleGraph, ctx) => {
-	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
-			// `ctx.circular`).
-			state = false;
-		} else if (!ctx.circular) {
-			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
- * @param {SideEffectsWalkContext} ctx per-walk cycle-tracking context
- * @returns {ConnectionState} the side-effects connection state
- */
-const walkSideEffectsRecursive = (
-	mod,
-	moduleGraph,
-	depth,
-	SideEffectDep,
-	ctx
-) => {
-	// 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,
-				ctx
+		if (fMod.length > 0) {
+			const parent = fMod[fMod.length - 1];
+			lowOf.set(
+				parent,
+				Math.min(
+					/** @type {number} */ (lowOf.get(parent)),
+					/** @type {number} */ (lowOf.get(mod))
+				)
 			);
 		}
-
-		if (mod.factoryMeta !== undefined) {
-			if (mod.factoryMeta.sideEffectFree) {
-				return propagateLinearResult(linearAncestors, false, moduleGraph, ctx);
-			}
-			if (mod.factoryMeta.sideEffectFree === false) {
-				return propagateLinearResult(linearAncestors, true, moduleGraph, ctx);
-			}
-		}
-		if (!(mod.buildMeta !== undefined && mod.buildMeta.sideEffectFree)) {
-			return propagateLinearResult(linearAncestors, true, moduleGraph, ctx);
-		}
-		if (mod._isEvaluatingSideEffects) {
-			ctx.circular = true;
-			return propagateLinearResult(
-				linearAncestors,
-				ModuleGraphConnection.CIRCULAR_CONNECTION,
-				moduleGraph,
-				ctx
-			);
-		}
-
-		// 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, ctx);
-				}
-				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 (!ctx.circular) {
-				mod._sideEffectsStateGraph = moduleGraph;
-				mod._sideEffectsStateValue = false;
-			}
-			return propagateLinearResult(linearAncestors, false, moduleGraph, ctx);
-		}
-
-		const refModule = moduleGraph.getModule(linearDep);
-		if (!refModule) {
-			recordSideEffectsBailout(mod, moduleGraph, linearDep);
-			mod._sideEffectsStateGraph = moduleGraph;
-			mod._sideEffectsStateValue = true;
-			return propagateLinearResult(linearAncestors, true, moduleGraph, ctx);
-		}
-		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, ctx),
-			moduleGraph,
-			ctx
-		);
 	}
 
-	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,
-					ctx
-				);
-			} 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.
-				ctx.circular = 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, ctx);
-		}
-		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 (!ctx.circular) {
-		mod._sideEffectsStateGraph = moduleGraph;
-		mod._sideEffectsStateValue = current;
-	}
-	return propagateLinearResult(linearAncestors, current, moduleGraph, ctx);
+	return result;
 };
 
 /**
@@ -924,8 +685,8 @@ class NormalModule extends Module {
 		 * 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`).
+		 * slots. Populated only for context-independent results (cycle-free
+		 * or SCC-root modules; see `walkSideEffects`).
 		 * @type {ModuleGraph | undefined}
 		 */
 		this._sideEffectsStateGraph = undefined;
@@ -1380,6 +1141,7 @@ class NormalModule extends Module {
 		};
 
 		Object.assign(loaderContext, options.loader);
+		createLoaderContext(loaderContext);
 
 		hooks.loader.call(
 			/** @type {AnyLoaderContext} */
@@ -1677,6 +1439,9 @@ class NormalModule extends Module {
 					buildDependencies.add(loader.loader);
 				}
 				buildInfo.cacheable = buildInfo.cacheable && result.cacheable;
+				if (result.notCacheableReasons.length > 0) {
+					buildInfo.notCacheableReasons = result.notCacheableReasons;
+				}
 				processResult(err, result.result);
 			}
 		);
@@ -1783,6 +1548,7 @@ class NormalModule extends Module {
 		};
 		this.buildInfo = {
 			cacheable: false,
+			notCacheableReasons: undefined,
 			parsed: true,
 			fileDependencies: undefined,
 			contextDependencies: undefined,
@@ -1998,15 +1764,13 @@ class NormalModule extends Module {
 	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
 	 */
 	getSideEffectsConnectionState(moduleGraph) {
-		// Fresh per-walk context; re-entrant calls (e.g.
+		// Each call owns its Tarjan bookkeeping; re-entrant calls (e.g.
 		// `ConcatenatedModule.getSideEffectsConnectionState` delegating back
-		// through here) get their own and can't clobber the outer walk.
-		return walkSideEffectsRecursive(
+		// through here) can't clobber the outer walk.
+		return walkSideEffects(
 			this,
 			moduleGraph,
-			0,
-			getHarmonyImportSideEffectDependency(),
-			{ circular: false }
+			getHarmonyImportSideEffectDependency()
 		);
 	}