refactor: file counter save the resource id which used the file (#11757)

* feat: file counter save the resource id which used the file

* refactor: remove module.depends_on & factorizeinfo.depends_on

* fix: comment

* fix: ci

Author: jerrykingxyz

crates/rspack_core/src/cache/persistent/occasion/make/alternatives/module.rs

@@ -4,7 +4,6 @@ use rspack_cacheable::{cacheable, cacheable_dyn, utils::OwnedOrRef};
 use rspack_collections::Identifiable;
 use rspack_error::{Result, impl_empty_diagnosable_trait};
 use rspack_hash::RspackHashDigest;
-use rspack_paths::ArcPathSet;
 use rspack_sources::BoxSource;
 use rspack_util::source_map::{ModuleSourceMapConfig, SourceMapKind};
 
@@ -102,11 +101,6 @@ impl Module for TempModule {
     true
   }
 
-  fn depends_on(&self, _modified_file: &ArcPathSet) -> bool {
-    // return true to make sure this module always rebuild
-    true
-  }
-
   async fn code_generation(
     &self,
     _compilation: &Compilation,

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

@@ -9,8 +9,9 @@ use rustc_hash::FxHashSet as HashSet;
 
 use super::super::{Storage, cacheable_context::CacheableContext};
 use crate::{
-  FactorizeInfo, FileCounter, ModuleGraph,
+  FactorizeInfo, ModuleGraph,
   compilation::make::{MakeArtifact, MakeArtifactState},
+  utils::{FileCounter, ResourceId},
 };
 
 /// Make Occasion is used to save MakeArtifact
@@ -75,10 +76,11 @@ impl MakeOccasion {
     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);
+      let resource_id = ResourceId::from(mid);
+      file_dep.add_files(&resource_id, &build_info.file_dependencies);
+      context_dep.add_files(&resource_id, &build_info.context_dependencies);
+      missing_dep.add_files(&resource_id, &build_info.missing_dependencies);
+      build_dep.add_files(&resource_id, &build_info.build_dependencies);
       if !module.diagnostics().is_empty() {
         make_failed_module.insert(mid);
       }
@@ -90,9 +92,10 @@ impl MakeOccasion {
         && !info.is_success()
       {
         make_failed_dependencies.insert(dep_id);
-        file_dep.add_batch_file(&info.file_dependencies());
-        context_dep.add_batch_file(&info.context_dependencies());
-        missing_dep.add_batch_file(&info.missing_dependencies());
+        let resource = dep_id.into();
+        file_dep.add_files(&resource, &info.file_dependencies());
+        context_dep.add_files(&resource, &info.context_dependencies());
+        missing_dep.add_files(&resource, &info.missing_dependencies());
       }
     }
 

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

@@ -4,7 +4,8 @@ use rustc_hash::FxHashSet as HashSet;
 
 use crate::{
   BuildDependency, DependencyId, FactorizeInfo, ModuleGraph, ModuleGraphPartial, ModuleIdentifier,
-  compilation::make::ModuleToLazyMake, utils::FileCounter,
+  compilation::make::ModuleToLazyMake,
+  utils::{FileCounter, ResourceId},
 };
 
 /// Enum used to mark whether module graph has been built.
@@ -91,18 +92,19 @@ impl MakeArtifact {
       .expect("should have module");
     // clean module build info
     let build_info = module.build_info();
+    let resource_id = ResourceId::from(module_identifier);
     self
       .file_dependencies
-      .remove_batch_file(&build_info.file_dependencies);
+      .remove_files(&resource_id, &build_info.file_dependencies);
     self
       .context_dependencies
-      .remove_batch_file(&build_info.context_dependencies);
+      .remove_files(&resource_id, &build_info.context_dependencies);
     self
       .missing_dependencies
-      .remove_batch_file(&build_info.missing_dependencies);
+      .remove_files(&resource_id, &build_info.missing_dependencies);
     self
       .build_dependencies
-      .remove_batch_file(&build_info.build_dependencies);
+      .remove_files(&resource_id, &build_info.build_dependencies);
     self.make_failed_module.remove(module_identifier);
 
     // clean incoming & all_dependencies(outgoing) factorize info
@@ -120,15 +122,16 @@ impl MakeArtifact {
       // make failed dependencies clean it.
       let dep = mg.dependency_by_id(dep_id).expect("should have dependency");
       let info = FactorizeInfo::get_from(dep).expect("should have factorize info");
+      let resource_id = ResourceId::from(dep_id);
       self
         .file_dependencies
-        .remove_batch_file(&info.file_dependencies());
+        .remove_files(&resource_id, &info.file_dependencies());
       self
         .context_dependencies
-        .remove_batch_file(&info.context_dependencies());
+        .remove_files(&resource_id, &info.context_dependencies());
       self
         .missing_dependencies
-        .remove_batch_file(&info.missing_dependencies());
+        .remove_files(&resource_id, &info.missing_dependencies());
     }
 
     self.revoked_modules.insert(*module_identifier);
@@ -148,15 +151,16 @@ impl MakeArtifact {
       // make failed dependencies clean it.
       let dep = mg.dependency_by_id(dep_id).expect("should have dependency");
       let info = FactorizeInfo::get_from(dep).expect("should have factorize info");
+      let resource_id = ResourceId::from(dep_id);
       self
         .file_dependencies
-        .remove_batch_file(&info.file_dependencies());
+        .remove_files(&resource_id, &info.file_dependencies());
       self
         .context_dependencies
-        .remove_batch_file(&info.context_dependencies());
+        .remove_files(&resource_id, &info.context_dependencies());
       self
         .missing_dependencies
-        .remove_batch_file(&info.missing_dependencies());
+        .remove_files(&resource_id, &info.missing_dependencies());
       // related_dep_ids will contain dep_id it self
       info.related_dep_ids().into_owned()
     } else {

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

@@ -6,7 +6,7 @@ use rustc_hash::FxHashSet as HashSet;
 
 use self::{fix_build_meta::FixBuildMeta, fix_issuers::FixIssuers};
 use super::{MakeArtifact, UpdateParam};
-use crate::{BuildDependency, Compilation, FactorizeInfo};
+use crate::{BuildDependency, Compilation, ResourceId};
 
 /// Cutout module graph.
 ///
@@ -59,21 +59,25 @@ impl Cutout {
           }));
         }
         UpdateParam::ModifiedFiles(files) | UpdateParam::RemovedFiles(files) => {
-          for module in module_graph.modules().values() {
-            // check has dependencies modified
-            if module.depends_on(&files) {
-              // add module id
-              force_build_modules.insert(module.identifier());
-            }
-          }
-          // only failed dependencies need to check
-          for dep_id in &artifact.make_failed_dependencies {
-            let dep = module_graph
-              .dependency_by_id(dep_id)
-              .expect("should have dependency");
-            let info = FactorizeInfo::get_from(dep).expect("should have factorize info");
-            if info.depends_on(&files) {
-              force_build_deps.insert(*dep_id);
+          for file in files {
+            for resource_ids in [
+              artifact.file_dependencies.related_resource_ids(&file),
+              artifact.context_dependencies.related_resource_ids(&file),
+              artifact.missing_dependencies.related_resource_ids(&file),
+            ]
+            .into_iter()
+            .flatten()
+            {
+              for resource_id in resource_ids {
+                match resource_id {
+                  ResourceId::Module(mid) => {
+                    force_build_modules.insert(*mid);
+                  }
+                  ResourceId::Dependency(dep_id) => {
+                    force_build_deps.insert(*dep_id);
+                  }
+                }
+              }
             }
           }
         }

crates/rspack_core/src/compilation/make/graph_updater/repair/build.rs

@@ -10,7 +10,10 @@ use crate::{
   AsyncDependenciesBlock, BoxDependency, BuildContext, BuildResult, CompilationId, CompilerId,
   CompilerOptions, DependencyParents, Module, ModuleProfile, ResolverFactory, SharedPluginDriver,
   compilation::make::{ForwardedIdSet, HasLazyDependencies, LazyDependencies},
-  utils::task_loop::{Task, TaskResult, TaskType},
+  utils::{
+    ResourceId,
+    task_loop::{Task, TaskResult, TaskType},
+  },
 };
 
 #[derive(Debug)]
@@ -125,18 +128,19 @@ impl Task<TaskContext> for BuildResultTask {
     module_graph
       .get_optimization_bailout_mut(&module.identifier())
       .extend(build_result.optimization_bailouts);
+    let resource_id = ResourceId::from(module.identifier());
     artifact
       .file_dependencies
-      .add_batch_file(&build_info.file_dependencies);
+      .add_files(&resource_id, &build_info.file_dependencies);
     artifact
       .context_dependencies
-      .add_batch_file(&build_info.context_dependencies);
+      .add_files(&resource_id, &build_info.context_dependencies);
     artifact
       .missing_dependencies
-      .add_batch_file(&build_info.missing_dependencies);
+      .add_files(&resource_id, &build_info.missing_dependencies);
     artifact
       .build_dependencies
-      .add_batch_file(&build_info.build_dependencies);
+      .add_files(&resource_id, &build_info.build_dependencies);
 
     let mut lazy_dependencies = LazyDependencies::default();
     let mut queue = VecDeque::new();

crates/rspack_core/src/compilation/make/graph_updater/repair/factorize.rs

@@ -9,7 +9,10 @@ use crate::{
   FactorizeInfo, ModuleFactory, ModuleFactoryCreateData, ModuleFactoryResult, ModuleIdentifier,
   ModuleLayer, ModuleProfile, Resolve, ResolverFactory,
   module_graph::ModuleGraphModule,
-  utils::task_loop::{Task, TaskResult, TaskType},
+  utils::{
+    ResourceId,
+    task_loop::{Task, TaskResult, TaskType},
+  },
 };
 
 #[derive(Debug)]
@@ -169,15 +172,16 @@ impl Task<TaskContext> for FactorizeResultTask {
 
     let artifact = &mut context.artifact;
     if !factorize_info.diagnostics().is_empty() {
+      let resource_id = ResourceId::from(*dependencies[0].id());
       artifact
         .file_dependencies
-        .add_batch_file(&factorize_info.file_dependencies());
+        .add_files(&resource_id, &factorize_info.file_dependencies());
       artifact
         .context_dependencies
-        .add_batch_file(&factorize_info.context_dependencies());
+        .add_files(&resource_id, &factorize_info.context_dependencies());
       artifact
         .missing_dependencies
-        .add_batch_file(&factorize_info.missing_dependencies());
+        .add_files(&resource_id, &factorize_info.missing_dependencies());
       artifact
         .make_failed_dependencies
         .insert(*dependencies[0].id());

crates/rspack_core/src/dependency/factorize_info.rs

@@ -55,27 +55,6 @@ impl FactorizeInfo {
     matches!(self, FactorizeInfo::Success)
   }
 
-  pub fn depends_on(&self, modified_file: &ArcPathSet) -> bool {
-    if let FactorizeInfo::Failed {
-      file_dependencies,
-      context_dependencies,
-      missing_dependencies,
-      ..
-    } = self
-    {
-      for item in modified_file {
-        if file_dependencies.contains(item)
-          || context_dependencies.contains(item)
-          || missing_dependencies.contains(item)
-        {
-          return true;
-        }
-      }
-    }
-
-    false
-  }
-
   pub fn related_dep_ids(&self) -> Cow<'_, [DependencyId]> {
     match &self {
       Self::Success => Cow::Owned(vec![]),

crates/rspack_core/src/module.rs

@@ -396,21 +396,6 @@ pub trait Module:
       || self.diagnostics().iter().any(|item| item.is_error())
   }
 
-  fn depends_on(&self, modified_file: &ArcPathSet) -> bool {
-    let build_info = self.build_info();
-    for item in modified_file {
-      if build_info.file_dependencies.contains(item)
-        || build_info.build_dependencies.contains(item)
-        || build_info.context_dependencies.contains(item)
-        || build_info.missing_dependencies.contains(item)
-      {
-        return true;
-      }
-    }
-
-    false
-  }
-
   fn need_id(&self) -> bool {
     true
   }