fix(incremental): wrong runtime module when rebuild (#8504)

crates/rspack_core/src/compiler/compilation.rs

@@ -963,7 +963,9 @@ impl Compilation {
       self
         .chunk_render_results
         .retain(|chunk, _| self.chunk_by_ukey.contains(chunk));
-      mutations.get_affected_chunks_with_chunk_graph(self)
+      let mut chunks = mutations.get_affected_chunks_with_chunk_graph(self);
+      chunks.extend(self.get_chunk_graph_entries());
+      chunks
     } else {
       self.chunk_by_ukey.keys().copied().collect()
     };
@@ -1332,33 +1334,36 @@ impl Compilation {
         plugin_driver.clone(),
       )
       .await?;
+    let runtime_chunks = self.get_chunk_graph_entries().collect();
     let process_runtime_requirements_chunks = if let Some(mutations) = self
       .incremental
       .mutations_read(IncrementalPasses::CHUNKS_RUNTIME_REQUIREMENTS)
     {
       let removed_chunks = mutations.iter().filter_map(|mutation| match mutation {
-        Mutation::ChunkRemove { chunk } => Some(*chunk),
+        Mutation::ChunkRemove { chunk } => Some(chunk),
         _ => None,
       });
       for removed_chunk in removed_chunks {
-        self.cgc_runtime_requirements_results.remove(&removed_chunk);
+        self.cgc_runtime_requirements_results.remove(removed_chunk);
+      }
+      let affected_chunks = mutations.get_affected_chunks_with_chunk_graph(self);
+      for affected_chunk in &affected_chunks {
+        self.cgc_runtime_requirements_results.remove(affected_chunk);
+      }
+      for runtime_chunk in &runtime_chunks {
+        self.cgc_runtime_requirements_results.remove(runtime_chunk);
       }
       self
         .cgc_runtime_requirements_results
         .retain(|chunk, _| self.chunk_by_ukey.contains(chunk));
-      mutations.get_affected_chunks_with_chunk_graph(self)
+      affected_chunks
     } else {
       self.chunk_by_ukey.keys().copied().collect()
     };
     self
       .process_chunks_runtime_requirements(
         process_runtime_requirements_chunks,
-        plugin_driver.clone(),
-      )
-      .await?;
-    self
-      .process_entries_runtime_requirements(
-        self.get_chunk_graph_entries().into_iter(),
+        runtime_chunks,
         plugin_driver.clone(),
       )
       .await?;
@@ -1457,7 +1462,7 @@ impl Compilation {
     }
   }
 
-  pub fn get_chunk_graph_entries(&self) -> UkeySet<ChunkUkey> {
+  pub fn get_chunk_graph_entries(&self) -> impl Iterator<Item = ChunkUkey> + use<'_> {
     let entries = self.entrypoints.values().map(|entrypoint_ukey| {
       let entrypoint = self.chunk_group_by_ukey.expect_get(entrypoint_ukey);
       entrypoint.get_runtime_chunk(&self.chunk_group_by_ukey)
@@ -1466,7 +1471,7 @@ impl Compilation {
       let entrypoint = self.chunk_group_by_ukey.expect_get(entrypoint_ukey);
       entrypoint.get_runtime_chunk(&self.chunk_group_by_ukey)
     });
-    entries.chain(async_entries).collect()
+    entries.chain(async_entries)
   }
 
   #[instrument(skip_all)]
@@ -1527,18 +1532,19 @@ impl Compilation {
   pub async fn process_chunks_runtime_requirements(
     &mut self,
     chunks: UkeySet<ChunkUkey>,
+    entries: UkeySet<ChunkUkey>,
     plugin_driver: SharedPluginDriver,
   ) -> Result<()> {
     let logger = self.get_logger("rspack.Compilation");
     let start = logger.time("runtime requirements.chunks");
     let mut chunk_requirements = HashMap::default();
-    for chunk_ukey in chunks {
+    for chunk_ukey in chunks.iter().chain(entries.iter()) {
       let mut set = RuntimeGlobals::default();
       for module in self
         .chunk_graph
-        .get_chunk_modules(&chunk_ukey, &self.get_module_graph())
+        .get_chunk_modules(chunk_ukey, &self.get_module_graph())
       {
-        let chunk = self.chunk_by_ukey.expect_get(&chunk_ukey);
+        let chunk = self.chunk_by_ukey.expect_get(chunk_ukey);
         if let Some(runtime_requirements) =
           ChunkGraph::get_module_runtime_requirements(self, module.identifier(), chunk.runtime())
         {
@@ -1551,24 +1557,15 @@ impl Compilation {
       plugin_driver
         .compilation_hooks
         .additional_chunk_runtime_requirements
-        .call(self, &chunk_ukey, &mut set)?;
+        .call(self, chunk_ukey, &mut set)?;
 
-      ChunkGraph::set_chunk_runtime_requirements(self, chunk_ukey, set);
+      ChunkGraph::set_chunk_runtime_requirements(self, *chunk_ukey, set);
     }
     logger.time_end(start);
-    Ok(())
-  }
 
-  #[instrument(skip_all)]
-  pub async fn process_entries_runtime_requirements(
-    &mut self,
-    chunk_graph_entries: impl Iterator<Item = ChunkUkey>,
-    plugin_driver: SharedPluginDriver,
-  ) -> Result<()> {
-    let logger = self.get_logger("rspack.Compilation");
     let start = logger.time("runtime requirements.entries");
-    for entry_ukey in chunk_graph_entries {
-      let entry = self.chunk_by_ukey.expect_get(&entry_ukey);
+    for entry_ukey in &entries {
+      let entry = self.chunk_by_ukey.expect_get(entry_ukey);
       let mut set = RuntimeGlobals::default();
       for chunk_ukey in entry
         .get_all_referenced_chunks(&self.chunk_group_by_ukey)
@@ -1581,7 +1578,7 @@ impl Compilation {
       plugin_driver
         .compilation_hooks
         .additional_tree_runtime_requirements
-        .call(self, &entry_ukey, &mut set)
+        .call(self, entry_ukey, &mut set)
         .await?;
 
       process_runtime_requirement_hook(
@@ -1592,7 +1589,7 @@ impl Compilation {
             .runtime_requirement_in_tree
             .call(
               self,
-              &entry_ukey,
+              entry_ukey,
               all_runtime_requirements,
               runtime_requirements,
               runtime_requirements_mut,
@@ -1601,25 +1598,23 @@ impl Compilation {
         },
       )?;
 
-      ChunkGraph::set_tree_runtime_requirements(self, entry_ukey, set);
+      ChunkGraph::set_tree_runtime_requirements(self, *entry_ukey, set);
     }
 
     // NOTE: webpack runs hooks.runtime_module in compilation.add_runtime_module
     // and overwrite the runtime_module.generate() to get new source in create_chunk_assets
     // this needs full runtime requirements, so run hooks.runtime_module after runtime_requirements_in_tree
-    for entry_ukey in self.get_chunk_graph_entries() {
+    for entry_ukey in &entries {
       let runtime_module_ids: Vec<_> = self
         .chunk_graph
-        .get_chunk_runtime_modules_iterable(&entry_ukey)
+        .get_chunk_runtime_modules_iterable(entry_ukey)
         .copied()
         .collect();
       for runtime_module_id in runtime_module_ids {
-        self
-          .plugin_driver
-          .clone()
+        plugin_driver
           .compilation_hooks
           .runtime_module
-          .call(self, &runtime_module_id, &entry_ukey)
+          .call(self, &runtime_module_id, entry_ukey)
           .await?;
       }
     }
@@ -1653,7 +1648,7 @@ impl Compilation {
       Ok(())
     }
 
-    let unordered_runtime_chunks = self.get_chunk_graph_entries();
+    let unordered_runtime_chunks: UkeySet<ChunkUkey> = self.get_chunk_graph_entries().collect();
     let start = logger.time("hashing: hash chunks");
     let other_chunks: Vec<_> = create_hash_chunks
       .iter()

crates/rspack_core/src/compiler/hmr.rs

@@ -27,7 +27,6 @@ impl Compiler {
     let all_old_runtime = old
       .compilation
       .get_chunk_graph_entries()
-      .into_iter()
       .filter_map(|entry_ukey| old.compilation.chunk_by_ukey.get(&entry_ukey))
       .flat_map(|entry_chunk| entry_chunk.runtime().clone())
       .collect();

crates/rspack_core/src/compiler/module_executor/execute.rs

@@ -166,13 +166,11 @@ impl Task<MakeTaskContext> for ExecuteTask {
       .await?;
     compilation
       .process_chunks_runtime_requirements(
+        UkeySet::from_iter([chunk_ukey]),
         UkeySet::from_iter([chunk_ukey]),
         compilation.plugin_driver.clone(),
       )
       .await?;
-    compilation
-      .process_entries_runtime_requirements(once(chunk_ukey), compilation.plugin_driver.clone())
-      .await?;
     let runtime_modules = compilation
       .chunk_graph
       .get_chunk_runtime_modules_iterable(&chunk_ukey)

packages/rspack-test-tools/tests/watchCases/runtime-requirements/entry-runtime-requirements/0/a.js

@@ -0,0 +1 @@
+import "./b";

packages/rspack-test-tools/tests/watchCases/runtime-requirements/entry-runtime-requirements/0/b.js

@@ -0,0 +1 @@
+global.value = 42;

packages/rspack-test-tools/tests/watchCases/runtime-requirements/entry-runtime-requirements/0/index.js

@@ -0,0 +1,11 @@
+it("should have correct result", () => {
+  import("./a").then(() => {
+    if (WATCH_STEP === '1') {
+      expect(global.value).toBe("main");
+      expect(__webpack_require__.j).toBe("main");
+    } else {
+      expect(global.value).toBe(42);
+      expect(__webpack_require__.j).toBe(undefined);
+    }
+  });
+})

packages/rspack-test-tools/tests/watchCases/runtime-requirements/entry-runtime-requirements/1/b.js

@@ -0,0 +1 @@
+global.value = __webpack_runtime_id__;

packages/rspack-test-tools/tests/watchCases/runtime-requirements/entry-runtime-requirements/2/b.js

@@ -0,0 +1 @@
+global.value = 42;