1 files changed, 26 insertions, 30 deletions

diff --git a/crates/vfs-notify/src/lib.rs b/crates/vfs-notify/src/lib.rs
index baee6ddc8..25ba8d798 100644
--- a/crates/vfs-notify/src/lib.rs
+++ b/crates/vfs-notify/src/lib.rs
@@ -20,7 +20,7 @@ use walkdir::WalkDir;
 use crate::include::Include;
 
 #[derive(Debug)]
-pub struct LoaderHandle {
+pub struct NotifyHandle {
     // Relative order of fields below is significant.
     sender: crossbeam_channel::Sender<Message>,
     _thread: jod_thread::JoinHandle,
@@ -32,12 +32,12 @@ enum Message {
     Invalidate(AbsPathBuf),
 }
 
-impl loader::Handle for LoaderHandle {
-    fn spawn(sender: loader::Sender) -> LoaderHandle {
-        let actor = LoaderActor::new(sender);
+impl loader::Handle for NotifyHandle {
+    fn spawn(sender: loader::Sender) -> NotifyHandle {
+        let actor = NotifyActor::new(sender);
         let (sender, receiver) = unbounded::<Message>();
         let thread = jod_thread::spawn(move || actor.run(receiver));
-        LoaderHandle { sender, _thread: thread }
+        NotifyHandle { sender, _thread: thread }
     }
     fn set_config(&mut self, config: loader::Config) {
         self.sender.send(Message::Config(config)).unwrap()
@@ -45,17 +45,17 @@ impl loader::Handle for LoaderHandle {
     fn invalidate(&mut self, path: AbsPathBuf) {
         self.sender.send(Message::Invalidate(path)).unwrap();
     }
-    fn load_sync(&mut self, path: &AbsPathBuf) -> Option<Vec<u8>> {
+    fn load_sync(&mut self, path: &AbsPath) -> Option<Vec<u8>> {
         read(path)
     }
 }
 
 type NotifyEvent = notify::Result<notify::Event>;
 
-struct LoaderActor {
+struct NotifyActor {
+    sender: loader::Sender,
     config: Vec<(AbsPathBuf, Include, bool)>,
     watched_paths: FxHashSet<AbsPathBuf>,
-    sender: loader::Sender,
     // Drop order of fields bellow is significant,
     watcher: Option<RecommendedWatcher>,
     watcher_receiver: Receiver<NotifyEvent>,
@@ -67,30 +67,35 @@ enum Event {
     NotifyEvent(NotifyEvent),
 }
 
-impl LoaderActor {
-    fn new(sender: loader::Sender) -> LoaderActor {
+impl NotifyActor {
+    fn new(sender: loader::Sender) -> NotifyActor {
         let (watcher_sender, watcher_receiver) = unbounded();
         let watcher = log_notify_error(Watcher::new_immediate(move |event| {
             watcher_sender.send(event).unwrap()
         }));
 
-        LoaderActor {
-            watcher,
-            watcher_receiver,
-            watched_paths: FxHashSet::default(),
+        NotifyActor {
             sender,
             config: Vec::new(),
+            watched_paths: FxHashSet::default(),
+            watcher,
+            watcher_receiver,
         }
     }
-
-    fn run(mut self, receiver: Receiver<Message>) {
-        while let Some(event) = self.next_event(&receiver) {
+    fn next_event(&self, receiver: &Receiver<Message>) -> Option<Event> {
+        select! {
+            recv(receiver) -> it => it.ok().map(Event::Message),
+            recv(&self.watcher_receiver) -> it => Some(Event::NotifyEvent(it.unwrap())),
+        }
+    }
+    fn run(mut self, inbox: Receiver<Message>) {
+        while let Some(event) = self.next_event(&inbox) {
             log::debug!("vfs-notify event: {:?}", event);
             match event {
                 Event::Message(msg) => match msg {
                     Message::Config(config) => {
-                        let n_entries_total = config.load.len();
-                        self.send(loader::Message::Progress { n_entries_total, n_entries_done: 0 });
+                        let n_total = config.load.len();
+                        self.send(loader::Message::Progress { n_total, n_done: 0 });
 
                         self.unwatch_all();
                         self.config.clear();
@@ -99,10 +104,7 @@ impl LoaderActor {
                             let watch = config.watch.contains(&i);
                             let files = self.load_entry(entry, watch);
                             self.send(loader::Message::Loaded { files });
-                            self.send(loader::Message::Progress {
-                                n_entries_total,
-                                n_entries_done: i + 1,
-                            });
+                            self.send(loader::Message::Progress { n_total, n_done: i + 1 });
                         }
                         self.config.sort_by(|x, y| x.0.cmp(&y.0));
                     }
@@ -157,12 +159,6 @@ impl LoaderActor {
             }
         }
     }
-    fn next_event(&self, receiver: &Receiver<Message>) -> Option<Event> {
-        select! {
-            recv(receiver) -> it => it.ok().map(Event::Message),
-            recv(&self.watcher_receiver) -> it => Some(Event::NotifyEvent(it.unwrap())),
-        }
-    }
     fn load_entry(
         &mut self,
         entry: loader::Entry,
@@ -199,7 +195,7 @@ impl LoaderActor {
                         let is_dir = entry.file_type().is_dir();
                         let is_file = entry.file_type().is_file();
                         let abs_path = AbsPathBuf::try_from(entry.into_path()).unwrap();
-                        if is_dir {
+                        if is_dir && watch {
                             self.watch(abs_path.clone());
                         }
                         let rel_path = abs_path.strip_prefix(&path)?;