refactor: introducing the faster code-splitting algorithm

crates/node_binding/binding.d.ts

@@ -1393,6 +1393,7 @@ export interface RawExperiments {
   layers: boolean
   topLevelAwait: boolean
 incremental?: false | { [key: string]: boolean }
+parallelCodeSplitting: boolean
 rspackFuture?: RawRspackFuture
 cache: boolean | { type: "persistent" } & RawExperimentCacheOptionsPersistent | { type: "memory" }
 }

crates/rspack/src/builder/mod.rs

@@ -2686,6 +2686,7 @@ pub struct ExperimentsBuilder {
   output_module: Option<bool>,
   future_defaults: Option<bool>,
   css: Option<bool>,
+  parallel_code_splitting: Option<bool>,
   async_web_assembly: Option<bool>,
   // TODO: lazy compilation
 }
@@ -2701,6 +2702,7 @@ impl From<&mut ExperimentsBuilder> for ExperimentsBuilder {
       output_module: value.output_module.take(),
       future_defaults: value.future_defaults.take(),
       css: value.css.take(),
+      parallel_code_splitting: value.parallel_code_splitting.take(),
       async_web_assembly: value.async_web_assembly.take(),
     }
   }
@@ -2742,6 +2744,11 @@ impl ExperimentsBuilder {
     self
   }
 
+  pub fn parallel_code_splitting(&mut self, parallel_code_splitting: bool) -> &mut Self {
+    self.parallel_code_splitting = Some(parallel_code_splitting);
+    self
+  }
+
   pub fn build(
     &mut self,
     _builder_context: &mut BuilderContext,
@@ -2772,11 +2779,14 @@ impl ExperimentsBuilder {
     w!(self.async_web_assembly, *future_defaults);
     w!(self.output_module, false);
 
+    let parallel_code_splitting = d!(self.parallel_code_splitting, false);
+
     Experiments {
       layers,
       incremental,
       top_level_await,
       rspack_future,
+      parallel_code_splitting,
       cache,
     }
   }

crates/rspack_binding_values/src/raw_options/raw_experiments/mod.rs

@@ -17,6 +17,7 @@ pub struct RawExperiments {
   pub top_level_await: bool,
   #[napi(ts_type = "false | { [key: string]: boolean }")]
   pub incremental: Option<WithFalse<RawIncremental>>,
+  pub parallel_code_splitting: bool,
   pub rspack_future: Option<RawRspackFuture>,
   #[napi(
     ts_type = r#"boolean | { type: "persistent" } & RawExperimentCacheOptionsPersistent | { type: "memory" }"#
@@ -34,6 +35,7 @@ impl From<RawExperiments> for Experiments {
         },
         None => IncrementalPasses::empty(),
       },
+      parallel_code_splitting: value.parallel_code_splitting,
       layers: value.layers,
       top_level_await: value.top_level_await,
       rspack_future: value.rspack_future.unwrap_or_default().into(),

crates/rspack_core/src/build_chunk_graph/code_splitter.rs

@@ -659,7 +659,7 @@ Or do you want to use the entrypoints '{name}' and '{runtime}' independently on
       assign_depths(
         &mut assign_depths_map,
         &compilation.get_module_graph(),
-        modules.iter().collect(),
+        modules.iter(),
       );
       input_entrypoints_and_modules.insert(entry_point, modules);
     }
@@ -1559,7 +1559,11 @@ Or do you want to use the entrypoints '{name}' and '{runtime}' independently on
       return modules.clone();
     }
 
-    self.extract_block_modules(module.get_root_block(compilation), runtime, compilation);
+    self.extract_block_modules(
+      module.get_root_block(&compilation.get_module_graph()),
+      runtime,
+      compilation,
+    );
     self
       .block_modules_runtime_map
       .get::<OptionalRuntimeSpec>(&runtime.cloned().into())
@@ -1952,11 +1956,10 @@ pub(crate) enum DependenciesBlockIdentifier {
 }
 
 impl DependenciesBlockIdentifier {
-  pub fn get_root_block<'a>(&'a self, compilation: &'a Compilation) -> ModuleIdentifier {
+  pub fn get_root_block<'a>(&'a self, module_graph: &'a ModuleGraph) -> ModuleIdentifier {
     match self {
       DependenciesBlockIdentifier::Module(m) => *m,
-      DependenciesBlockIdentifier::AsyncDependenciesBlock(id) => *compilation
-        .get_module_graph()
+      DependenciesBlockIdentifier::AsyncDependenciesBlock(id) => *module_graph
         .block_by_id(id)
         .expect("should have block")
         .parent(),

crates/rspack_core/src/build_chunk_graph/incremental.rs

@@ -129,7 +129,7 @@ impl CodeSplitter {
         continue;
       };
 
-      parent_cg.children.remove(&chunk_group_ukey);
+      parent_cg.children.swap_remove_full(&chunk_group_ukey);
 
       if let Some(parent_cgi) = self.chunk_group_info_map.get(parent) {
         if let Some(parent_cgi) = self.chunk_group_infos.get_mut(parent_cgi) {

crates/rspack_core/src/build_chunk_graph/mod.rs

@@ -7,6 +7,7 @@ use crate::{incremental::IncrementalPasses, Compilation};
 
 pub(crate) mod code_splitter;
 pub(crate) mod incremental;
+pub(crate) mod new_code_splitter;
 
 #[instrument("Compilation:build_chunk_graph", skip_all)]
 pub(crate) fn build_chunk_graph(compilation: &mut Compilation) -> rspack_error::Result<()> {
@@ -46,3 +47,9 @@ pub(crate) fn build_chunk_graph(compilation: &mut Compilation) -> rspack_error::
 
   Ok(())
 }
+
+#[instrument(skip_all)]
+pub(crate) fn build_chunk_graph_new(compilation: &mut Compilation) -> rspack_error::Result<()> {
+  new_code_splitter::code_split(compilation)?;
+  Ok(())
+}