fix: build chunk graph when dynamic entry with depend-on chain (#11486)

Author: SyMind

crates/rspack_core/src/build_chunk_graph/incremental.rs

@@ -17,7 +17,10 @@ use crate::{
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub enum ChunkReCreation {
-  Entry(String),
+  Entry {
+    name: String,
+    depend_on: Option<Vec<String>>,
+  },
   Normal(NormalChunkRecreation),
 }
 
@@ -32,7 +35,10 @@ pub struct NormalChunkRecreation {
 impl ChunkReCreation {
   pub fn rebuild(self, splitter: &mut CodeSplitter, compilation: &mut Compilation) -> Result<()> {
     match self {
-      ChunkReCreation::Entry(entry) => {
+      ChunkReCreation::Entry {
+        name: entry,
+        depend_on: _,
+      } => {
         let input = splitter.prepare_entry_input(&entry, compilation)?;
         splitter.set_entry_runtime_and_depend_on(&entry, compilation)?;
         splitter.prepare_entries(std::iter::once(input).collect(), compilation)?;
@@ -249,7 +255,10 @@ impl CodeSplitter {
       && chunk_group.is_initial()
       && chunk_group.parents.is_empty()
     {
-      edges = vec![ChunkReCreation::Entry(name)];
+      edges = vec![ChunkReCreation::Entry {
+        name,
+        depend_on: None,
+      }];
     }
 
     // If the invalidated chunk group is an entrypoint, we must also invalidate any
@@ -567,14 +576,20 @@ impl CodeSplitter {
 
       edges = compilation
         .entries
-        .keys()
-        .map(|name| ChunkReCreation::Entry(name.to_owned()))
+        .iter()
+        .map(|(name, entry_data)| ChunkReCreation::Entry {
+          name: name.to_owned(),
+          depend_on: entry_data.options.depend_on.clone(),
+        })
         .collect();
     } else {
       'outer: for (entry, data) in &compilation.entries {
         if !compilation.entrypoints.contains_key(entry) {
           // new entry
-          edges.push(ChunkReCreation::Entry(entry.to_owned()));
+          edges.push(ChunkReCreation::Entry {
+            name: entry.to_owned(),
+            depend_on: data.options.depend_on.clone(),
+          });
           continue 'outer;
         }
 
@@ -594,21 +609,60 @@ impl CodeSplitter {
         for m in &curr_modules {
           // there is new entry
           if !prev_entry_modules.contains(m) {
-            edges.push(ChunkReCreation::Entry(entry.to_owned()));
+            edges.push(ChunkReCreation::Entry {
+              name: entry.to_owned(),
+              depend_on: data.options.depend_on.clone(),
+            });
             continue 'outer;
           }
         }
 
         for m in prev_entry_modules {
           if !curr_modules.contains(&m) {
             // there is removed entry modules
-            edges.push(ChunkReCreation::Entry(entry.to_owned()));
+            edges.push(ChunkReCreation::Entry {
+              name: entry.to_owned(),
+              depend_on: data.options.depend_on.clone(),
+            });
             continue 'outer;
           }
         }
       }
     }
 
+    // For entries with dependencies (`dependOn`), we must ensure that the dependency
+    // is processed before the entry that depends on it. This is a topological sort.
+    edges.sort_unstable_by(|a, b| {
+      let (a_name, a_depend_on) = if let ChunkReCreation::Entry { name, depend_on } = a {
+        (name, depend_on)
+      } else {
+        return std::cmp::Ordering::Equal;
+      };
+
+      let (b_name, b_depend_on) = if let ChunkReCreation::Entry { name, depend_on } = b {
+        (name, depend_on)
+      } else {
+        return std::cmp::Ordering::Equal;
+      };
+
+      let a_depends_on_b = a_depend_on
+        .as_deref()
+        .is_some_and(|deps| deps.contains(b_name));
+      let b_depends_on_a = b_depend_on
+        .as_deref()
+        .is_some_and(|deps| deps.contains(a_name));
+
+      // If a depends on b, b must come first (a > b).
+      // If b depends on a, a must come first (a < b).
+      // If there's no direct dependency, their relative order doesn't matter.
+      if a_depends_on_b {
+        std::cmp::Ordering::Greater
+      } else if b_depends_on_a {
+        std::cmp::Ordering::Less
+      } else {
+        std::cmp::Ordering::Equal
+      }
+    });
     for edge in edges {
       edge.rebuild(self, compilation)?;
     }

packages/rspack-test-tools/tests/watchCases/chunks/dynamic-entry-with-depend-on-chain/0/main-app.js

@@ -0,0 +1,42 @@
+const fs = require("fs");
+const path = require("path");
+
+let ERROR;
+
+/** @type {import("@rspack/core").Configuration} */
+module.exports = {
+    entry() {
+        if (fs.existsSync(ERROR)) {
+            return {
+                "main-app": "./main-app.js",
+                "pages/_error": {
+                    import: "./_error.js",
+                    dependOn: "pages/_app"
+                },
+                "pages/_app": {
+                    import: "./_app.js",
+                    dependOn: "main-app"
+                },
+            }
+        }
+        return {
+            "main-app": "./main-app.js"
+        }
+    },
+    output: {
+        filename: "[name].js"
+    },
+    plugins: [
+        {
+            apply(compiler) {
+                ERROR = path.join(compiler.context, "_error.js");
+
+                compiler.hooks.finishMake.tap("PLUGIN", compilation => {
+                    if (!fs.existsSync(ERROR)) {
+                        compilation.missingDependencies.add(ERROR);
+                    }
+                });
+            }
+        }
+    ]
+}

packages/rspack-test-tools/tests/watchCases/chunks/dynamic-entry-with-depend-on-chain/1/_app.js

@@ -0,0 +1,5 @@
+module.exports = {
+    findBundle() {
+        return [];
+    }
+}