fix: should update alias resolution when a higher-priority file is created in watch mode (#11643)

Author: SyMind

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

@@ -5,7 +5,7 @@ use std::sync::Arc;
 
 use rspack_collections::IdentifierSet;
 use rspack_error::Result;
-use rustc_hash::FxHashSet as HashSet;
+use rustc_hash::FxHashSet;
 
 use super::super::{Storage, cacheable_context::CacheableContext};
 use crate::{
@@ -85,17 +85,18 @@ impl MakeOccasion {
         make_failed_module.insert(mid);
       }
     }
+
     // recovery make_failed_dependencies
-    let mut make_failed_dependencies = HashSet::default();
+    let mut make_failed_dependencies = FxHashSet::default();
     for (dep_id, dep) in mg.dependencies() {
-      if let Some(info) = FactorizeInfo::get_from(dep)
-        && !info.is_success()
-      {
-        make_failed_dependencies.insert(dep_id);
+      if let Some(info) = FactorizeInfo::get_from(dep) {
+        if !info.is_success() {
+          make_failed_dependencies.insert(dep_id);
+        }
         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());
+        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

@@ -113,25 +113,27 @@ impl MakeArtifact {
       .expect("should have mgm");
     for dep_id in mgm
       .all_dependencies
-      .iter()
-      .chain(mgm.incoming_connections())
+      .clone()
+      .into_iter()
+      .chain(mgm.incoming_connections().clone())
     {
-      if !self.make_failed_dependencies.remove(dep_id) {
-        continue;
+      self.make_failed_dependencies.remove(&dep_id);
+
+      let dep = mg
+        .dependency_by_id_mut(&dep_id)
+        .expect("should have dependency");
+      if let Some(info) = FactorizeInfo::revoke(dep) {
+        let resource_id = ResourceId::from(dep_id);
+        self
+          .file_dependencies
+          .remove_files(&resource_id, info.file_dependencies());
+        self
+          .context_dependencies
+          .remove_files(&resource_id, info.context_dependencies());
+        self
+          .missing_dependencies
+          .remove_files(&resource_id, info.missing_dependencies());
       }
-      // 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_files(&resource_id, &info.file_dependencies());
-      self
-        .context_dependencies
-        .remove_files(&resource_id, &info.context_dependencies());
-      self
-        .missing_dependencies
-        .remove_files(&resource_id, &info.missing_dependencies());
     }
 
     self.revoked_modules.insert(*module_identifier);
@@ -145,24 +147,25 @@ impl MakeArtifact {
   /// If `force` is true, the dependency will be completely removed, and nothing will be returned.
   /// This function will update index on MakeArtifact.
   pub fn revoke_dependency(&mut self, dep_id: &DependencyId, force: bool) -> Vec<BuildDependency> {
-    let mut mg = ModuleGraph::new([None, None], Some(&mut self.module_graph_partial));
+    self.make_failed_dependencies.remove(dep_id);
 
-    let revoke_dep_ids = if self.make_failed_dependencies.remove(dep_id) {
-      // 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 mut mg = ModuleGraph::new([None, None], Some(&mut self.module_graph_partial));
+    let revoke_dep_ids = if let Some(factorize_info) = mg
+      .dependency_by_id_mut(dep_id)
+      .and_then(FactorizeInfo::revoke)
+    {
       let resource_id = ResourceId::from(dep_id);
       self
         .file_dependencies
-        .remove_files(&resource_id, &info.file_dependencies());
+        .remove_files(&resource_id, factorize_info.file_dependencies());
       self
         .context_dependencies
-        .remove_files(&resource_id, &info.context_dependencies());
+        .remove_files(&resource_id, factorize_info.context_dependencies());
       self
         .missing_dependencies
-        .remove_files(&resource_id, &info.missing_dependencies());
+        .remove_files(&resource_id, factorize_info.missing_dependencies());
       // related_dep_ids will contain dep_id it self
-      info.related_dep_ids().into_owned()
+      factorize_info.related_dep_ids().to_vec()
     } else {
       vec![*dep_id]
     };

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

@@ -171,21 +171,22 @@ impl Task<TaskContext> for FactorizeResultTask {
     } = *self;
 
     let artifact = &mut context.artifact;
-    if !factorize_info.diagnostics().is_empty() {
-      let resource_id = ResourceId::from(*dependencies[0].id());
-      artifact
-        .file_dependencies
-        .add_files(&resource_id, &factorize_info.file_dependencies());
-      artifact
-        .context_dependencies
-        .add_files(&resource_id, &factorize_info.context_dependencies());
-      artifact
-        .missing_dependencies
-        .add_files(&resource_id, &factorize_info.missing_dependencies());
+    if !factorize_info.is_success() {
       artifact
         .make_failed_dependencies
         .insert(*dependencies[0].id());
     }
+    let resource_id = ResourceId::from(*dependencies[0].id());
+    artifact
+      .file_dependencies
+      .add_files(&resource_id, factorize_info.file_dependencies());
+    artifact
+      .context_dependencies
+      .add_files(&resource_id, factorize_info.context_dependencies());
+    artifact
+      .missing_dependencies
+      .add_files(&resource_id, factorize_info.missing_dependencies());
+
     // write factorize_info to dependencies[0] and set success factorize_info to others
     for dep in &mut dependencies {
       let dep_factorize_info = if let Some(d) = dep.as_context_dependency_mut() {

crates/rspack_core/src/dependency/factorize_info.rs

@@ -1,5 +1,3 @@
-use std::borrow::Cow;
-
 use rspack_cacheable::cacheable;
 use rspack_error::Diagnostic;
 use rspack_paths::ArcPathSet;
@@ -8,16 +6,12 @@ use super::{BoxDependency, DependencyId};
 
 #[cacheable]
 #[derive(Debug, Clone, Default)]
-pub enum FactorizeInfo {
-  #[default]
-  Success,
-  Failed {
-    related_dep_ids: Vec<DependencyId>,
-    file_dependencies: ArcPathSet,
-    context_dependencies: ArcPathSet,
-    missing_dependencies: ArcPathSet,
-    diagnostics: Vec<Diagnostic>,
-  },
+pub struct FactorizeInfo {
+  related_dep_ids: Vec<DependencyId>,
+  file_dependencies: ArcPathSet,
+  context_dependencies: ArcPathSet,
+  missing_dependencies: ArcPathSet,
+  diagnostics: Vec<Diagnostic>,
 }
 
 impl FactorizeInfo {
@@ -28,16 +22,12 @@ impl FactorizeInfo {
     context_dependencies: ArcPathSet,
     missing_dependencies: ArcPathSet,
   ) -> Self {
-    if diagnostics.is_empty() {
-      Self::Success
-    } else {
-      Self::Failed {
-        related_dep_ids,
-        file_dependencies,
-        context_dependencies,
-        missing_dependencies,
-        diagnostics,
-      }
+    Self {
+      related_dep_ids,
+      file_dependencies,
+      context_dependencies,
+      missing_dependencies,
+      diagnostics,
     }
   }
 
@@ -51,52 +41,37 @@ impl FactorizeInfo {
     }
   }
 
+  pub fn revoke(dep: &mut BoxDependency) -> Option<FactorizeInfo> {
+    if let Some(d) = dep.as_context_dependency_mut() {
+      Some(std::mem::take(d.factorize_info_mut()))
+    } else if let Some(d) = dep.as_module_dependency_mut() {
+      Some(std::mem::take(d.factorize_info_mut()))
+    } else {
+      None
+    }
+  }
+
   pub fn is_success(&self) -> bool {
-    matches!(self, FactorizeInfo::Success)
+    self.diagnostics.is_empty()
   }
 
-  pub fn related_dep_ids(&self) -> Cow<'_, [DependencyId]> {
-    match &self {
-      Self::Success => Cow::Owned(vec![]),
-      Self::Failed {
-        related_dep_ids, ..
-      } => Cow::Borrowed(related_dep_ids),
-    }
+  pub fn related_dep_ids(&self) -> &[DependencyId] {
+    &self.related_dep_ids
   }
 
-  pub fn file_dependencies(&self) -> Cow<'_, ArcPathSet> {
-    match &self {
-      Self::Success => Cow::Owned(Default::default()),
-      Self::Failed {
-        file_dependencies, ..
-      } => Cow::Borrowed(file_dependencies),
-    }
+  pub fn file_dependencies(&self) -> &ArcPathSet {
+    &self.file_dependencies
   }
 
-  pub fn context_dependencies(&self) -> Cow<'_, ArcPathSet> {
-    match &self {
-      Self::Success => Cow::Owned(Default::default()),
-      Self::Failed {
-        context_dependencies,
-        ..
-      } => Cow::Borrowed(context_dependencies),
-    }
+  pub fn context_dependencies(&self) -> &ArcPathSet {
+    &self.context_dependencies
   }
 
-  pub fn missing_dependencies(&self) -> Cow<'_, ArcPathSet> {
-    match &self {
-      Self::Success => Cow::Owned(Default::default()),
-      Self::Failed {
-        missing_dependencies,
-        ..
-      } => Cow::Borrowed(missing_dependencies),
-    }
+  pub fn missing_dependencies(&self) -> &ArcPathSet {
+    &self.missing_dependencies
   }
 
-  pub fn diagnostics(&self) -> Cow<'_, [Diagnostic]> {
-    match &self {
-      Self::Success => Cow::Owned(vec![]),
-      Self::Failed { diagnostics, .. } => Cow::Borrowed(diagnostics),
-    }
+  pub fn diagnostics(&self) -> &[Diagnostic] {
+    &self.diagnostics
   }
 }

crates/rspack_core/src/normal_module_factory.rs

@@ -478,8 +478,6 @@ impl NormalModuleFactory {
       resource_data.resource().to_owned()
     };
 
-    let file_dependency = resource_data.path().map(|p| p.to_owned());
-
     let resolved_module_type =
       self.calculate_module_type(match_module_type, &resolved_module_rules);
     let resolved_module_layer =
@@ -586,9 +584,6 @@ impl NormalModuleFactory {
       .call(data, &mut create_data, &mut module)
       .await?;
 
-    if let Some(file_dependency) = file_dependency {
-      data.add_file_dependency(file_dependency.into_std_path_buf());
-    }
     data.add_file_dependencies(file_dependencies);
     data.add_missing_dependencies(missing_dependencies);
 

tests/rspack-test/configCases/context/missing-dependency/rspack.config.js

@@ -6,9 +6,9 @@ module.exports = {
 		{
 			apply(compiler) {
 				compiler.hooks.done.tap("DonePlugin", stats => {
-					expect(Array.from(stats.compilation.missingDependencies)).toEqual([
+					expect(Array.from(stats.compilation.missingDependencies)).toContain(
 						path.resolve(__dirname, "./lang")
-					]);
+					);
 				});
 			}
 		}

tests/rspack-test/watchCases/resolve/alias/0/a.js

@@ -0,0 +1 @@
+export default "a";

tests/rspack-test/watchCases/resolve/alias/0/index.js

@@ -0,0 +1,19 @@
+import result from 'multi-alias';
+
+it('should update alias resolution when a higher-priority file is created in watch mode', () => {
+    switch (WATCH_STEP) {
+        case "0":
+            // Initial build:
+            // `b.js` does not exist, so it should fall back to `a.js`.
+            expect(result).toBe("a")
+            break;
+        case "1":
+            // After update (b.js is created):
+            // `b.js` now exists and has higher priority in the alias array.
+            // The build should now resolve to `b.js`.
+            expect(result).toBe("b")
+            break;
+        default:
+            throw new Error('unexpected update');
+    }
+})

tests/rspack-test/watchCases/resolve/alias/1/b.js

@@ -0,0 +1 @@
+export default "b";

tests/rspack-test/watchCases/resolve/alias/rspack.config.js

@@ -0,0 +1,11 @@
+/** @type {import("@rspack/core").Configuration} */
+module.exports = {
+    resolve: {
+        alias: {
+            "multi-alias": [
+                "./b",
+                "./a"
+            ]
+        }
+    }
+};