switch to a task-based approach

Author: davidbarsky

crates/rust-analyzer/src/global_state.rs

@@ -83,7 +83,7 @@ pub(crate) struct GlobalState {
     pub(crate) last_flycheck_error: Option<String>,
 
     // VFS
-    pub(crate) loader: Handle<Box<dyn vfs::loader::Handle>, Receiver<vfs::loader::Message>>,
+    pub(crate) loader: Handle<Box<dyn vfs::loader::Handle + Send>, Receiver<vfs::loader::Message>>,
     pub(crate) vfs: Arc<RwLock<(vfs::Vfs, IntMap<FileId, LineEndings>)>>,
     pub(crate) vfs_config_version: u32,
     pub(crate) vfs_progress_config_version: u32,
@@ -149,7 +149,7 @@ impl GlobalState {
             let (sender, receiver) = unbounded::<vfs::loader::Message>();
             let handle: vfs_notify::NotifyHandle =
                 vfs::loader::Handle::spawn(Box::new(move |msg| sender.send(msg).unwrap()));
-            let handle = Box::new(handle) as Box<dyn vfs::loader::Handle>;
+            let handle = Box::new(handle) as Box<dyn vfs::loader::Handle + Send>;
             Handle { handle, receiver }
         };
 

crates/rust-analyzer/src/handlers/notification.rs

@@ -9,14 +9,16 @@ use lsp_types::{
     DidChangeWatchedFilesParams, DidChangeWorkspaceFoldersParams, DidCloseTextDocumentParams,
     DidOpenTextDocumentParams, DidSaveTextDocumentParams, WorkDoneProgressCancelParams,
 };
+use stdx::thread::ThreadIntent;
 use triomphe::Arc;
 use vfs::{AbsPathBuf, ChangeKind, VfsPath};
 
 use crate::{
     config::Config,
     global_state::GlobalState,
-    lsp::{ext, from_proto, utils::apply_document_changes},
+    lsp::{from_proto, utils::apply_document_changes},
     lsp_ext::RunFlycheckParams,
+    main_loop::Task,
     mem_docs::DocumentData,
     reload,
 };
@@ -64,13 +66,15 @@ pub(crate) fn handle_did_open_text_document(
         if already_exists {
             tracing::error!("duplicate DidOpenTextDocument: {}", path);
         }
-        {
-            let vfs = &mut state.vfs.write().0;
-            vfs.set_file_contents(path.clone(), Some(params.text_document.text.into_bytes()));
-        }
+
+        let vfs = &mut state.vfs.write().0;
+        vfs.set_file_contents(path, Some(params.text_document.text.into_bytes()));
 
         if state.config.notifications().unindexed_project {
-            run_unindexed_project(state, params.text_document.uri)
+            state.task_pool.handle.spawn(ThreadIntent::Worker, || {
+                tracing::debug!("dispatching task");
+                Task::FileIndexState(params.text_document.uri)
+            });
         }
     }
     Ok(())
@@ -348,25 +352,3 @@ pub(crate) fn handle_run_flycheck(
     }
     Ok(())
 }
-
-pub(crate) fn run_unindexed_project(state: &mut GlobalState, uri: lsp_types::Url) {
-    let _p = profile::span("run_unindexed_project");
-
-    if state.is_quiescent() {
-        tracing::debug!(processed_changes = state.process_changes());
-        let id = from_proto::file_id(&state.snapshot(), &uri).expect("Unable to get file ID");
-        if let Ok(crates) = state.snapshot().analysis.crates_for(id) {
-            if crates.is_empty() {
-                tracing::debug!(?uri, "rust-analyzer does not track this file");
-                let text_documents = vec![lsp_types::TextDocumentIdentifier { uri: uri }];
-                state.send_notification::<ext::UnindexedProject>(ext::UnindexedProjectParams {
-                    text_documents,
-                });
-            } else {
-                tracing::debug!(?uri, "file is indexed by rust-analyzer")
-            }
-        } else {
-            tracing::warn!("was unable to get analysis for crate")
-        }
-    }
-}

crates/rust-analyzer/src/main_loop.rs

@@ -1,5 +1,6 @@
 //! The main loop of `rust-analyzer` responsible for dispatching LSP
 //! requests/replies and notifications back to the client.
+use crate::lsp::ext;
 use std::{
     fmt,
     time::{Duration, Instant},
@@ -65,6 +66,7 @@ pub(crate) enum Task {
     Response(lsp_server::Response),
     Retry(lsp_server::Request),
     Diagnostics(Vec<(FileId, Vec<lsp_types::Diagnostic>)>),
+    FileIndexState(lsp_types::Url),
     PrimeCaches(PrimeCachesProgress),
     FetchWorkspace(ProjectWorkspaceProgress),
     FetchBuildData(BuildDataProgress),
@@ -199,7 +201,7 @@ impl GlobalState {
         let _p = profile::span("GlobalState::handle_event");
 
         let event_dbg_msg = format!("{event:?}");
-        tracing::debug!("{:?} handle_event({})", loop_start, event_dbg_msg);
+        tracing::debug!(?loop_start, ?event, "handle_event");
         if tracing::enabled!(tracing::Level::INFO) {
             let task_queue_len = self.task_pool.handle.len();
             if task_queue_len > 0 {
@@ -486,6 +488,27 @@ impl GlobalState {
             // Only retry requests that haven't been cancelled. Otherwise we do unnecessary work.
             Task::Retry(req) if !self.is_completed(&req) => self.on_request(req),
             Task::Retry(_) => (),
+            Task::FileIndexState(uri) => {
+                let _p = profile::span("run_unindexed_project");
+
+                tracing::debug!(changes = self.process_changes(), "processes changes");
+                let snap = self.snapshot();
+                let id =
+                    crate::lsp::from_proto::file_id(&snap, &uri).expect("Unable to get file ID");
+
+                if let Ok(crates) = &snap.analysis.crates_for(id) {
+                    if crates.is_empty() {
+                        tracing::debug!(?uri, "rust-analyzer does not track this file");
+                        self.send_notification::<ext::UnindexedProject>(
+                            ext::UnindexedProjectParams {
+                                text_documents: vec![lsp_types::TextDocumentIdentifier { uri }],
+                            },
+                        );
+                    } else {
+                        tracing::warn!("was unable to get analysis for crate")
+                    }
+                }
+            }
             Task::Diagnostics(diagnostics_per_file) => {
                 for (file_id, diagnostics) in diagnostics_per_file {
                     self.diagnostics.set_native_diagnostics(file_id, diagnostics)

crates/rust-analyzer/tests/slow-tests/support.rs

@@ -203,30 +203,31 @@ impl Server {
         N: lsp_types::notification::Notification,
         N::Params: Serialize,
     {
-        let msg = recv_timeout(&self.client.receiver).unwrap_or_else(|_| panic!("timed out"));
-
-        let Some(Message::Notification(actual)) = msg else {
-            panic!("did not get a notification");
-        };
-
-        if actual.method == N::METHOD {
-            let actual = actual
-                .clone()
-                .extract::<Value>(N::METHOD)
-                .expect("was not able to extract notification");
-
-            if let Some((expected_part, actual_part)) = find_mismatch(&expected, &actual) {
-                panic!(
-                    "JSON mismatch\nExpected:\n{}\nWas:\n{}\nExpected part:\n{}\nActual part:\n{}\n",
-                    to_string_pretty(&expected).unwrap(),
-                    to_string_pretty(&actual).unwrap(),
-                    to_string_pretty(expected_part).unwrap(),
-                    to_string_pretty(actual_part).unwrap(),
-                );
+        while let Some(Message::Notification(actual)) =
+            recv_timeout(&self.client.receiver).unwrap_or_else(|_| panic!("timed out"))
+        {
+            if actual.method == N::METHOD {
+                let actual = actual
+                    .clone()
+                    .extract::<Value>(N::METHOD)
+                    .expect("was not able to extract notification");
+
+                if let Some((expected_part, actual_part)) = find_mismatch(&expected, &actual) {
+                    panic!(
+                            "JSON mismatch\nExpected:\n{}\nWas:\n{}\nExpected part:\n{}\nActual part:\n{}\n",
+                            to_string_pretty(&expected).unwrap(),
+                            to_string_pretty(&actual).unwrap(),
+                            to_string_pretty(expected_part).unwrap(),
+                            to_string_pretty(actual_part).unwrap(),
+                        );
+                } else {
+                    return;
+                }
+            } else {
+                continue;
             }
-        } else {
-            panic!("mismatched method: {}", actual.method);
         }
+        panic!("never got expected notification");
     }
 
     #[track_caller]