detect file changes

Author: terhechte

Cargo.lock

@@ -38,3 +38,5 @@ rfd = "0.15.3"
 open = "5"
 shellexpand = "3.1.0"
 chrono = "0.4.40"
+notify = "8.0.0"
+notify-debouncer-mini = "0.6.0"

Cargo.toml

@@ -0,0 +1,75 @@
+use std::{path::PathBuf, sync::Arc, time::Duration};
+
+use anyhow::Result;
+use async_lsp::{LanguageServer, ServerSocket};
+use lsp_types::{DidChangeWatchedFilesParams, FileChangeType, FileEvent};
+use notify_debouncer_mini::{
+    DebounceEventResult, DebouncedEvent, Debouncer, new_debouncer, notify::*,
+};
+use tokio::{runtime::Handle, sync::Mutex};
+use url::Url;
+
+use crate::project::Project;
+
+#[derive(Debug)]
+pub struct ChangeNotifier {
+    #[allow(dead_code)] // Keep the handle to ensure the change notifier runs
+    debouncer: Debouncer<FsEventWatcher>,
+}
+
+impl ChangeNotifier {
+    pub fn new(
+        server: Arc<Mutex<ServerSocket>>,
+        project: &Project,
+        handle: Handle,
+    ) -> Result<Self> {
+        let handle_clone = handle.clone();
+        let target_path = project.root().join("target");
+        let mut debouncer = new_debouncer(
+            Duration::from_secs(2),
+            move |res: DebounceEventResult| match res {
+                Ok(events) => events.iter().for_each(|e| {
+                    handle_event(e, server.clone(), handle_clone.clone(), target_path.clone())
+                }),
+                Err(e) => tracing::error!("Error {:?}", e),
+            },
+        )?;
+
+        // We watch the root folder
+        debouncer
+            .watcher()
+            .watch(project.root(), RecursiveMode::Recursive)?;
+        Ok(Self { debouncer })
+    }
+}
+
+fn handle_event(
+    event: &DebouncedEvent,
+    server: Arc<Mutex<ServerSocket>>,
+    handle: Handle,
+    target_path: PathBuf,
+) {
+    // Don't trigger lsp on target files. Otherwise it will trigger itself.
+    if event.path.starts_with(&target_path) {
+        return;
+    }
+    tracing::trace!("Event {:?} for {:?}", event.kind, event.path);
+    let url = match Url::from_file_path(event.path.clone()) {
+        Ok(url) => url,
+        Err(e) => {
+            tracing::error!("Failed to convert file path to URL: {:?}", e);
+            return;
+        }
+    };
+    handle.spawn(async move {
+        match server
+            .lock()
+            .await
+            .did_change_watched_files(DidChangeWatchedFilesParams {
+                changes: vec![FileEvent::new(url, FileChangeType::CHANGED)],
+            }) {
+            Ok(_) => (),
+            Err(e) => tracing::error!("Failed to send DidChangeWatchedFiles notification: {:?}", e),
+        }
+    });
+}

src/lsp/change_notifier.rs

@@ -11,7 +11,11 @@ use lsp_types::{
 };
 
 // Old and new token names.
-const RA_INDEXING_TOKENS: &[&str] = &["rustAnalyzer/Indexing", "rustAnalyzer/cachePriming"];
+const RA_INDEXING_TOKENS: &[&str] = &[
+    "rustAnalyzer/Indexing",
+    "rustAnalyzer/cachePriming",
+    "rustAnalyzer/Building",
+];
 
 pub struct ClientState {
     project: PathBuf,
@@ -47,13 +51,8 @@ impl LanguageClient for ClientState {
                 tracing::error!("Failed to send indexing notification: {}", e);
             }
 
-            // Send a notification without consuming the sender
             if let Some(tx) = &self.indexed_tx {
-                // Use try_send or send_async depending on whether you want it to be blocking
-                // or potentially fail if the channel is full (though capacity is 1 here).
-                // try_send is likely fine if the receiver is waiting.
                 if let Err(e) = tx.try_send(()) {
-                    // Log if sending fails (e.g., channel full or disconnected)
                     tracing::error!("Failed to send indexing completion signal: {}", e);
                 }
             }

src/lsp/client_state.rs

@@ -1,3 +1,4 @@
+mod change_notifier;
 mod client_state;
 mod rust_analyzer_lsp;
 mod utils;

src/lsp/mod.rs

@@ -1,5 +1,6 @@
 use std::path::Path;
 use std::process::Stdio;
+use std::sync::Arc;
 
 use anyhow::{Context, Result};
 use async_lsp::concurrency::ConcurrencyLayer;
@@ -21,6 +22,7 @@ use tokio::task::JoinHandle;
 use tower::ServiceBuilder;
 use tracing::{debug, info};
 
+use super::change_notifier::ChangeNotifier;
 use super::client_state::ClientState;
 use crate::lsp::LspNotification;
 use crate::project::Project;
@@ -29,10 +31,12 @@ use flume::Sender;
 #[derive(Debug)]
 pub struct RustAnalyzerLsp {
     project: Project,
-    server: Mutex<ServerSocket>,
+    server: Arc<Mutex<ServerSocket>>,
     #[allow(dead_code)] // Keep the handle to ensure the mainloop runs
     mainloop_handle: Mutex<Option<JoinHandle<()>>>,
     indexed_rx: Mutex<flume::Receiver<()>>,
+    #[allow(dead_code)] // Keep the handle to ensure the change notifier runs
+    change_notifier: ChangeNotifier,
 }
 
 impl RustAnalyzerLsp {
@@ -69,11 +73,18 @@ impl RustAnalyzerLsp {
             }
         });
 
+        let server = Arc::new(Mutex::new(server));
+
+        // Get the current runtime handle
+        let handle = tokio::runtime::Handle::current();
+        let change_notifier = ChangeNotifier::new(server.clone(), project, handle)?;
+
         let client = Self {
             project: project.clone(),
-            server: Mutex::new(server),
+            server,
             mainloop_handle: Mutex::new(Some(mainloop_handle)),
             indexed_rx: Mutex::new(indexed_rx),
+            change_notifier,
         };
 
         // Initialize.