revert

Author: SyMind

crates/rspack_core/src/cache/persistent/occasion/make/mod.rs

@@ -61,6 +61,7 @@ impl MakeOccasion {
   pub async fn recovery(&self) -> Result<MakeArtifact> {
     let (partial, module_to_lazy_make, entry_dependencies) =
       module_graph::recovery_module_graph(&self.storage, &self.context).await?;
+
     // regenerate statistical data
     let mg = ModuleGraph::new([Some(&partial), None], None);
     // recovery make_failed_module
@@ -70,60 +71,22 @@ impl MakeOccasion {
     let mut context_dep = FileCounter::default();
     let mut missing_dep = FileCounter::default();
     let mut build_dep = FileCounter::default();
+    for (mid, module) in mg.modules() {
+      let build_info = module.build_info();
+      file_dep.add_batch_file(&build_info.file_dependencies);
+      context_dep.add_batch_file(&build_info.context_dependencies);
+      missing_dep.add_batch_file(&build_info.missing_dependencies);
+      build_dep.add_batch_file(&build_info.build_dependencies);
+      if !module.diagnostics().is_empty() {
+        make_failed_module.insert(mid);
+      }
+    }
 
-    let modules = mg.modules();
-    rayon::scope(|s| {
-      s.spawn(|_| {
-        for module in modules.values() {
-          let build_info = module.build_info();
-          file_dep.add_batch_file(&build_info.file_dependencies);
-        }
-      });
-      s.spawn(|_| {
-        for module in modules.values() {
-          let build_info = module.build_info();
-          context_dep.add_batch_file(&build_info.context_dependencies);
-        }
-      });
-      s.spawn(|_| {
-        for module in modules.values() {
-          let build_info = module.build_info();
-          missing_dep.add_batch_file(&build_info.missing_dependencies);
-        }
-      });
-      s.spawn(|_| {
-        for module in modules.values() {
-          let build_info = module.build_info();
-          build_dep.add_batch_file(&build_info.build_dependencies);
-        }
-      });
-      s.spawn(|_| {
-        for (identifier, module) in &modules {
-          if !module.diagnostics().is_empty() {
-            make_failed_module.insert(*identifier);
-          }
-        }
-      });
-    });
-
-    let dependency_factorize_infos = mg.dependency_factorize_infos();
-    rayon::scope(|s| {
-      s.spawn(|_| {
-        for factorize_info in dependency_factorize_infos.values() {
-          file_dep.add_batch_file(&factorize_info.file_dependencies());
-        }
-      });
-      s.spawn(|_| {
-        for factorize_info in dependency_factorize_infos.values() {
-          context_dep.add_batch_file(&factorize_info.context_dependencies());
-        }
-      });
-      s.spawn(|_| {
-        for factorize_info in dependency_factorize_infos.values() {
-          missing_dep.add_batch_file(&factorize_info.missing_dependencies());
-        }
-      });
-    });
+    for (_, factorize_info) in mg.dependency_factorize_info_iter() {
+      file_dep.add_batch_file(&factorize_info.file_dependencies());
+      context_dep.add_batch_file(&factorize_info.context_dependencies());
+      missing_dep.add_batch_file(&factorize_info.missing_dependencies());
+    }
 
     Ok(MakeArtifact {
       // write all of field here to avoid forget to update occasion when add new fields

crates/rspack_core/src/compilation/make/artifact.rs

@@ -186,8 +186,7 @@ impl MakeArtifact {
           .collect::<Vec<_>>()
       });
     let make_failed_dependencies = mg
-      .dependency_factorize_infos()
-      .into_iter()
+      .dependency_factorize_info_iter()
       .filter(|(_, info)| !info.is_success());
     let dep_diagnostics = make_failed_dependencies.flat_map(|(dep_id, factorize_info)| {
       let origin_module_identifier = mg.get_parent_module(&dep_id);

crates/rspack_core/src/compilation/make/graph_updater/cutout/mod.rs

@@ -76,8 +76,7 @@ impl Cutout {
           );
           force_build_deps.extend(
             module_graph
-              .dependency_factorize_infos()
-              .into_iter()
+              .dependency_factorize_info_iter()
               // The cost of `factorize_info.depends_on` can be highly non-uniform.
               // To enable Rayon's work-stealing for better load balancing, we first
               // materialize the iterator into a Vec. This allows `par_iter` to create

crates/rspack_core/src/module_graph/mod.rs

@@ -647,27 +647,8 @@ impl<'a> ModuleGraph<'a> {
   }
 
   #[inline]
-  pub fn dependency_factorize_infos(&self) -> HashMap<DependencyId, &FactorizeInfo> {
-    let mut res = HashMap::default();
-    for item in self.partials.iter().flatten() {
-      for (k, v) in &item.dependency_factorize_infos {
-        if let Some(v) = v {
-          res.insert(*k, v);
-        } else {
-          res.remove(k);
-        }
-      }
-    }
-    if let Some(active) = &self.active {
-      for (k, v) in &active.dependency_factorize_infos {
-        if let Some(v) = v {
-          res.insert(*k, v);
-        } else {
-          res.remove(k);
-        }
-      }
-    }
-    res
+  pub fn dependency_factorize_info_iter(&'a self) -> FactorizeInfos<'a> {
+    FactorizeInfos::new(self)
   }
 
   pub fn add_dependency(&mut self, dependency: BoxDependency) {
@@ -1276,3 +1257,80 @@ impl<'a> ModuleGraph<'a> {
     }
   }
 }
+
+#[allow(clippy::type_complexity)]
+pub enum FactorizeInfos<'a> {
+  // An optimized iterator for when there's only a single, read-only layer of data.
+  // It directly iterates over the underlying `HashMap` without any merging overhead,
+  // filtering out deleted entries (`None` values).
+  Direct(
+    std::iter::FilterMap<
+      std::collections::hash_map::Iter<'a, DependencyId, Option<FactorizeInfo>>,
+      fn((&DependencyId, &'a Option<FactorizeInfo>)) -> Option<(DependencyId, &'a FactorizeInfo)>,
+    >,
+  ),
+  // An iterator for when multiple data layers exist (e.g., during the seal phase).
+  // It merges all layers into a temporary `HashMap` to correctly resolve overrides
+  // and deletions, then iterates over the merged result.
+  Merged(std::collections::hash_map::IntoIter<DependencyId, &'a FactorizeInfo>),
+}
+
+impl<'a> FactorizeInfos<'a> {
+  pub fn new(module_graph: &'a ModuleGraph<'a>) -> Self {
+    if module_graph.partials.iter().flatten().count() == 1 && module_graph.active.is_none() {
+      #[allow(clippy::unwrap_used)]
+      let partial = module_graph
+        .partials
+        .iter()
+        .find_map(|p| p.as_ref())
+        .unwrap();
+      Self::Direct(
+        partial
+          .dependency_factorize_infos
+          .iter()
+          .filter_map(|item| item.1.as_ref().map(|info| (*item.0, info))),
+      )
+    } else {
+      let mut merged = HashMap::default();
+      for item in module_graph.partials.iter().flatten() {
+        for (dependency_id, factorize_info) in &item.dependency_factorize_infos {
+          if let Some(factorize_info) = factorize_info {
+            merged.insert(*dependency_id, factorize_info);
+          } else {
+            merged.remove(dependency_id);
+          }
+        }
+      }
+      if let Some(active) = &module_graph.active {
+        for (dependency_id, factorize_info) in &active.dependency_factorize_infos {
+          if let Some(factorize_info) = factorize_info {
+            merged.insert(*dependency_id, factorize_info);
+          } else {
+            merged.remove(dependency_id);
+          }
+        }
+      }
+      Self::Merged(merged.into_iter())
+    }
+  }
+}
+
+impl<'a> Iterator for FactorizeInfos<'a> {
+  type Item = (DependencyId, &'a FactorizeInfo);
+
+  #[inline]
+  fn next(&mut self) -> Option<Self::Item> {
+    match self {
+      Self::Direct(iter) => iter.next(),
+      Self::Merged(iter) => iter.next(),
+    }
+  }
+
+  #[inline]
+  fn size_hint(&self) -> (usize, Option<usize>) {
+    match self {
+      Self::Direct(iter) => iter.size_hint(),
+      Self::Merged(iter) => iter.size_hint(),
+    }
+  }
+}