1 files changed, 56 insertions, 36 deletions

diff --git a/crates/ra_lsp_server/src/main_loop.rs b/crates/ra_lsp_server/src/main_loop.rs
index 15bf519c9..9901fe931 100644
--- a/crates/ra_lsp_server/src/main_loop.rs
+++ b/crates/ra_lsp_server/src/main_loop.rs
@@ -5,11 +5,18 @@ mod handlers;
 mod subscriptions;
 pub(crate) mod pending_requests;
 
-use std::{error::Error, fmt, panic, path::PathBuf, sync::Arc, time::Instant};
+use std::{
+    env,
+    error::Error,
+    fmt, panic,
+    path::PathBuf,
+    sync::Arc,
+    time::{Duration, Instant},
+};
 
 use crossbeam_channel::{select, unbounded, RecvError, Sender};
 use lsp_server::{Connection, ErrorCode, Message, Notification, Request, RequestId, Response};
-use lsp_types::{ClientCapabilities, NumberOrString, Url};
+use lsp_types::{ClientCapabilities, NumberOrString};
 use ra_cargo_watch::{CheckOptions, CheckTask};
 use ra_ide::{Canceled, FeatureFlags, FileId, LibraryData, SourceRootId};
 use ra_prof::profile;
@@ -352,7 +359,7 @@ fn loop_turn(
             world_state.maybe_collect_garbage();
             loop_state.in_flight_libraries -= 1;
         }
-        Event::CheckWatcher(task) => on_check_task(task, world_state, task_sender)?,
+        Event::CheckWatcher(task) => on_check_task(pool, task, world_state, task_sender)?,
         Event::Msg(msg) => match msg {
             Message::Request(req) => on_request(
                 world_state,
@@ -425,6 +432,19 @@ fn loop_turn(
             loop_state.subscriptions.subscriptions(),
         )
     }
+
+    let loop_duration = loop_start.elapsed();
+    if loop_duration > Duration::from_millis(10) {
+        log::error!("overly long loop turn: {:?}", loop_duration);
+        if env::var("RA_PROFILE").is_ok() {
+            show_message(
+                req::MessageType::Error,
+                format!("overly long loop turn: {:?}", loop_duration),
+                &connection.sender,
+            );
+        }
+    }
+
     Ok(())
 }
 
@@ -452,7 +472,7 @@ fn on_request(
     world: &mut WorldState,
     pending_requests: &mut PendingRequests,
     pool: &ThreadPool,
-    sender: &Sender<Task>,
+    task_sender: &Sender<Task>,
     msg_sender: &Sender<Message>,
     request_received: Instant,
     req: Request,
@@ -461,7 +481,7 @@ fn on_request(
         req: Some(req),
         pool,
         world,
-        sender,
+        task_sender,
         msg_sender,
         pending_requests,
         request_received,
@@ -602,31 +622,23 @@ fn on_notification(
 }
 
 fn on_check_task(
+    pool: &ThreadPool,
     task: CheckTask,
     world_state: &mut WorldState,
     task_sender: &Sender<Task>,
 ) -> Result<()> {
-    match task {
+    let urls = match task {
         CheckTask::ClearDiagnostics => {
             let state = Arc::get_mut(&mut world_state.check_watcher.state)
                 .expect("couldn't get check watcher state as mutable");
-            let cleared_files = state.clear();
-
-            // Send updated diagnostics for each cleared file
-            for url in cleared_files {
-                publish_diagnostics_for_url(&url, world_state, task_sender)?;
-            }
+            state.clear()
         }
 
         CheckTask::AddDiagnostic(url, diagnostic) => {
             let state = Arc::get_mut(&mut world_state.check_watcher.state)
                 .expect("couldn't get check watcher state as mutable");
             state.add_diagnostic_with_fixes(url.clone(), diagnostic);
-
-            // We manually send a diagnostic update when the watcher asks
-            // us to, to avoid the issue of having to change the file to
-            // receive updated diagnostics.
-            publish_diagnostics_for_url(&url, world_state, task_sender)?;
+            vec![url]
         }
 
         CheckTask::Status(progress) => {
@@ -636,22 +648,30 @@ fn on_check_task(
             };
             let not = notification_new::<req::Progress>(params);
             task_sender.send(Task::Notify(not)).unwrap();
+            Vec::new()
         }
-    }
-    Ok(())
-}
+    };
+
+    let subscriptions = urls
+        .into_iter()
+        .map(|url| {
+            let path = url.to_file_path().map_err(|()| format!("invalid uri: {}", url))?;
+            Ok(world_state.vfs.read().path2file(&path).map(|it| FileId(it.0)))
+        })
+        .filter_map(|res| res.transpose())
+        .collect::<Result<Vec<_>>>()?;
+
+    // We manually send a diagnostic update when the watcher asks
+    // us to, to avoid the issue of having to change the file to
+    // receive updated diagnostics.
+    update_file_notifications_on_threadpool(
+        pool,
+        world_state.snapshot(),
+        false,
+        task_sender.clone(),
+        subscriptions,
+    );
 
-fn publish_diagnostics_for_url(
-    url: &Url,
-    world_state: &WorldState,
-    task_sender: &Sender<Task>,
-) -> Result<()> {
-    let path = url.to_file_path().map_err(|()| format!("invalid uri: {}", url))?;
-    if let Some(file_id) = world_state.vfs.read().path2file(&path) {
-        let params = handlers::publish_diagnostics(&world_state.snapshot(), FileId(file_id.0))?;
-        let not = notification_new::<req::PublishDiagnostics>(params);
-        task_sender.send(Task::Notify(not)).unwrap();
-    }
     Ok(())
 }
 
@@ -661,7 +681,7 @@ struct PoolDispatcher<'a> {
     world: &'a mut WorldState,
     pending_requests: &'a mut PendingRequests,
     msg_sender: &'a Sender<Message>,
-    sender: &'a Sender<Task>,
+    task_sender: &'a Sender<Task>,
     request_received: Instant,
 }
 
@@ -708,7 +728,7 @@ impl<'a> PoolDispatcher<'a> {
 
         self.pool.execute({
             let world = self.world.snapshot();
-            let sender = self.sender.clone();
+            let sender = self.task_sender.clone();
             move || {
                 let result = f(world, params);
                 let task = result_to_task::<R>(id, result);
@@ -786,7 +806,7 @@ fn update_file_notifications_on_threadpool(
     pool: &ThreadPool,
     world: WorldSnapshot,
     publish_decorations: bool,
-    sender: Sender<Task>,
+    task_sender: Sender<Task>,
     subscriptions: Vec<FileId>,
 ) {
     log::trace!("updating notifications for {:?}", subscriptions);
@@ -802,7 +822,7 @@ fn update_file_notifications_on_threadpool(
                     }
                     Ok(params) => {
                         let not = notification_new::<req::PublishDiagnostics>(params);
-                        sender.send(Task::Notify(not)).unwrap();
+                        task_sender.send(Task::Notify(not)).unwrap();
                     }
                 }
             }
@@ -815,7 +835,7 @@ fn update_file_notifications_on_threadpool(
                     }
                     Ok(params) => {
                         let not = notification_new::<req::PublishDecorations>(params);
-                        sender.send(Task::Notify(not)).unwrap();
+                        task_sender.send(Task::Notify(not)).unwrap();
                     }
                 }
             }