fix: should re-build chunk graph when adding a entry connection (#9537)

crates/rspack_core/src/artifacts/cgm_hash_artifact.rs

@@ -18,8 +18,19 @@ impl CgmHashArtifact {
     hashes.get(runtime)
   }
 
-  pub fn set_hashes(&mut self, module: ModuleIdentifier, hashes: RuntimeSpecMap<RspackHashDigest>) {
-    self.module_to_hashes.insert(module, hashes);
+  pub fn set_hashes(
+    &mut self,
+    module: ModuleIdentifier,
+    hashes: RuntimeSpecMap<RspackHashDigest>,
+  ) -> bool {
+    if let Some(old) = self.module_to_hashes.get(&module)
+      && old == &hashes
+    {
+      false
+    } else {
+      self.module_to_hashes.insert(module, hashes);
+      true
+    }
   }
 
   pub fn remove(&mut self, module: &ModuleIdentifier) -> Option<RuntimeSpecMap<RspackHashDigest>> {

crates/rspack_core/src/build_chunk_graph/incremental.rs

@@ -509,16 +509,14 @@ impl CodeSplitter {
 
     // If after edges rebuild there are still some entries not included in entrypoints
     // then they are new added entries and we build them.
-    if compilation.entries.len() > compilation.entrypoints.len() {
-      let new_entries: Vec<_> = compilation
-        .entries
-        .keys()
-        .filter(|entry| !compilation.entrypoints.contains_key(entry.as_str()))
-        .map(|entry| ChunkReCreation::Entry(entry.to_owned()))
-        .collect();
-      for edge in new_entries {
-        edge.rebuild(self, compilation)?;
-      }
+    let new_entries: Vec<_> = compilation
+      .entries
+      .keys()
+      .filter(|entry| !compilation.entrypoints.contains_key(entry.as_str()))
+      .map(|entry| ChunkReCreation::Entry(entry.to_owned()))
+      .collect();
+    for edge in new_entries {
+      edge.rebuild(self, compilation)?;
     }
 
     // Ensure entrypoints always have the same order with entries

crates/rspack_core/src/chunk_graph/chunk_graph_module.rs

@@ -273,10 +273,10 @@ impl ChunkGraph {
     compilation: &mut Compilation,
     module_identifier: ModuleIdentifier,
     hashes: RuntimeSpecMap<RspackHashDigest>,
-  ) {
+  ) -> bool {
     compilation
       .cgm_hash_artifact
-      .set_hashes(module_identifier, hashes);
+      .set_hashes(module_identifier, hashes)
   }
 
   pub fn try_get_module_chunks(

crates/rspack_core/src/compiler/compilation.rs

@@ -1421,14 +1421,46 @@ impl Compilation {
       for revoked_module in revoked_modules {
         self.cgm_hash_artifact.remove(&revoked_module);
       }
-      let modules = mutations.get_affected_modules_with_chunk_graph(self);
+      let mg = self.get_module_graph();
+      let mut affected_modules = mutations.get_affected_modules_with_module_graph(&mg);
+      for mutation in mutations.iter() {
+        match mutation {
+          Mutation::ModuleSetAsync { module } => {
+            affected_modules.insert(*module);
+          }
+          Mutation::ModuleSetId { module } => {
+            affected_modules.insert(*module);
+            affected_modules.extend(
+              mg.get_incoming_connections(module)
+                .filter_map(|c| c.original_module_identifier),
+            );
+          }
+          Mutation::ChunkAdd { chunk } => {
+            affected_modules.extend(self.chunk_graph.get_chunk_modules_identifier(chunk));
+          }
+          Mutation::ChunkSetId { chunk } => {
+            let chunk = self.chunk_by_ukey.expect_get(chunk);
+            affected_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 logger = self.get_logger("rspack.incremental.modulesHashes");
       logger.log(format!(
         "{} modules are affected, {} in total",
-        modules.len(),
-        self.get_module_graph().modules().len()
+        affected_modules.len(),
+        mg.modules().len()
       ));
-      modules
+      affected_modules
     } else {
       self.get_module_graph().modules().keys().copied().collect()
     };
@@ -1456,7 +1488,13 @@ impl Compilation {
       for revoked_module in revoked_modules {
         self.code_generation_results.remove(&revoked_module);
       }
-      let modules = mutations.get_affected_modules_with_chunk_graph(self);
+      let modules: IdentifierSet = mutations
+        .iter()
+        .filter_map(|mutation| match mutation {
+          Mutation::ModuleSetHashes { module } => Some(*module),
+          _ => None,
+        })
+        .collect();
       let logger = self.get_logger("rspack.incremental.modulesCodegen");
       logger.log(format!(
         "{} modules are affected, {} in total",
@@ -1490,7 +1528,13 @@ impl Compilation {
           .cgm_runtime_requirements_artifact
           .remove(&revoked_module);
       }
-      let modules = mutations.get_affected_modules_with_chunk_graph(self);
+      let modules: IdentifierSet = mutations
+        .iter()
+        .filter_map(|mutation| match mutation {
+          Mutation::ModuleSetHashes { module } => Some(*module),
+          _ => None,
+        })
+        .collect();
       let logger = self.get_logger("rspack.incremental.modulesRuntimeRequirements");
       logger.log(format!(
         "{} modules are affected, {} in total",
@@ -2164,7 +2208,11 @@ impl Compilation {
       })
       .collect::<Result<_>>()?;
     for (module, hashes) in results {
-      ChunkGraph::set_module_hashes(self, module, hashes);
+      if ChunkGraph::set_module_hashes(self, module, hashes)
+        && let Some(mutations) = self.incremental.mutations_write()
+      {
+        mutations.add(Mutation::ModuleSetHashes { module });
+      }
     }
     Ok(())
   }

crates/rspack_core/src/compiler/rebuild.rs

@@ -62,11 +62,6 @@ impl Compiler {
 
       new_compilation.hot_index = self.compilation.hot_index + 1;
 
-      if let Some(mutations) = new_compilation.incremental.mutations_write()
-        && let Some(old_mutations) = self.compilation.incremental.mutations_write()
-      {
-        mutations.swap_modules_with_chunk_graph_cache(old_mutations);
-      }
       if new_compilation
         .incremental
         .can_read_mutations(IncrementalPasses::MAKE)