Small refactoring

Author: tuguzT

crates/spirv-builder/src/watch.rs

@@ -1,6 +1,8 @@
-use std::path::{Path, PathBuf};
-use std::sync::mpsc::Receiver;
-use std::{collections::HashSet, sync::mpsc::sync_channel};
+use std::{
+    collections::HashSet,
+    path::{Path, PathBuf},
+    sync::mpsc::{Receiver, sync_channel},
+};
 
 use notify::{Event, RecommendedWatcher, RecursiveMode, Watcher};
 use rustc_codegen_spirv_types::CompileResult;
@@ -14,13 +16,16 @@ impl SpirvBuilder {
     }
 }
 
+type WatchedPaths = HashSet<PathBuf>;
+
+/// Watcher of a crate which rebuilds it on changes.
 #[derive(Debug)]
 pub struct SpirvWatcher<B> {
     builder: B,
     watcher: RecommendedWatcher,
     rx: Receiver<()>,
     watch_path: PathBuf,
-    watched_paths: HashSet<PathBuf>,
+    watched_paths: WatchedPaths,
     first_result: bool,
 }
 
@@ -67,6 +72,10 @@ where
         })
     }
 
+    /// Blocks the current thread until a change is detected
+    /// and the crate is rebuilt.
+    ///
+    /// Result of rebuilding of the crate is then returned to the caller.
     pub fn recv(&mut self) -> Result<CompileResult, SpirvBuilderError> {
         if !self.first_result {
             return self.recv_first_result();
@@ -77,7 +86,7 @@ where
         let metadata_file = crate::invoke_rustc(builder)?;
         let result = builder.parse_metadata_file(&metadata_file)?;
 
-        self.watch_leaf_deps(&self.watch_path.clone())?;
+        Self::watch_leaf_deps(&self.watch_path, &mut self.watched_paths, &mut self.watcher)?;
         Ok(result)
     }
 
@@ -88,8 +97,9 @@ where
             Err(err) => {
                 log::error!("{err}");
 
+                let watch_path = self.watch_path.as_ref();
                 self.watcher
-                    .watch(&self.watch_path, RecursiveMode::Recursive)
+                    .watch(watch_path, RecursiveMode::Recursive)
                     .map_err(SpirvWatcherError::NotifyFailed)?;
                 let path = loop {
                     self.rx.recv().expect("watcher should be alive");
@@ -99,26 +109,28 @@ where
                     }
                 };
                 self.watcher
-                    .unwatch(&self.watch_path)
+                    .unwatch(watch_path)
                     .map_err(SpirvWatcherError::NotifyFailed)?;
                 path
             }
         };
         let result = builder.parse_metadata_file(&metadata_file)?;
 
-        self.watch_leaf_deps(&metadata_file)?;
+        Self::watch_leaf_deps(&metadata_file, &mut self.watched_paths, &mut self.watcher)?;
         self.watch_path = metadata_file;
         self.first_result = true;
         Ok(result)
     }
 
-    fn watch_leaf_deps(&mut self, metadata_file: &Path) -> Result<(), SpirvBuilderError> {
-        leaf_deps(metadata_file, |it| {
-            let path = it.to_path().unwrap();
-            if self.watched_paths.insert(path.to_owned())
-                && let Err(err) = self
-                    .watcher
-                    .watch(it.to_path().unwrap(), RecursiveMode::NonRecursive)
+    fn watch_leaf_deps(
+        metadata_file: &Path,
+        watched_paths: &mut WatchedPaths,
+        watcher: &mut RecommendedWatcher,
+    ) -> Result<(), SpirvBuilderError> {
+        leaf_deps(metadata_file, |artifact| {
+            let path = artifact.to_path().unwrap();
+            if watched_paths.insert(path.to_owned())
+                && let Err(err) = watcher.watch(path, RecursiveMode::NonRecursive)
             {
                 log::error!("files of cargo dependencies are not valid: {err}");
             }
@@ -127,10 +139,14 @@ where
     }
 }
 
-impl SpirvWatcher<&SpirvBuilder> {
+impl<B> SpirvWatcher<B>
+where
+    B: AsRef<SpirvBuilder>,
+{
+    #[inline]
     pub fn forget_lifetime(self) -> SpirvWatcher<SpirvBuilder> {
         SpirvWatcher {
-            builder: self.builder.clone(),
+            builder: self.builder.as_ref().clone(),
             watcher: self.watcher,
             rx: self.rx,
             watch_path: self.watch_path,