refactor: native watcher to make codes clear (#11282)

* refactor:  native watcher to make codes clear

Author: GiveMe-A-Name

crates/rspack_binding_api/src/native_watcher.rs

@@ -1,8 +1,9 @@
-use std::boxed::Box;
+use std::{boxed::Box, path::PathBuf};
 
 use napi::bindgen_prelude::*;
 use napi_derive::*;
-use rspack_fs::{FsWatcher, FsWatcherIgnored, FsWatcherOptions, PathUpdater};
+use rspack_fs::{FsWatcher, FsWatcherIgnored, FsWatcherOptions};
+use rspack_paths::ArcPath;
 use rspack_regex::RspackRegex;
 
 type JsWatcherIgnored = Either3<String, Vec<String>, RspackRegex>;
@@ -86,29 +87,14 @@ impl NativeWatcher {
     let js_event_handler = JsEventHandler::new(callback)?;
     let js_event_handler_undelayed = JsEventHandlerUndelayed::new(callback_undelayed)?;
 
-    let file_updater = PathUpdater {
-      added: files.0,
-      removed: files.1,
-    };
-
-    let directories_updater = PathUpdater {
-      added: directories.0,
-      removed: directories.1,
-    };
-
-    let missing_updater = PathUpdater {
-      added: missing.0,
-      removed: missing.1,
-    };
-
     reference.share_with(env, |native_watcher| {
       napi::bindgen_prelude::spawn(async move {
         native_watcher
           .watcher
           .watch(
-            file_updater,
-            directories_updater,
-            missing_updater,
+            to_tuple_path_iterator(files),
+            to_tuple_path_iterator(directories),
+            to_tuple_path_iterator(missing),
             Box::new(js_event_handler),
             Box::new(js_event_handler_undelayed),
           )
@@ -147,6 +133,15 @@ impl NativeWatcher {
   }
 }
 
+fn to_tuple_path_iterator(
+  tuple: (Vec<String>, Vec<String>),
+) -> (impl Iterator<Item = ArcPath>, impl Iterator<Item = ArcPath>) {
+  (
+    tuple.0.into_iter().map(|s| ArcPath::from(PathBuf::from(s))),
+    tuple.1.into_iter().map(|s| ArcPath::from(PathBuf::from(s))),
+  )
+}
+
 struct JsEventHandler {
   inner: napi::threadsafe_function::ThreadsafeFunction<
     NativeWatchResult,
@@ -177,8 +172,8 @@ impl JsEventHandler {
 impl rspack_fs::EventAggregateHandler for JsEventHandler {
   fn on_event_handle(
     &self,
-    changed_files: std::collections::HashSet<String>,
-    deleted_files: std::collections::HashSet<String>,
+    changed_files: rspack_util::fx_hash::FxHashSet<String>,
+    deleted_files: rspack_util::fx_hash::FxHashSet<String>,
   ) {
     let changed_files_vec: Vec<String> = changed_files.into_iter().collect();
     let deleted_files_vec: Vec<String> = deleted_files.into_iter().collect();

crates/rspack_fs/src/lib.rs

@@ -3,7 +3,7 @@ pub use read::ReadableFileSystem;
 
 mod watcher;
 pub use watcher::{
-  EventAggregateHandler, EventHandler, FsWatcher, FsWatcherIgnored, FsWatcherOptions, PathUpdater,
+  EventAggregateHandler, EventHandler, FsWatcher, FsWatcherIgnored, FsWatcherOptions,
 };
 
 mod write;

crates/rspack_fs/src/watcher/analyzer/directories.rs

@@ -3,7 +3,7 @@ use rspack_paths::ArcPath;
 use rspack_util::fx_hash::FxHashSet as HashSet;
 
 use super::{Analyzer, WatchPattern};
-use crate::watcher::path_manager::PathAccessor;
+use crate::watcher::paths::PathAccessor;
 
 /// `WatcherDirectoriesAnalyzer` analyzes the path register and determines
 ///
@@ -66,33 +66,29 @@ impl WatcherDirectoriesAnalyzer {
 #[cfg(test)]
 mod tests {
   use super::*;
-  use crate::watcher::path_manager::{PathManager, PathUpdater};
+  use crate::watcher::paths::PathManager;
 
   #[test]
   fn test_find_watch_directories() {
     let current_dir = std::env::current_dir().expect("Failed to get current directory");
     let path_manager = PathManager::default();
-    let file_updater = PathUpdater {
-      added: vec![
-        current_dir.join("Cargo.toml").to_string_lossy().to_string(),
-        current_dir.join("src/lib.rs").to_string_lossy().to_string(),
-      ],
-      removed: vec![],
-    };
-
-    let directory_updater = PathUpdater {
-      added: vec![current_dir.join("src").to_string_lossy().to_string()],
-      removed: vec![],
-    };
-
-    let missing_updater = PathUpdater {
-      added: vec![],
-      removed: vec![],
-    };
-
-    path_manager
-      .update_paths(file_updater, directory_updater, missing_updater)
-      .unwrap();
+    let files = (
+      vec![
+        current_dir.join("Cargo.toml").into(),
+        current_dir.join("src/lib.rs").into(),
+      ]
+      .into_iter(),
+      vec![].into_iter(),
+    );
+
+    let dirs = (
+      vec![current_dir.join("src").into()].into_iter(),
+      vec![].into_iter(),
+    );
+
+    let missing = (vec![].into_iter(), vec![].into_iter());
+
+    path_manager.update(files, dirs, missing).unwrap();
     let analyzer = WatcherDirectoriesAnalyzer::default();
     let watch_patterns = analyzer.analyze(path_manager.access());
 
@@ -115,33 +111,25 @@ mod tests {
     let dir_0 = ArcPath::from(current_dir.join("src"));
 
     let path_manager = PathManager::default();
-    let file_updater = PathUpdater {
-      added: vec![
-        current_dir.join("Cargo.toml").to_string_lossy().to_string(),
-        current_dir
-          .join("src/a/b/c/d.rs")
-          .to_string_lossy()
-          .to_string(),
-      ],
-      removed: vec![],
-    };
-    let directory_updater = PathUpdater {
-      added: vec![
-        current_dir.join("src").to_string_lossy().to_string(),
-        current_dir
-          .join("src/b/c/d/e")
-          .to_string_lossy()
-          .to_string(),
-      ],
-      removed: vec![],
-    };
-    let missing_updater = PathUpdater {
-      added: vec![],
-      removed: vec![],
-    };
-    path_manager
-      .update_paths(file_updater, directory_updater, missing_updater)
-      .unwrap();
+    let files = (
+      vec![
+        current_dir.join("Cargo.toml").into(),
+        current_dir.join("src/a/b/c/d.rs").into(),
+      ]
+      .into_iter(),
+      vec![].into_iter(),
+    );
+    let dirs = (
+      vec![
+        current_dir.join("src").into(),
+        current_dir.join("src/b/c/d/e").into(),
+      ]
+      .into_iter(),
+      vec![].into_iter(),
+    );
+    let missing = (vec![].into_iter(), vec![].into_iter());
+
+    path_manager.update(files, dirs, missing).unwrap();
 
     let analyzer = WatcherDirectoriesAnalyzer::default();
     let watch_patterns = analyzer.analyze(path_manager.access());

crates/rspack_fs/src/watcher/analyzer/mod.rs

@@ -1,24 +1,18 @@
-use crate::watcher::{WatchPattern, path_manager::PathAccessor};
+use crate::watcher::{WatchPattern, paths::PathAccessor};
 
 mod directories;
 mod root;
 
-/// The `Analyzer` trait defines an interface for analyzing a [`PathRegister`]
-/// and producing a set of [`WatchTarget`]s to be watched by the file system watcher.
-///
-/// Implementors of this trait should provide logic to determine which paths
-/// should be watched, and with what recursive mode, based on the current state
-/// of the path register.
-///
-/// The trait is bounded by `Default` to allow easy instantiation.
+/// The `Analyzer` trait defines an interface for analyzing a [`PathAccessor`]
+/// and producing a set of [`WatchPattern`]s to be watched by the file system watcher.
 pub(crate) trait Analyzer: Default {
   /// Analyze the given [`PathRegister`] and return a list of [`WatchTarget`]s.
   ///
   /// # Arguments
-  /// * `register` - The path register containing all paths to consider.
+  /// * `path_accessor` - A reference to a [`PathAccessor`] that provides access to the current state of paths, directories, and missing paths.
   ///
   /// # Returns
-  /// A vector of [`WatchTarget`]s representing the paths and their watch modes.
+  /// A vector of [`WatchPattern`]s representing the paths and their watch modes.
   fn analyze<'a>(&self, path_accessor: PathAccessor<'a>) -> Vec<WatchPattern>;
 }
 

crates/rspack_fs/src/watcher/analyzer/root.rs

@@ -1,42 +1,32 @@
 #![allow(unused)]
+use std::ops::Deref;
+
 use dashmap::DashSet as HashSet;
 use rspack_paths::ArcPath;
 use rspack_util::fx_hash::FxDashMap as HashMap;
 
 use super::{Analyzer, WatchPattern};
-use crate::watcher::path_manager::PathAccessor;
+use crate::watcher::paths::PathAccessor;
 
 #[derive(Default)]
+/// The `WatcherRootAnalyzer` is an implementation of the `Analyzer` trait that
+/// analyzes the root directory of the file system and determines the common root
+/// path to be watched.
 pub struct WatcherRootAnalyzer {
   path_tree: PathTree,
 }
 
 impl Analyzer for WatcherRootAnalyzer {
   fn analyze<'a>(&self, path_accessor: PathAccessor<'a>) -> Vec<WatchPattern> {
-    let incremental_files = path_accessor.incremental_files();
-    let incremental_directories = path_accessor.incremental_directories();
-    let incremental_missing = path_accessor.incremental_missing();
-
-    for added in incremental_files.added().iter() {
-      self.path_tree.add_path(&added);
-    }
+    let (_, added_files, removed_files) = path_accessor.files();
+    let (_, added_directories, removed_directories) = path_accessor.directories();
+    let (_, added_missing, removed_missing) = path_accessor.missing();
 
-    for removed in incremental_files.removed().iter() {
-      self.path_tree.remove_path(&removed);
-    }
-
-    for added in incremental_directories.added().iter() {
-      self.path_tree.add_path(&added);
-    }
-    for removed in incremental_directories.removed().iter() {
-      self.path_tree.remove_path(&removed);
-    }
-    for added in incremental_missing.added().iter() {
-      self.path_tree.add_path(&added);
-    }
-    for removed in incremental_missing.removed().iter() {
-      self.path_tree.remove_path(&removed);
-    }
+    self.path_tree.update_paths(added_files, removed_files);
+    self
+      .path_tree
+      .update_paths(added_directories, removed_directories);
+    self.path_tree.update_paths(added_missing, removed_missing);
 
     let common_root = self.path_tree.find_common_root();
 
@@ -80,6 +70,15 @@ impl PathTree {
     }
   }
 
+  pub fn update_paths(&self, added_paths: &HashSet<ArcPath>, removed_paths: &HashSet<ArcPath>) {
+    for added in added_paths.iter() {
+      self.add_path(added.deref());
+    }
+    for removed in removed_paths.iter() {
+      self.remove_path(removed.deref());
+    }
+  }
+
   pub fn add_path(&self, path: &ArcPath) {
     self.inner.entry(path.clone()).or_default();
     self.add_path_recursive(path);
@@ -153,7 +152,7 @@ mod tests {
   use rspack_paths::ArcPath;
 
   use super::*;
-  use crate::watcher::path_manager::{PathManager, PathUpdater};
+  use crate::watcher::paths::PathManager;
 
   #[test]
   fn test_find_watch_root() {
@@ -163,27 +162,10 @@ mod tests {
     let dir_0 = ArcPath::from(current_dir.clone());
     let dir_1 = ArcPath::from(current_dir.join("src"));
     let path_manager = PathManager::default();
-    let file_updater = PathUpdater {
-      added: vec![
-        file_0.to_string_lossy().to_string(),
-        file_1.to_string_lossy().to_string(),
-      ],
-      removed: vec![],
-    };
-    let directory_updater = PathUpdater {
-      added: vec![
-        dir_0.to_string_lossy().to_string(),
-        dir_1.to_string_lossy().to_string(),
-      ],
-      removed: vec![],
-    };
-    let missing_updater = PathUpdater {
-      added: vec![],
-      removed: vec![],
-    };
-    path_manager
-      .update_paths(file_updater, directory_updater, missing_updater)
-      .unwrap();
+    let files = (vec![file_0, file_1].into_iter(), vec![].into_iter());
+    let dirs = (vec![dir_0, dir_1].into_iter(), vec![].into_iter());
+    let missing = (vec![].into_iter(), vec![].into_iter());
+    path_manager.update(files, dirs, missing).unwrap();
 
     let analyzer = WatcherRootAnalyzer::default();
     let watch_patterns = analyzer.analyze(path_manager.access());
@@ -198,38 +180,19 @@ mod tests {
     let current_dir = std::env::current_dir().expect("Failed to get current directory");
 
     let path_manager = PathManager::default();
-    let file_updater = PathUpdater {
-      added: vec![],
-      removed: vec![],
-    };
-    let directory_updater = PathUpdater {
-      added: vec![],
-      removed: vec![],
-    };
-    let missing_updater = PathUpdater {
-      added: vec![
-        current_dir
-          .join("_missing")
-          .join("a")
-          .to_string_lossy()
-          .to_string(),
-        current_dir
-          .join("_missing")
-          .join("b")
-          .to_string_lossy()
-          .to_string(),
-        current_dir
-          .join("_missing")
-          .join("c.js")
-          .to_string_lossy()
-          .to_string(),
-      ],
-      removed: vec![],
-    };
-
-    path_manager
-      .update_paths(file_updater, directory_updater, missing_updater)
-      .unwrap();
+    let files = (vec![].into_iter(), vec![].into_iter());
+    let dirs = (vec![].into_iter(), vec![].into_iter());
+    let missing = (
+      vec![
+        current_dir.join("_missing").join("a").into(),
+        current_dir.join("_missing").join("b").into(),
+        current_dir.join("_missing").join("c.js").into(),
+      ]
+      .into_iter(),
+      vec![].into_iter(),
+    );
+
+    path_manager.update(files, dirs, missing).unwrap();
 
     let analyzer = WatcherRootAnalyzer::default();
     let watch_patterns = analyzer.analyze(path_manager.access());