Make Watcher a struct, not a trait

Summary: There are only two reasonable implementations, and they both live in the same file, so make it know that internally. Important to allow fallback from watchman to notify transparently.

Reviewed By: kinto0

Differential Revision: D73776764

fbshipit-source-id: f82aea11d683af1532dff5d606a891d1bb05f17d

Author: ndmitchell

pyrefly/Cargo.toml

@@ -20,7 +20,6 @@ path = "bin/main.rs"
 anyhow = "1.0.95"
 append-only-vec = "0.1.2"
 argfile = "0.1.6"
-async-trait = "0.1.86"
 blake3 = { version = "=1.5.5", features = ["mmap", "rayon", "traits-preview"] }
 bstr = { version = "1.10.0", features = ["serde", "std", "unicode"] }
 clap = { version = "4.5.30", features = ["derive", "env", "string", "unicode", "wrap_help"] }

pyrefly/bin/main.rs

@@ -18,7 +18,7 @@ use clap::Subcommand;
 use dupe::Dupe;
 use library::ArcId;
 use library::ConfigFile;
-use library::NotifyWatcher;
+use library::Watcher;
 use library::clap_env;
 use library::finder::ConfigFinder;
 use library::get_args_expanded;
@@ -109,7 +109,7 @@ async fn run_check(
     allow_forget: bool,
 ) -> anyhow::Result<CommandExitStatus> {
     if watch {
-        let watcher = NotifyWatcher::new(&files_to_check.roots())?;
+        let watcher = Watcher::notify(&files_to_check.roots())?;
         args.run_watch(watcher, files_to_check, config_finder)
             .await?;
         Ok(CommandExitStatus::Success)

pyrefly/lib/commands/check.rs

@@ -257,7 +257,7 @@ struct RequireLevels {
     default: Require,
 }
 
-async fn get_watcher_events(watcher: &mut impl Watcher) -> anyhow::Result<CategorizedEvents> {
+async fn get_watcher_events(watcher: &mut Watcher) -> anyhow::Result<CategorizedEvents> {
     loop {
         let events = CategorizedEvents::new(watcher.wait().await?);
         if !events.is_empty() {
@@ -312,7 +312,7 @@ impl Args {
 
     pub async fn run_watch(
         self,
-        mut watcher: impl Watcher,
+        mut watcher: Watcher,
         files_to_check: FilteredGlobs,
         config_finder: ConfigFinder,
     ) -> anyhow::Result<()> {

pyrefly/lib/lib.rs

@@ -80,11 +80,7 @@ pub mod library {
                 pub use crate::util::thread_pool::init_thread_pool;
                 pub use crate::util::trace::init_tracing;
                 #[cfg(not(target_arch = "wasm32"))]
-                pub use crate::util::watcher::NotifyWatcher;
-                #[cfg(not(target_arch = "wasm32"))]
                 pub use crate::util::watcher::Watcher;
-                #[cfg(not(target_arch = "wasm32"))]
-                pub use crate::util::watcher::Watchman;
             }
         }
     }

pyrefly/lib/util/watcher.rs

@@ -13,7 +13,6 @@ use std::time::Duration;
 use std::time::Instant;
 
 use anyhow::Context as _;
-use async_trait::async_trait;
 use notify::Event;
 use notify::RecursiveMode;
 use notify::Watcher as _;
@@ -30,28 +29,44 @@ use watchman_client::pdu::FileType;
 use watchman_client::pdu::SubscribeRequest;
 use watchman_client::pdu::SyncTimeout;
 
-#[async_trait]
-pub trait Watcher {
-    async fn wait(&mut self) -> anyhow::Result<Vec<Event>>;
+pub struct Watcher(WatcherInner);
+
+enum WatcherInner {
+    Watchman(Watchman),
+    Notify(NotifyWatcher),
 }
 
-pub struct NotifyWatcher {
+impl Watcher {
+    pub async fn wait(&mut self) -> anyhow::Result<Vec<Event>> {
+        match &mut self.0 {
+            WatcherInner::Watchman(w) => w.wait().await,
+            WatcherInner::Notify(w) => w.wait().await,
+        }
+    }
+
+    pub async fn watchman(path: &Path) -> anyhow::Result<Self> {
+        Ok(Self(WatcherInner::Watchman(Watchman::new(path).await?)))
+    }
+
+    pub fn notify(paths: &[PathBuf]) -> anyhow::Result<Self> {
+        Ok(Self(WatcherInner::Notify(NotifyWatcher::new(paths)?)))
+    }
+}
+
+struct NotifyWatcher {
     receiver: Receiver<notify::Result<Event>>,
 }
 
 impl NotifyWatcher {
-    pub fn new(paths: &[PathBuf]) -> anyhow::Result<Self> {
+    fn new(paths: &[PathBuf]) -> anyhow::Result<Self> {
         let (sender, receiver) = channel();
         let mut watcher = recommended_watcher(sender)?;
         for path in paths {
             watcher.watch(path, RecursiveMode::Recursive)?;
         }
         Ok(Self { receiver })
     }
-}
 
-#[async_trait]
-impl Watcher for NotifyWatcher {
     async fn wait(&mut self) -> anyhow::Result<Vec<Event>> {
         let mut res = Vec::new();
         res.push(self.receiver.recv()??);
@@ -122,13 +137,12 @@ mod watchman_query {
     }
 }
 
-pub struct Watchman {
+struct Watchman {
     root: PathBuf,
     subscription: Subscription<watchman_query::SubscriptionFields>,
 }
 
-#[async_trait]
-impl Watcher for Watchman {
+impl Watchman {
     async fn wait(&mut self) -> anyhow::Result<Vec<Event>> {
         loop {
             match self
@@ -157,10 +171,8 @@ impl Watcher for Watchman {
             }
         }
     }
-}
 
-impl Watchman {
-    pub async fn new(path: &Path) -> anyhow::Result<Self> {
+    async fn new(path: &Path) -> anyhow::Result<Self> {
         let root = CanonicalPath::canonicalize(path)?;
         let watchman_client = Connector::new()
             .connect()