fix: mf hoist should record mutation (#11560)

Author: ahabhgk

crates/rspack_core/src/build_chunk_graph/code_splitter.rs

@@ -1498,6 +1498,9 @@ Or do you want to use the entrypoints '{name}' and '{runtime}' independently on
               compilation
                 .named_chunk_groups
                 .insert(name.to_owned(), entrypoint.ukey);
+              compilation
+                .named_chunks
+                .insert(name.to_owned(), chunk.ukey());
             }
 
             entrypoint.connect_chunk(chunk);

crates/rspack_core/src/compiler/compilation.rs

@@ -1713,41 +1713,10 @@ impl Compilation {
       for revoked_module in revoked_modules {
         self.cgm_hash_artifact.remove(&revoked_module);
       }
-      let mg = self.get_module_graph();
-      let mut modules = mutations.get_affected_modules_with_module_graph(&mg);
-      for mutation in mutations.iter() {
-        match mutation {
-          Mutation::ModuleSetAsync { module } => {
-            modules.insert(*module);
-          }
-          Mutation::ModuleSetId { module } => {
-            modules.insert(*module);
-            modules.extend(
-              mg.get_incoming_connections(module)
-                .filter_map(|c| c.original_module_identifier),
-            );
-          }
-          Mutation::ChunkAdd { chunk } => {
-            modules.extend(self.chunk_graph.get_chunk_modules_identifier(chunk));
-          }
-          Mutation::ChunkSetId { chunk } => {
-            let chunk = self.chunk_by_ukey.expect_get(chunk);
-            modules.extend(
-              chunk
-                .groups()
-                .iter()
-                .flat_map(|group| {
-                  let group = self.chunk_group_by_ukey.expect_get(group);
-                  group.origins()
-                })
-                .filter_map(|origin| origin.module),
-            );
-          }
-          _ => {}
-        }
-      }
+      let mut modules = mutations.get_affected_modules_with_chunk_graph(self);
 
       // check if module runtime changes
+      let mg = self.get_module_graph();
       for mi in mg.modules().keys() {
         let module_runtimes = self
           .chunk_graph

crates/rspack_core/src/incremental/mutations.rs

@@ -14,6 +14,7 @@ pub struct Mutations {
   inner: Vec<Mutation>,
 
   affected_modules_with_module_graph: OnceCell<IdentifierSet>,
+  affected_modules_with_chunk_graph: OnceCell<IdentifierSet>,
   affected_chunks_with_chunk_graph: OnceCell<UkeySet<ChunkUkey>>,
 }
 
@@ -136,6 +137,57 @@ impl Mutations {
       .clone()
   }
 
+  pub fn get_affected_modules_with_chunk_graph(&self, compilation: &Compilation) -> IdentifierSet {
+    self
+      .affected_modules_with_chunk_graph
+      .get_or_init(|| {
+        let mg = compilation.get_module_graph();
+        let mut modules = self.get_affected_modules_with_module_graph(&mg);
+        let mut chunks = UkeySet::default();
+        for mutation in self.iter() {
+          match mutation {
+            Mutation::ModuleSetAsync { module } => {
+              modules.insert(*module);
+            }
+            Mutation::ModuleSetId { module } => {
+              modules.insert(*module);
+              modules.extend(
+                mg.get_incoming_connections(module)
+                  .filter_map(|c| c.original_module_identifier),
+              );
+            }
+            Mutation::ChunkAdd { chunk } => {
+              chunks.insert(chunk);
+            }
+            Mutation::ChunkRemove { chunk } => {
+              chunks.remove(chunk);
+            }
+            Mutation::ChunkSetId { chunk } => {
+              let chunk = compilation.chunk_by_ukey.expect_get(chunk);
+              modules.extend(
+                chunk
+                  .groups()
+                  .iter()
+                  .flat_map(|group| {
+                    let group = compilation.chunk_group_by_ukey.expect_get(group);
+                    group.origins()
+                  })
+                  .filter_map(|origin| origin.module),
+              );
+            }
+            _ => {}
+          }
+        }
+        modules.extend(
+          chunks
+            .into_iter()
+            .flat_map(|chunk| compilation.chunk_graph.get_chunk_modules_identifier(chunk)),
+        );
+        modules
+      })
+      .clone()
+  }
+
   pub fn get_affected_chunks_with_chunk_graph(
     &self,
     compilation: &Compilation,

crates/rspack_plugin_mf/src/container/hoist_container_references_plugin.rs

@@ -19,12 +19,12 @@ use std::{
 
 use async_trait::async_trait;
 use rspack_core::{
-  Compilation, CompilationOptimizeChunks, CompilerCompilation, Dependency, DependencyId, Module,
-  ModuleIdentifier, Plugin,
+  Compilation, CompilationOptimizeChunks, CompilerCompilation, Dependency, DependencyId,
+  ModuleIdentifier, Plugin, incremental::Mutation,
 };
 use rspack_error::Result;
 use rspack_hook::{plugin, plugin_hook};
-use rustc_hash::FxHashSet;
+use rustc_hash::{FxHashMap, FxHashSet};
 
 use super::{
   container_entry_dependency::ContainerEntryDependency, fallback_dependency::FallbackDependency,
@@ -140,14 +140,13 @@ async fn optimize_chunks(&self, compilation: &mut Compilation) -> Result<Option<
   // Helper: recursively collect all referenced modules
   fn get_all_referenced_modules(
     compilation: &Compilation,
-    module: &dyn Module,
+    module_id: ModuleIdentifier,
     ty: &str,
   ) -> FxHashSet<ModuleIdentifier> {
     let mut collected = FxHashSet::default();
     let mut visited = FxHashSet::default();
     let mut stack = VecDeque::new();
 
-    let module_id = module.identifier();
     collected.insert(module_id);
     visited.insert(module_id);
     stack.push_back(module_id);
@@ -181,120 +180,82 @@ async fn optimize_chunks(&self, compilation: &mut Compilation) -> Result<Option<
     collected
   }
 
-  // Helper: get runtime chunks from entrypoints with enhanced detection
-  fn get_runtime_chunks(compilation: &Compilation) -> FxHashSet<rspack_core::ChunkUkey> {
-    let mut runtime_chunks = FxHashSet::default();
+  let mg = compilation.get_module_graph();
 
-    // Get runtime chunks from entrypoints
-    for entrypoint_ukey in compilation.entrypoints.values() {
-      if let Some(entrypoint) = compilation.chunk_group_by_ukey.get(entrypoint_ukey) {
-        let runtime_chunk = entrypoint.get_runtime_chunk(&compilation.chunk_group_by_ukey);
-        runtime_chunks.insert(runtime_chunk);
-
-        // Enhanced: Also check all chunks for runtime (similar to external PR)
-        for (chunk_ukey, chunk) in compilation.chunk_by_ukey.iter() {
-          if chunk.has_runtime(&compilation.chunk_group_by_ukey) {
-            runtime_chunks.insert(*chunk_ukey);
-          }
-        }
-      }
-    }
-
-    runtime_chunks
-  }
-
-  // Helper: clean up chunks by disconnecting unused modules
-  fn clean_up_chunks(compilation: &mut Compilation, modules: &mut FxHashSet<ModuleIdentifier>) {
-    for module_id in modules.iter() {
-      let chunks_vec: Vec<_> = compilation
+  // Collect all federation (container, runtime, and remote) referenced modules
+  let all_modules_to_hoist = self
+    .federation_deps
+    .lock()
+    .expect("Failed to lock federation deps")
+    .iter()
+    .filter_map(|dep| mg.module_identifier_by_dependency_id(dep))
+    .flat_map(|module| get_all_referenced_modules(compilation, *module, "initial"))
+    .collect::<FxHashSet<_>>();
+
+  // Hoist referenced modules to their runtime chunk
+  let entries = compilation
+    .get_chunk_graph_entries()
+    .filter_map(|entry| {
+      compilation
+        .chunk_by_ukey
+        .get(&entry)
+        .map(|chunk| (chunk.runtime(), entry))
+    })
+    .collect::<FxHashMap<_, _>>();
+  for module in &all_modules_to_hoist {
+    let runtime_chunks = compilation
+      .chunk_graph
+      .get_module_runtimes_iter(*module, &compilation.chunk_by_ukey)
+      .filter_map(|runtime_spec| entries.get(&runtime_spec).copied())
+      .collect::<Vec<_>>();
+    for runtime_chunk in runtime_chunks {
+      if !compilation
         .chunk_graph
-        .get_module_chunks(*module_id)
-        .iter()
-        .copied()
-        .collect();
-
-      for chunk_ukey in chunks_vec {
-        let chunk = compilation.chunk_by_ukey.get(&chunk_ukey);
-        let has_runtime = chunk.is_some_and(|c| c.has_runtime(&compilation.chunk_group_by_ukey));
-
-        if !has_runtime {
-          compilation
-            .chunk_graph
-            .disconnect_chunk_and_module(&chunk_ukey, *module_id);
-
-          if compilation
-            .chunk_graph
-            .get_number_of_chunk_modules(&chunk_ukey)
-            == 0
-            && compilation
-              .chunk_graph
-              .get_number_of_entry_modules(&chunk_ukey)
-              == 0
-            && let Some(mut removed_chunk) = compilation.chunk_by_ukey.remove(&chunk_ukey)
-          {
-            compilation
-              .chunk_graph
-              .disconnect_chunk(&mut removed_chunk, &mut compilation.chunk_group_by_ukey);
-            compilation.chunk_graph.remove_chunk(&chunk_ukey);
-
-            // Remove from named chunks if it has a name
-            if let Some(name) = removed_chunk.name() {
-              compilation.named_chunks.remove(name);
-            }
-          }
-        }
+        .is_module_in_chunk(module, runtime_chunk)
+      {
+        compilation
+          .chunk_graph
+          .connect_chunk_and_module(runtime_chunk, *module);
       }
     }
-    modules.clear();
   }
 
-  let _runtime_chunks = get_runtime_chunks(compilation);
-  let mut all_modules_to_hoist = FxHashSet::default();
-
-  // Process all federation dependencies (container, runtime, and remote)
-  for dep_id in self
-    .federation_deps
-    .lock()
-    .expect("Failed to lock federation deps")
-    .iter()
-  {
-    let module_graph = compilation.get_module_graph();
-    if let Some(module_id) = module_graph.module_identifier_by_dependency_id(dep_id)
-      && let Some(module) = module_graph.module_by_identifier(module_id)
-    {
-      let referenced_modules = get_all_referenced_modules(compilation, module.as_ref(), "initial");
-      all_modules_to_hoist.extend(&referenced_modules);
-
-      // Get module runtimes and hoist to runtime chunks
-      let runtime_specs: Vec<_> = compilation
+  // Disconnect hoisted modules from non-runtime chunks, this is safe since we already hoist them to runtime chunk
+  let runtime_chunks = entries.values().copied().collect::<FxHashSet<_>>();
+  for module in all_modules_to_hoist {
+    let non_runtime_chunks = compilation
+      .chunk_graph
+      .get_module_chunks(module)
+      .iter()
+      .filter(|chunk| !runtime_chunks.contains(chunk))
+      .copied()
+      .collect::<Vec<_>>();
+    for chunk in non_runtime_chunks {
+      compilation
         .chunk_graph
-        .get_module_runtimes_iter(*module_id, &compilation.chunk_by_ukey)
-        .cloned()
-        .collect();
-
-      for runtime_spec in runtime_specs {
-        // Find runtime chunks by name
-        for runtime_name in runtime_spec.iter() {
-          if let Some(runtime_chunk) = compilation.named_chunks.get(runtime_name.as_str()) {
-            for &ref_module_id in &referenced_modules {
-              if !compilation
-                .chunk_graph
-                .is_module_in_chunk(&ref_module_id, *runtime_chunk)
-              {
-                compilation
-                  .chunk_graph
-                  .connect_chunk_and_module(*runtime_chunk, ref_module_id);
-              }
-            }
-          }
+        .disconnect_chunk_and_module(&chunk, module);
+
+      if compilation.chunk_graph.get_number_of_chunk_modules(&chunk) == 0
+        && compilation.chunk_graph.get_number_of_entry_modules(&chunk) == 0
+        && let Some(mut removed_chunk) = compilation.chunk_by_ukey.remove(&chunk)
+      {
+        compilation
+          .chunk_graph
+          .disconnect_chunk(&mut removed_chunk, &mut compilation.chunk_group_by_ukey);
+        compilation.chunk_graph.remove_chunk(&chunk);
+
+        // Remove from named chunks if it has a name
+        if let Some(name) = removed_chunk.name() {
+          compilation.named_chunks.remove(name);
+        }
+        // Record mutation
+        if let Some(mutations) = compilation.incremental.mutations_write() {
+          mutations.add(Mutation::ChunkRemove { chunk });
         }
       }
     }
   }
 
-  // Cleanup: disconnect hoisted modules from non-runtime chunks
-  clean_up_chunks(compilation, &mut all_modules_to_hoist);
-
   Ok(None)
 }
 

packages/rspack-test-tools/tests/Incremental-node.test.js

@@ -36,7 +36,7 @@ describeByWalk(
 			__dirname,
 			`./js/incremental/webpack-test/hot-async-node`
 		),
-		exclude: [/require-disposed-module-warning/]
+		exclude: []
 	}
 );
 
@@ -49,6 +49,6 @@ describeByWalk(
 	{
 		source: path.resolve(__dirname, "../../../tests/webpack-test/hotCases"),
 		dist: path.resolve(__dirname, `./js/incremental/webpack-test/hot-node`),
-		exclude: [/require-disposed-module-warning/]
+		exclude: []
 	}
 );

packages/rspack-test-tools/tests/Incremental-web.test.js

@@ -32,9 +32,6 @@ describeByWalk(
 	{
 		source: path.resolve(__dirname, "../../../tests/webpack-test/hotCases"),
 		dist: path.resolve(__dirname, `./js/incremental/webpack-test/hot-web`),
-		exclude: [
-			// there is a self reference module in this case causing the make phase didn't found the module is removed
-			/require-disposed-module-warning/
-		]
+		exclude: []
 	}
 );

packages/rspack-test-tools/tests/Incremental-webworker.test.js

@@ -36,6 +36,6 @@ describeByWalk(
 			__dirname,
 			`./js/incremental/webpack-test/hot-webworker`
 		),
-		exclude: [/require-disposed-module-warning/]
+		exclude: []
 	}
 );

packages/rspack-test-tools/tests/watchCases/chunks/mf-hoisting/0/getWorker.js

@@ -0,0 +1,5 @@
+export default () => {
+	const worker = new Worker(new URL("./worker", import.meta.url));
+	worker.testName = `test worker ${WATCH_STEP}`;
+	return worker;
+};

packages/rspack-test-tools/tests/watchCases/chunks/mf-hoisting/0/index.js

@@ -0,0 +1 @@
+import("./main");

packages/rspack-test-tools/tests/watchCases/chunks/mf-hoisting/0/main.js

@@ -0,0 +1,5 @@
+import getWorker from "./getWorker";
+
+it("should have correct value", () => {
+  expect(getWorker().testName).toBe("test worker 0");
+})