refactor: make &compilation for optimization_dependencies

crates/rspack_core/src/compilation/mod.rs

@@ -4,6 +4,7 @@ use std::{
   collections::{VecDeque, hash_map},
   fmt::{self, Debug},
   hash::{BuildHasherDefault, Hash},
+  mem,
   sync::{
     Arc,
     atomic::{AtomicBool, AtomicU32, Ordering},
@@ -76,7 +77,8 @@ define_hook!(CompilationExecuteModule:
 define_hook!(CompilationFinishModules: Series(compilation: &mut Compilation, async_modules_artifact: &mut AsyncModulesArtifact));
 define_hook!(CompilationSeal: Series(compilation: &mut Compilation));
 define_hook!(CompilationConcatenationScope: SeriesBail(compilation: &Compilation, curr_module: ModuleIdentifier) -> ConcatenationScope);
-define_hook!(CompilationOptimizeDependencies: SeriesBail(compilation: &mut Compilation, side_effects_optimize_artifact: &mut SideEffectsOptimizeArtifact, diagnostics: &mut Vec<Diagnostic>) -> bool);
+define_hook!(CompilationOptimizeDependencies: SeriesBail(compilation: &Compilation, side_effects_optimize_artifact: &mut SideEffectsOptimizeArtifact,  build_module_graph_artifact: &mut BuildModuleGraphArtifact,
+ diagnostics: &mut Vec<Diagnostic>) -> bool);
 define_hook!(CompilationOptimizeModules: SeriesBail(compilation: &mut Compilation) -> bool);
 define_hook!(CompilationAfterOptimizeModules: Series(compilation: &mut Compilation));
 define_hook!(CompilationOptimizeChunks: SeriesBail(compilation: &mut Compilation) -> bool);
@@ -1634,16 +1636,23 @@ impl Compilation {
 
     let mut side_effects_optimize_artifact = self.side_effects_optimize_artifact.take();
     let mut diagnostics: Vec<Diagnostic> = vec![];
+    let mut build_module_graph_artifact = mem::take(&mut self.build_module_graph_artifact);
     while matches!(
       plugin_driver
         .compilation_hooks
         .optimize_dependencies
-        .call(self, &mut side_effects_optimize_artifact, &mut diagnostics)
+        .call(
+          self,
+          &mut side_effects_optimize_artifact,
+          &mut build_module_graph_artifact,
+          &mut diagnostics
+        )
         .await
         .map_err(|e| e.wrap_err("caused by plugins in Compilation.hooks.optimizeDependencies"))?,
       Some(true)
     ) {}
     self.side_effects_optimize_artifact = DerefOption::new(side_effects_optimize_artifact);
+    self.build_module_graph_artifact = build_module_graph_artifact;
     self.extend_diagnostics(diagnostics);
 
     logger.time_end(start);

crates/rspack_plugin_dll/src/flag_all_modules_as_used_plugin.rs

@@ -1,7 +1,8 @@
 use rspack_collections::IdentifierSet;
 use rspack_core::{
   BoxModule, Compilation, CompilationBuildModule, CompilationId, CompilationOptimizeDependencies,
-  CompilerId, FactoryMeta, Plugin, RuntimeSpec, SideEffectsOptimizeArtifact, get_entry_runtime,
+  CompilerId, FactoryMeta, Plugin, RuntimeSpec, SideEffectsOptimizeArtifact,
+  build_module_graph::BuildModuleGraphArtifact, get_entry_runtime,
 };
 use rspack_error::{Diagnostic, Result};
 use rspack_hook::{plugin, plugin_hook};
@@ -41,8 +42,9 @@ impl Plugin for FlagAllModulesAsUsedPlugin {
 #[plugin_hook(CompilationOptimizeDependencies for FlagAllModulesAsUsedPlugin)]
 async fn optimize_dependencies(
   &self,
-  compilation: &mut Compilation,
+  compilation: &Compilation,
   _side_effects_optimize_artifact: &mut SideEffectsOptimizeArtifact,
+  build_module_graph_artifact: &mut BuildModuleGraphArtifact,
   _diagnostics: &mut Vec<Diagnostic>,
 ) -> Result<Option<bool>> {
   let entries = &compilation.entries;
@@ -56,7 +58,7 @@ async fn optimize_dependencies(
       a
     });
 
-  let mg = compilation.get_module_graph_mut();
+  let mg = build_module_graph_artifact.get_module_graph_mut();
 
   let module_id_list: IdentifierSet = mg.modules().keys().copied().collect();
 

crates/rspack_plugin_javascript/src/plugin/flag_dependency_usage_plugin.rs

@@ -7,8 +7,8 @@ use rspack_core::{
   CompilationOptimizeDependencies, ConnectionState, DependenciesBlock, DependencyId, ExportsInfo,
   ExportsInfoData, ExtendedReferencedExport, GroupOptions, ModuleGraph, ModuleGraphCacheArtifact,
   ModuleIdentifier, Plugin, ReferencedExport, RuntimeSpec, SideEffectsOptimizeArtifact, UsageState,
-  get_entry_runtime, incremental::IncrementalPasses, is_exports_object_referenced,
-  is_no_exports_referenced,
+  build_module_graph::BuildModuleGraphArtifact, get_entry_runtime, incremental::IncrementalPasses,
+  is_exports_object_referenced, is_no_exports_referenced,
 };
 use rspack_error::{Diagnostic, Result};
 use rspack_hook::{plugin, plugin_hook};
@@ -32,22 +32,28 @@ enum ProcessModuleReferencedExports {
 #[allow(unused)]
 pub struct FlagDependencyUsagePluginProxy<'a> {
   global: bool,
-  compilation: &'a mut Compilation,
+  compilation: &'a Compilation,
+  build_module_graph_artifact: &'a mut BuildModuleGraphArtifact,
   exports_info_module_map: UkeyMap<ExportsInfo, ModuleIdentifier>,
 }
 
 #[allow(unused)]
 impl<'a> FlagDependencyUsagePluginProxy<'a> {
-  pub fn new(global: bool, compilation: &'a mut Compilation) -> Self {
+  pub fn new(
+    global: bool,
+    compilation: &'a Compilation,
+    build_module_graph_artifact: &'a mut BuildModuleGraphArtifact,
+  ) -> Self {
     Self {
       global,
       compilation,
+      build_module_graph_artifact,
       exports_info_module_map: UkeyMap::default(),
     }
   }
 
   fn apply(&mut self) {
-    let mut module_graph = self.compilation.get_module_graph_mut();
+    let mut module_graph = self.build_module_graph_artifact.get_module_graph_mut();
     module_graph.active_all_exports_info();
     module_graph.reset_all_exports_info_used();
 
@@ -62,12 +68,12 @@ impl<'a> FlagDependencyUsagePluginProxy<'a> {
     // SAFETY: we can make sure that entries will not be used other place at the same time,
     // this take is aiming to avoid use self ref and mut ref at the same time;
     let mut global_runtime: Option<RuntimeSpec> = None;
-    let entries = std::mem::take(&mut self.compilation.entries);
+    let entries = &self.compilation.entries;
     for (entry_name, entry) in entries.iter() {
       let runtime = if self.global {
         None
       } else {
-        Some(get_entry_runtime(entry_name, &entry.options, &entries))
+        Some(get_entry_runtime(entry_name, &entry.options, entries))
       };
       if let Some(runtime) = runtime.as_ref() {
         global_runtime.get_or_insert_default().extend(runtime);
@@ -85,7 +91,6 @@ impl<'a> FlagDependencyUsagePluginProxy<'a> {
     for dep in self.compilation.global_entry.include_dependencies.clone() {
       self.process_entry_dependency(dep, global_runtime.clone(), &mut q);
     }
-    self.compilation.entries = entries;
 
     loop {
       let mut batch = vec![];
@@ -119,7 +124,7 @@ impl<'a> FlagDependencyUsagePluginProxy<'a> {
         // 1. if the exports info data has `redirect_to`, the redirected exports info will also be modified, so the referenced exports should not be processed parallelly
         // 2. if the referenced exports has nested properties, the nested exports info will also be modified, the referenced exports should not be processed parallelly
 
-        let mg = self.compilation.get_module_graph();
+        let mg = self.build_module_graph_artifact.get_module_graph();
 
         let collected = batch_res
           .into_par_iter()
@@ -165,7 +170,7 @@ impl<'a> FlagDependencyUsagePluginProxy<'a> {
       // we can ensure that only the module's exports info data will be modified
       // so we can process these non-nested tasks parallelly by cloning the exports info data
       let non_nested_res = {
-        let mg = self.compilation.get_module_graph();
+        let mg = self.build_module_graph_artifact.get_module_graph();
         non_nested_tasks
           .into_par_iter()
           .map(|(module_id, tasks)| {
@@ -202,7 +207,7 @@ impl<'a> FlagDependencyUsagePluginProxy<'a> {
 
       {
         // after processing, we will set the exports info data back to the module graph
-        let mut mg = self.compilation.get_module_graph_mut();
+        let mut mg = self.build_module_graph_artifact.get_module_graph_mut();
         for (exports_info, res) in non_nested_res {
           for i in res {
             q.enqueue(i);
@@ -251,7 +256,7 @@ impl<'a> FlagDependencyUsagePluginProxy<'a> {
     let (dependencies, async_blocks) = collect_active_dependencies(
       block_id,
       runtime,
-      self.compilation.get_module_graph(),
+      self.build_module_graph_artifact.get_module_graph(),
       &self.compilation.module_graph_cache_artifact,
       global,
     );
@@ -261,7 +266,7 @@ impl<'a> FlagDependencyUsagePluginProxy<'a> {
       let old_referenced_exports = map.remove(&module_id);
       let Some(referenced_exports) = get_dependency_referenced_exports(
         dep_id,
-        self.compilation.get_module_graph(),
+        self.build_module_graph_artifact.get_module_graph(),
         &self.compilation.module_graph_cache_artifact,
         runtime,
       ) else {
@@ -299,11 +304,11 @@ impl<'a> FlagDependencyUsagePluginProxy<'a> {
     queue: &mut Queue<ProcessBlockTask>,
   ) {
     if let Some(module) = self
-      .compilation
+      .build_module_graph_artifact
       .get_module_graph()
       .module_graph_module_by_dependency_id(&dep)
     {
-      let mg = self.compilation.get_module_graph();
+      let mg = self.build_module_graph_artifact.get_module_graph();
       let exports_info = mg.get_exports_info(&module.module_identifier);
       let res = self.process_referenced_module(
         exports_info,
@@ -327,7 +332,7 @@ impl<'a> FlagDependencyUsagePluginProxy<'a> {
     force_side_effects: bool,
   ) -> Vec<ProcessBlockTask> {
     let mut queue = vec![];
-    let mut module_graph = self.compilation.get_module_graph_mut();
+    let mut module_graph = self.build_module_graph_artifact.get_module_graph_mut();
     let module = module_graph
       .module_by_identifier(&module_id)
       .expect("should have module");
@@ -479,8 +484,9 @@ impl FlagDependencyUsagePlugin {
 #[plugin_hook(CompilationOptimizeDependencies for FlagDependencyUsagePlugin)]
 async fn optimize_dependencies(
   &self,
-  compilation: &mut Compilation,
+  compilation: &Compilation,
   _side_effect_optimize_artifact: &mut SideEffectsOptimizeArtifact,
+  build_module_graph_artifact: &mut BuildModuleGraphArtifact,
   diagnostics: &mut Vec<Diagnostic>,
 ) -> Result<Option<bool>> {
   if let Some(diagnostic) = compilation.incremental.disable_passes(
@@ -489,10 +495,11 @@ async fn optimize_dependencies(
     "it requires calculating the used exports based on all modules, which is a global effect",
   ) {
     diagnostics.extend(diagnostic);
-    compilation.cgm_hash_artifact.clear();
+    // compilation.cgm_hash_artifact.clear();
   }
 
-  let mut proxy = FlagDependencyUsagePluginProxy::new(self.global, compilation);
+  let mut proxy =
+    FlagDependencyUsagePluginProxy::new(self.global, compilation, build_module_graph_artifact);
   proxy.apply();
   Ok(None)
 }

crates/rspack_plugin_javascript/src/plugin/inline_exports_plugin.rs

@@ -4,7 +4,8 @@ use rspack_core::{
   Compilation, CompilationOptimizeDependencies, Dependency, DependencyId, ExportMode,
   ExportProvided, ExportsInfo, ExportsInfoGetter, GetUsedNameParam, ModuleGraph,
   ModuleGraphConnection, ModuleIdentifier, Plugin, PrefetchExportsInfoMode, RuntimeSpec,
-  SideEffectsOptimizeArtifact, UsageState, UsedName, UsedNameItem, incremental::IncrementalPasses,
+  SideEffectsOptimizeArtifact, UsageState, UsedName, UsedNameItem,
+  build_module_graph::BuildModuleGraphArtifact, incremental::IncrementalPasses,
 };
 use rspack_error::{Diagnostic, Result};
 use rspack_hook::{plugin, plugin_hook};
@@ -92,8 +93,9 @@ pub struct InlineExportsPlugin;
 #[plugin_hook(CompilationOptimizeDependencies for InlineExportsPlugin, stage = 100)]
 async fn optimize_dependencies(
   &self,
-  compilation: &mut Compilation,
+  compilation: &Compilation,
   _side_effect_optimize_artifact: &mut SideEffectsOptimizeArtifact,
+  build_module_graph_artifact: &mut BuildModuleGraphArtifact,
   diagnostics: &mut Vec<Diagnostic>,
 ) -> Result<Option<bool>> {
   if let Some(diagnostic) = compilation.incremental.disable_passes(
@@ -102,10 +104,10 @@ async fn optimize_dependencies(
     "it requires calculating the export names of all the modules, which is a global effect",
   ) {
     diagnostics.extend(diagnostic);
-    compilation.cgm_hash_artifact.clear();
+    //compilation.cgm_hash_artifact.clear();
   }
 
-  let mg = compilation.get_module_graph_mut();
+  let mg = build_module_graph_artifact.get_module_graph_mut();
   let modules = mg.modules();
 
   let mut visited: FxHashSet<ExportsInfo> = FxHashSet::default();

crates/rspack_plugin_javascript/src/plugin/side_effects_flag_plugin.rs

@@ -9,6 +9,7 @@ use rspack_core::{
   NormalModuleFactoryModule, Plugin, PrefetchExportsInfoMode, RayonConsumer,
   ResolvedExportInfoTarget, SideEffectsDoOptimize, SideEffectsDoOptimizeMoveTarget,
   SideEffectsOptimizeArtifact,
+  build_module_graph::BuildModuleGraphArtifact,
   incremental::{self, IncrementalPasses, Mutation},
 };
 use rspack_error::{Diagnostic, Result};
@@ -150,14 +151,15 @@ async fn nmf_module(
 #[plugin_hook(CompilationOptimizeDependencies for SideEffectsFlagPlugin,tracing=false)]
 async fn optimize_dependencies(
   &self,
-  compilation: &mut Compilation,
+  compilation: &Compilation,
   side_effects_optimize_artifact: &mut SideEffectsOptimizeArtifact,
+  build_module_graph_artifact: &mut BuildModuleGraphArtifact,
   _diagnostics: &mut Vec<Diagnostic>,
 ) -> Result<Option<bool>> {
   let logger = compilation.get_logger("rspack.SideEffectsFlagPlugin");
   let start = logger.time("update connections");
 
-  let module_graph = compilation.get_module_graph();
+  let module_graph = build_module_graph_artifact.get_module_graph();
 
   let all_modules = module_graph.modules();
 
@@ -276,7 +278,7 @@ async fn optimize_dependencies(
   while !do_optimizes.is_empty() {
     do_optimized_count += do_optimizes.len();
 
-    let module_graph = compilation.get_module_graph_mut();
+    let module_graph = build_module_graph_artifact.get_module_graph_mut();
 
     let new_connections: Vec<_> = do_optimizes
       .into_iter()
@@ -285,7 +287,7 @@ async fn optimize_dependencies(
       })
       .collect();
 
-    let module_graph = compilation.get_module_graph();
+    let module_graph = build_module_graph_artifact.get_module_graph();
     do_optimizes = new_connections
       .into_par_iter()
       .filter(|(_, module)| side_effects_state_map[module] == ConnectionState::Active(false))

crates/rspack_plugin_progress/src/lib.rs

@@ -20,6 +20,7 @@ use rspack_core::{
   CompilationSeal, CompilationSucceedModule, CompilerAfterEmit, CompilerClose, CompilerCompilation,
   CompilerEmit, CompilerFinishMake, CompilerId, CompilerMake, CompilerThisCompilation,
   ModuleIdentifier, Plugin, SideEffectsOptimizeArtifact,
+  build_module_graph::BuildModuleGraphArtifact,
 };
 use rspack_error::{Diagnostic, Result};
 use rspack_hook::{plugin, plugin_hook};
@@ -439,8 +440,9 @@ async fn seal(&self, _compilation: &mut Compilation) -> Result<()> {
 #[plugin_hook(CompilationOptimizeDependencies for ProgressPlugin)]
 async fn optimize_dependencies(
   &self,
-  _compilation: &mut Compilation,
+  _compilation: &Compilation,
   _side_effects_optimize_artifact: &mut SideEffectsOptimizeArtifact,
+  _build_module_graph_artifact: &mut BuildModuleGraphArtifact,
   _diagnostics: &mut Vec<Diagnostic>,
 ) -> Result<Option<bool>> {
   self.sealing_hooks_report("dependencies", 2).await?;

xtask/benchmark/benches/groups/build_chunk_graph.rs

@@ -1,5 +1,5 @@
 #![allow(clippy::unwrap_used)]
-use std::sync::Arc;
+use std::{mem, sync::Arc};
 
 use criterion::criterion_group;
 use rspack::builder::Builder as _;
@@ -180,21 +180,24 @@ pub fn build_chunk_graph_benchmark_inner(c: &mut Criterion) {
     let mut side_effects_optimize_artifact =
       compiler.compilation.side_effects_optimize_artifact.take();
     let mut diagnostics: Vec<Diagnostic> = vec![];
-
+    let mut build_module_graph_artifact =
+      mem::take(&mut compiler.compilation.build_module_graph_artifact);
     while matches!(
       compiler
         .plugin_driver
         .compilation_hooks
         .optimize_dependencies
         .call(
-          &mut compiler.compilation,
+          &compiler.compilation,
           &mut side_effects_optimize_artifact,
+          &mut build_module_graph_artifact,
           &mut diagnostics
         )
         .await
         .unwrap(),
       Some(true)
     ) {}
+    compiler.compilation.build_module_graph_artifact = build_module_graph_artifact;
 
     compiler.compilation.side_effects_optimize_artifact =
       DerefOption::new(side_effects_optimize_artifact);