Merge #6027

6027: Spawn a flycheck instance per workspace r=matklad a=jonas-schievink

Limitations:

- All instances are restarted on every file change
- There's only one configuration used for all of them

Co-authored-by: Jonas Schievink <[email protected]>

Author: bors[bot]

crates/flycheck/src/lib.rs

@@ -59,11 +59,12 @@ pub struct FlycheckHandle {
 
 impl FlycheckHandle {
     pub fn spawn(
+        id: usize,
         sender: Box<dyn Fn(Message) + Send>,
         config: FlycheckConfig,
         workspace_root: PathBuf,
     ) -> FlycheckHandle {
-        let actor = FlycheckActor::new(sender, config, workspace_root);
+        let actor = FlycheckActor::new(id, sender, config, workspace_root);
         let (sender, receiver) = unbounded::<Restart>();
         let thread = jod_thread::spawn(move || actor.run(receiver));
         FlycheckHandle { sender, thread }
@@ -81,7 +82,11 @@ pub enum Message {
     AddDiagnostic { workspace_root: PathBuf, diagnostic: Diagnostic },
 
     /// Request check progress notification to client
-    Progress(Progress),
+    Progress {
+        /// Flycheck instance ID
+        id: usize,
+        progress: Progress,
+    },
 }
 
 #[derive(Debug)]
@@ -95,6 +100,7 @@ pub enum Progress {
 struct Restart;
 
 struct FlycheckActor {
+    id: usize,
     sender: Box<dyn Fn(Message) + Send>,
     config: FlycheckConfig,
     workspace_root: PathBuf,
@@ -113,11 +119,15 @@ enum Event {
 
 impl FlycheckActor {
     fn new(
+        id: usize,
         sender: Box<dyn Fn(Message) + Send>,
         config: FlycheckConfig,
         workspace_root: PathBuf,
     ) -> FlycheckActor {
-        FlycheckActor { sender, config, workspace_root, cargo_handle: None }
+        FlycheckActor { id, sender, config, workspace_root, cargo_handle: None }
+    }
+    fn progress(&self, progress: Progress) {
+        self.send(Message::Progress { id: self.id, progress });
     }
     fn next_event(&self, inbox: &Receiver<Restart>) -> Option<Event> {
         let check_chan = self.cargo_handle.as_ref().map(|cargo| &cargo.receiver);
@@ -139,7 +149,7 @@ impl FlycheckActor {
                     command.stdout(Stdio::piped()).stderr(Stdio::null()).stdin(Stdio::null());
                     if let Ok(child) = command.spawn().map(JodChild) {
                         self.cargo_handle = Some(CargoHandle::spawn(child));
-                        self.send(Message::Progress(Progress::DidStart));
+                        self.progress(Progress::DidStart);
                     }
                 }
                 Event::CheckEvent(None) => {
@@ -153,11 +163,11 @@ impl FlycheckActor {
                             self.check_command()
                         )
                     }
-                    self.send(Message::Progress(Progress::DidFinish(res)));
+                    self.progress(Progress::DidFinish(res));
                 }
                 Event::CheckEvent(Some(message)) => match message {
                     cargo_metadata::Message::CompilerArtifact(msg) => {
-                        self.send(Message::Progress(Progress::DidCheckCrate(msg.target.name)));
+                        self.progress(Progress::DidCheckCrate(msg.target.name));
                     }
 
                     cargo_metadata::Message::CompilerMessage(msg) => {
@@ -179,7 +189,7 @@ impl FlycheckActor {
     }
     fn cancel_check_process(&mut self) {
         if self.cargo_handle.take().is_some() {
-            self.send(Message::Progress(Progress::DidCancel));
+            self.progress(Progress::DidCancel);
         }
     }
     fn check_command(&self) -> Command {

crates/rust-analyzer/src/global_state.rs

@@ -63,7 +63,7 @@ pub(crate) struct GlobalState {
     req_queue: ReqQueue,
     pub(crate) task_pool: Handle<TaskPool<Task>, Receiver<Task>>,
     pub(crate) loader: Handle<Box<dyn vfs::loader::Handle>, Receiver<vfs::loader::Message>>,
-    pub(crate) flycheck: Option<FlycheckHandle>,
+    pub(crate) flycheck: Vec<FlycheckHandle>,
     pub(crate) flycheck_sender: Sender<flycheck::Message>,
     pub(crate) flycheck_receiver: Receiver<flycheck::Message>,
     pub(crate) config: Config,
@@ -115,7 +115,7 @@ impl GlobalState {
             req_queue: ReqQueue::default(),
             task_pool,
             loader,
-            flycheck: None,
+            flycheck: Vec::new(),
             flycheck_sender,
             flycheck_receiver,
             config,

crates/rust-analyzer/src/main_loop.rs

@@ -266,8 +266,8 @@ impl GlobalState {
                     }
                 }
 
-                flycheck::Message::Progress(status) => {
-                    let (state, message) = match status {
+                flycheck::Message::Progress { id, progress } => {
+                    let (state, message) = match progress {
                         flycheck::Progress::DidStart => {
                             self.diagnostics.clear_check();
                             (Progress::Begin, None)
@@ -284,14 +284,21 @@ impl GlobalState {
                         }
                     };
 
-                    self.report_progress("cargo check", state, message, None);
+                    // When we're running multiple flychecks, we have to include a disambiguator in
+                    // the title, or the editor complains. Note that this is a user-facing string.
+                    let title = if self.flycheck.len() == 1 {
+                        "cargo check".to_string()
+                    } else {
+                        format!("cargo check (#{})", id + 1)
+                    };
+                    self.report_progress(&title, state, message, None);
                 }
             },
         }
 
         let state_changed = self.process_changes();
         if prev_status == Status::Loading && self.status == Status::Ready {
-            if let Some(flycheck) = &self.flycheck {
+            for flycheck in &self.flycheck {
                 flycheck.update();
             }
         }
@@ -490,7 +497,7 @@ impl GlobalState {
                 Ok(())
             })?
             .on::<lsp_types::notification::DidSaveTextDocument>(|this, params| {
-                if let Some(flycheck) = &this.flycheck {
+                for flycheck in &this.flycheck {
                     flycheck.update();
                 }
                 if let Ok(abs_path) = from_proto::abs_path(&params.text_document.uri) {

crates/rust-analyzer/src/reload.rs

@@ -235,29 +235,37 @@ impl GlobalState {
         let config = match self.config.flycheck.clone() {
             Some(it) => it,
             None => {
-                self.flycheck = None;
+                self.flycheck = Vec::new();
                 return;
             }
         };
 
         let sender = self.flycheck_sender.clone();
-        let sender = Box::new(move |msg| sender.send(msg).unwrap());
         self.flycheck = self
             .workspaces
             .iter()
-            // FIXME: Figure out the multi-workspace situation
-            .find_map(|w| match w {
-                ProjectWorkspace::Cargo { cargo, sysroot: _ } => Some(cargo.workspace_root()),
+            .enumerate()
+            .filter_map(|(id, w)| match w {
+                ProjectWorkspace::Cargo { cargo, sysroot: _ } => Some((id, cargo.workspace_root())),
                 ProjectWorkspace::Json { project, .. } => {
                     // Enable flychecks for json projects if a custom flycheck command was supplied
                     // in the workspace configuration.
                     match config {
-                        FlycheckConfig::CustomCommand { .. } => Some(project.path()),
+                        FlycheckConfig::CustomCommand { .. } => Some((id, project.path())),
                         _ => None,
                     }
                 }
             })
-            .map(move |root| FlycheckHandle::spawn(sender, config, root.to_path_buf().into()))
+            .map(|(id, root)| {
+                let sender = sender.clone();
+                FlycheckHandle::spawn(
+                    id,
+                    Box::new(move |msg| sender.send(msg).unwrap()),
+                    config.clone(),
+                    root.to_path_buf().into(),
+                )
+            })
+            .collect();
     }
 }