integate reloading

davidbarsky · davidbarsky · commit 7d6408aca882 · 2024-06-10T16:51:29.000-04:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/flycheck/src/json_workspace.rs b/crates/flycheck/src/json_workspace.rs
@@ -2,7 +2,7 @@
 use std::{io, process::Command};
 
 use crossbeam_channel::Sender;
-use paths::AbsPathBuf;
+use paths::Utf8PathBuf;
 use project_model::ProjectJsonData;
 use serde::{Deserialize, Serialize};
 
@@ -16,21 +16,29 @@ pub struct JsonWorkspace {
     sender: Sender<DiscoverProjectMessage>,
 }
 
+#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum JsonArguments {
+    Path(Utf8PathBuf),
+    Label(String),
+}
+
 impl JsonWorkspace {
     /// Create a new [JsonWorkspace].
     pub fn new(sender: Sender<DiscoverProjectMessage>, command: Vec<String>) -> Self {
         Self { sender, command }
     }
 
     /// Spawn the command inside [JsonWorkspace] and report progress, if any.
-    pub fn spawn(&self, files: Vec<AbsPathBuf>) -> io::Result<JsonWorkspaceHandle> {
+    pub fn spawn(&self, arg: JsonArguments) -> io::Result<JsonWorkspaceHandle> {
         let command = &self.command[0];
         let args = &self.command[1..];
-        let first_file: &AbsPathBuf = &files[0];
 
         let mut cmd = Command::new(command);
         cmd.args(args);
-        cmd.arg(first_file);
+
+        let arg = serde_json::to_string(&arg)?;
+        cmd.arg(arg);
 
         Ok(JsonWorkspaceHandle { _handle: CommandHandle::spawn(cmd, self.sender.clone())? })
     }
@@ -48,7 +56,13 @@ pub struct JsonWorkspaceHandle {
 pub enum DiscoverProjectMessage {
     Error { message: String, context: Option<String> },
     Progress { message: String },
-    Finished { project_json: Vec<ProjectJsonData> },
+    Finished(FinishedOutput),
+}
+
+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
+pub struct FinishedOutput {
+    pub project: ProjectJsonData,
+    pub buildfile: Utf8PathBuf,
 }
 
 impl ParseFromLine for DiscoverProjectMessage {
@@ -57,8 +71,8 @@ impl ParseFromLine for DiscoverProjectMessage {
             return Some(DiscoverProjectMessage::Error { message: line.to_owned(), context: None });
         };
 
-        if let Ok(project) = serde_json::from_value::<ProjectJsonData>(value.clone()) {
-            return Some(DiscoverProjectMessage::Finished { project_json: vec![project] });
+        if let Ok(project) = serde_json::from_value::<FinishedOutput>(value.clone()) {
+            return Some(DiscoverProjectMessage::Finished(project));
         }
 
         if let Some(message) = value.pointer("/fields/message") {
diff --git a/crates/flycheck/src/lib.rs b/crates/flycheck/src/lib.rs
@@ -26,7 +26,9 @@ mod json_workspace;
 mod test_runner;
 
 use command::{CommandHandle, ParseFromLine};
-pub use json_workspace::{DiscoverProjectMessage, JsonWorkspace, JsonWorkspaceHandle};
+pub use json_workspace::{
+    DiscoverProjectMessage, JsonArguments, JsonWorkspace, JsonWorkspaceHandle,
+};
 pub use test_runner::{CargoTestHandle, CargoTestMessage, TestState};
 
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
diff --git a/crates/project-model/src/project_json.rs b/crates/project-model/src/project_json.rs
@@ -222,6 +222,15 @@ impl ProjectJson {
         self.manifest.as_ref()
     }
 
+    pub fn crate_by_buildfile(&self, path: &AbsPath) -> Option<Build> {
+        let path: &std::path::Path = path.as_ref();
+        self.crates
+            .iter()
+            .filter(|krate| krate.is_workspace_member)
+            .filter_map(|krate| krate.build.clone())
+            .find(|build| build.build_file.as_std_path() == path)
+    }
+
     /// Returns the path to the project's manifest or root folder, if no manifest exists.
     pub fn manifest_or_root(&self) -> &AbsPath {
         self.manifest.as_ref().map_or(&self.project_root, |manifest| manifest.as_ref())
@@ -279,7 +288,7 @@ enum EditionData {
     Edition2024,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
 pub struct BuildData {
     label: String,
     build_file: Utf8PathBuf,
@@ -366,7 +375,7 @@ pub(crate) struct Dep {
     pub(crate) name: CrateName,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
 struct CrateSource {
     include_dirs: Vec<Utf8PathBuf>,
     exclude_dirs: Vec<Utf8PathBuf>,
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
@@ -39,6 +39,7 @@ mimalloc = { version = "0.1.30", default-features = false, optional = true }
 lsp-server.workspace = true
 tracing.workspace = true
 tracing-subscriber.workspace = true
+pretty_assertions = "1.4"
 tracing-tree.workspace = true
 triomphe.workspace = true
 toml = "0.8.8"
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
@@ -2349,7 +2349,7 @@ mod single_or_array {
     }
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
 #[serde(untagged)]
 enum ManifestOrProjectJson {
     Manifest(Utf8PathBuf),
diff --git a/crates/rust-analyzer/src/global_state.rs b/crates/rust-analyzer/src/global_state.rs
@@ -22,7 +22,7 @@ use project_model::{ManifestPath, ProjectWorkspace, ProjectWorkspaceKind, Worksp
 use rustc_hash::{FxHashMap, FxHashSet};
 use tracing::{span, trace, Level};
 use triomphe::Arc;
-use vfs::{AnchoredPathBuf, ChangeKind, Vfs};
+use vfs::{AbsPathBuf, AnchoredPathBuf, ChangeKind, Vfs};
 
 use crate::{
     config::{Config, ConfigChange, ConfigErrors},
@@ -139,7 +139,7 @@ pub(crate) struct GlobalState {
 
     // op queues
     pub(crate) fetch_workspaces_queue:
-        OpQueue<bool, Option<(Vec<anyhow::Result<ProjectWorkspace>>, bool)>>,
+        OpQueue<(Option<AbsPathBuf>, bool), Option<(Vec<anyhow::Result<ProjectWorkspace>>, bool)>>,
     pub(crate) fetch_build_data_queue:
         OpQueue<(), (Arc<Vec<ProjectWorkspace>>, Vec<anyhow::Result<WorkspaceBuildScripts>>)>,
     pub(crate) fetch_proc_macros_queue: OpQueue<Vec<ProcMacroPaths>, bool>,
@@ -434,7 +434,7 @@ impl GlobalState {
 
                 self.fetch_workspaces_queue.request_op(
                     format!("workspace vfs file change: {path}"),
-                    force_crate_graph_reload,
+                    (Some(path.to_owned()), force_crate_graph_reload),
                 );
             }
         }
diff --git a/crates/rust-analyzer/src/handlers/notification.rs b/crates/rust-analyzer/src/handlers/notification.rs
@@ -152,13 +152,15 @@ pub(crate) fn handle_did_save_text_document(
         // Re-fetch workspaces if a workspace related file has changed
         if let Some(abs_path) = vfs_path.as_path() {
             if reload::should_refresh_for_change(abs_path, ChangeKind::Modify) {
-                state
-                    .fetch_workspaces_queue
-                    .request_op(format!("workspace vfs file change saved {abs_path}"), false);
+                state.fetch_workspaces_queue.request_op(
+                    format!("workspace vfs file change saved {abs_path}"),
+                    (Some(abs_path.to_owned()), false),
+                );
             } else if state.detached_files.contains(abs_path) {
-                state
-                    .fetch_workspaces_queue
-                    .request_op(format!("detached file saved {abs_path}"), false);
+                state.fetch_workspaces_queue.request_op(
+                    format!("detached file saved {abs_path}"),
+                    (Some(abs_path.to_owned()), false),
+                );
             }
         }
 
@@ -240,7 +242,9 @@ pub(crate) fn handle_did_change_workspace_folders(
 
     if !config.has_linked_projects() && config.detached_files().is_empty() {
         config.rediscover_workspaces();
-        state.fetch_workspaces_queue.request_op("client workspaces changed".to_owned(), false)
+        state
+            .fetch_workspaces_queue
+            .request_op("client workspaces changed".to_owned(), (None, false));
     }
 
     Ok(())
diff --git a/crates/rust-analyzer/src/handlers/request.rs b/crates/rust-analyzer/src/handlers/request.rs
@@ -57,7 +57,7 @@ pub(crate) fn handle_workspace_reload(state: &mut GlobalState, _: ()) -> anyhow:
     state.proc_macro_clients = Arc::from_iter([]);
     state.build_deps_changed = false;
 
-    state.fetch_workspaces_queue.request_op("reload workspace request".to_owned(), false);
+    state.fetch_workspaces_queue.request_op("reload workspace request".to_owned(), (None, false));
     Ok(())
 }
 
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
@@ -9,12 +9,14 @@ use std::{
 
 use always_assert::always;
 use crossbeam_channel::{select, Receiver};
+use flycheck::JsonArguments;
 use ide_db::base_db::{SourceDatabase, SourceDatabaseExt, VfsPath};
 use lsp_server::{Connection, Notification, Request};
 use lsp_types::{notification::Notification as _, TextDocumentIdentifier, Url};
+use paths::Utf8PathBuf;
 use stdx::thread::ThreadIntent;
 use tracing::{span, Level};
-use vfs::{AbsPathBuf, FileId};
+use vfs::FileId;
 
 use crate::{
     config::Config,
@@ -88,7 +90,7 @@ pub(crate) enum QueuedTask {
 #[derive(Debug)]
 pub(crate) enum Task {
     Response(lsp_server::Response),
-    DiscoverLinkedProjects(Url),
+    DiscoverLinkedProjects(DiscoverProjectParam),
     Retry(lsp_server::Request),
     Diagnostics(DiagnosticsGeneration, Vec<(FileId, Vec<lsp_types::Diagnostic>)>),
     DiscoverTest(lsp_ext::DiscoverTestResults),
@@ -99,6 +101,12 @@ pub(crate) enum Task {
     BuildDepsHaveChanged,
 }
 
+#[derive(Debug)]
+pub(crate) enum DiscoverProjectParam {
+    Label(String),
+    Path(Url),
+}
+
 #[derive(Debug)]
 pub(crate) enum PrimeCachesProgress {
     Begin,
@@ -150,11 +158,11 @@ impl GlobalState {
         }
 
         if self.config.discover_command().is_none() {
-            self.fetch_workspaces_queue.request_op("startup".to_owned(), false);
-            if let Some((cause, force_crate_graph_reload)) =
+            self.fetch_workspaces_queue.request_op("startup".to_owned(), (None, false));
+            if let Some((cause, (path, force_crate_graph_reload))) =
                 self.fetch_workspaces_queue.should_start_op()
             {
-                self.fetch_workspaces(cause, force_crate_graph_reload);
+                self.fetch_workspaces(cause, path, force_crate_graph_reload);
             }
         }
 
@@ -195,7 +203,12 @@ impl GlobalState {
                     lsp_types::DocumentFilter {
                         language: None,
                         scheme: None,
-                        pattern: Some("**/rust-analyzer.toml".into()),
+                        pattern: Some("**/BUCK".into()),
+                    },
+                    lsp_types::DocumentFilter {
+                        language: None,
+                        scheme: None,
+                        pattern: Some("**/TARGETS".into()),
                     },
                 ]),
             },
@@ -442,10 +455,10 @@ impl GlobalState {
         }
 
         if self.config.cargo_autoreload_config() || self.config.discover_command().is_some() {
-            if let Some((cause, force_crate_graph_reload)) =
+            if let Some((cause, (path, force_crate_graph_reload))) =
                 self.fetch_workspaces_queue.should_start_op()
             {
-                self.fetch_workspaces(cause, force_crate_graph_reload);
+                self.fetch_workspaces(cause, path, force_crate_graph_reload);
             }
         }
 
@@ -658,23 +671,29 @@ impl GlobalState {
 
                 self.report_progress("Fetching", state, msg, None, None);
             }
-            Task::DiscoverLinkedProjects(url) => {
+            Task::DiscoverLinkedProjects(arg) => {
                 if let Some(command) = self.config.discover_command() {
                     if !self.discover_workspace_queue.op_in_progress() {
                         let discover =
                             flycheck::JsonWorkspace::new(self.discover_sender.clone(), command);
 
-                        let path = url
-                            .to_file_path()
-                            .unwrap_or_else(|_| panic!("Unable to get file path from {}", url));
-                        let files = vec![AbsPathBuf::try_from(path).unwrap()];
-
                         self.report_progress("Buck", Progress::Begin, None, None, None);
                         self.discover_workspace_queue
                             .request_op("Discovering workspace".to_owned(), ());
                         let _ = self.discover_workspace_queue.should_start_op();
 
-                        let handle = discover.spawn(files).unwrap();
+                        let arg = match arg {
+                            DiscoverProjectParam::Label(label) => JsonArguments::Label(label),
+                            DiscoverProjectParam::Path(path) => {
+                                let path =
+                                    path.to_file_path().expect("unable to convert to PathBuf");
+                                let path = Utf8PathBuf::from_path_buf(path)
+                                    .expect("Unable to convert to Utf8PathBuf");
+                                JsonArguments::Path(path)
+                            }
+                        };
+
+                        let handle = discover.spawn(arg).unwrap();
                         self.discover_handle = Some(handle);
                     }
                 }
@@ -788,7 +807,8 @@ impl GlobalState {
                     if let Ok(crates) = &snap.analysis.crates_for(id) {
                         if crates.is_empty() {
                             if snap.config.discover_command().is_some() {
-                                sender.send(Task::DiscoverLinkedProjects(uri)).unwrap();
+                                let arg = DiscoverProjectParam::Path(uri);
+                                sender.send(Task::DiscoverLinkedProjects(arg)).unwrap();
                             }
                         } else {
                             tracing::debug!(?uri, "is indexed");
@@ -820,11 +840,11 @@ impl GlobalState {
 
     fn handle_discover_msg(&mut self, message: flycheck::DiscoverProjectMessage) {
         match message {
-            flycheck::DiscoverProjectMessage::Finished { project_json } => {
+            flycheck::DiscoverProjectMessage::Finished(output) => {
                 self.report_progress("Buck", Progress::End, None, None, None);
                 self.discover_workspace_queue.op_completed(());
                 let mut config = Config::clone(&*self.config);
-                config.add_linked_projects(project_json);
+                config.add_linked_projects(output.project);
                 self.update_configuration(config);
             }
             flycheck::DiscoverProjectMessage::Progress { message } => {
diff --git a/crates/rust-analyzer/src/op_queue.rs b/crates/rust-analyzer/src/op_queue.rs
@@ -3,6 +3,7 @@
 
 pub(crate) type Cause = String;
 
+#[derive(Debug)]
 pub(crate) struct OpQueue<Args = (), Output = ()> {
     op_requested: Option<(Cause, Args)>,
     op_in_progress: bool,
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
diff --git a/docs/user/generated_config.adoc b/docs/user/generated_config.adoc
diff --git a/editors/code/package.json b/editors/code/package.json

Original file line number	Diff line number	Diff line change
`@@ -2349,7 +2349,7 @@ mod single_or_array {`
`2349`	`2349`	`}`
`2350`	`2350`	`}`
`2351`	`2351`
`2352`		`-#[derive(Serialize, Deserialize, Debug, Clone)]`
	`2352`	`+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]`
`2353`	`2353`	`#[serde(untagged)]`
`2354`	`2354`	`enum ManifestOrProjectJson {`
`2355`	`2355`	`Manifest(Utf8PathBuf),`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ pub(crate) fn handle_workspace_reload(state: &mut GlobalState, _: ()) -> anyhow:`
`57`	`57`	`state.proc_macro_clients = Arc::from_iter([]);`
`58`	`58`	`state.build_deps_changed = false;`
`59`	`59`
`60`		`- state.fetch_workspaces_queue.request_op("reload workspace request".to_owned(), false);`
	`60`	`+ state.fetch_workspaces_queue.request_op("reload workspace request".to_owned(), (None, false));`
`61`	`61`	`Ok(())`
`62`	`62`	`}`
`63`	`63`