feature: move linked_projects discovery to the rust-analyzer server

Author: davidbarsky

Cargo.lock

@@ -24,6 +24,7 @@ process-wrap.workspace = true
 paths.workspace = true
 stdx.workspace = true
 toolchain.workspace = true
+project-model.workspace = true
 
 [lints]
 workspace = true

crates/flycheck/Cargo.toml

@@ -0,0 +1,99 @@
+//! A `cargo-metadata`-equivalent for non-Cargo build systems.
+use std::{io, process::Command};
+
+use crossbeam_channel::Sender;
+use paths::Utf8PathBuf;
+use project_model::ProjectJsonData;
+use serde::{Deserialize, Serialize};
+
+use crate::command::{CommandHandle, ParseFromLine};
+
+/// A command wrapper for getting a `rust-project.json`.
+///
+/// This is analogous to `cargo-metadata`, but for non-Cargo build systems.
+pub struct JsonWorkspace {
+    command: Vec<String>,
+    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, arg: JsonArguments) -> io::Result<JsonWorkspaceHandle> {
+        let command = &self.command[0];
+        let args = &self.command[1..];
+
+        let mut cmd = Command::new(command);
+        cmd.args(args);
+
+        let arg = serde_json::to_string(&arg)?;
+        cmd.arg(arg);
+
+        Ok(JsonWorkspaceHandle { _handle: CommandHandle::spawn(cmd, self.sender.clone())? })
+    }
+}
+
+/// A handle to a spawned [JsonWorkspace].
+#[derive(Debug)]
+pub struct JsonWorkspaceHandle {
+    _handle: CommandHandle<DiscoverProjectMessage>,
+}
+
+/// An enum containing either progress messages or the materialized rust-project.
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(tag = "type")]
+pub enum DiscoverProjectMessage {
+    Error { message: String, context: Option<String> },
+    Progress { message: String },
+    Finished(FinishedOutput),
+}
+
+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
+pub struct FinishedOutput {
+    pub project: ProjectJsonData,
+    pub buildfile: Utf8PathBuf,
+}
+
+impl ParseFromLine for DiscoverProjectMessage {
+    fn from_line(line: &str, _error: &mut String) -> Option<Self> {
+        let Ok(value) = serde_json::from_str::<serde_json::Value>(line) else {
+            return Some(DiscoverProjectMessage::Error { message: line.to_owned(), context: None });
+        };
+
+        if let Ok(project) = serde_json::from_value::<FinishedOutput>(value.clone()) {
+            return Some(DiscoverProjectMessage::Finished(project));
+        }
+
+        if let Some(message) = value.pointer("/fields/message") {
+            return Some(DiscoverProjectMessage::Progress {
+                message: message.as_str().unwrap().to_owned(),
+            });
+        }
+
+        if let Some(error) = value.pointer("/fields/error") {
+            if let Some(source) = value.pointer("/fields/source") {
+                return Some(DiscoverProjectMessage::Error {
+                    message: error.as_str().unwrap().to_owned(),
+                    context: Some(source.as_str().unwrap().to_owned()),
+                });
+            }
+        }
+
+        None
+    }
+
+    fn from_eof() -> Option<Self> {
+        None
+    }
+}

crates/flycheck/src/json_workspace.rs

@@ -22,9 +22,13 @@ pub use cargo_metadata::diagnostic::{
 use toolchain::Tool;
 
 mod command;
+mod json_workspace;
 mod test_runner;
 
 use command::{CommandHandle, ParseFromLine};
+pub use json_workspace::{
+    DiscoverProjectMessage, JsonArguments, JsonWorkspace, JsonWorkspaceHandle,
+};
 pub use test_runner::{CargoTestHandle, CargoTestMessage, TestState};
 
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
@@ -242,7 +246,7 @@ enum FlycheckStatus {
     Finished,
 }
 
-const SAVED_FILE_PLACEHOLDER: &str = "$saved_file";
+pub const SAVED_FILE_PLACEHOLDER: &str = "$saved_file";
 
 impl FlycheckActor {
     fn new(

crates/flycheck/src/lib.rs

@@ -17,7 +17,6 @@ use itertools::Itertools;
 use proc_macro_api::{MacroDylib, ProcMacroServer};
 use project_model::{CargoConfig, ManifestPath, PackageRoot, ProjectManifest, ProjectWorkspace};
 use span::Span;
-use tracing::instrument;
 use vfs::{file_set::FileSetConfig, loader::Handle, AbsPath, AbsPathBuf, VfsPath};
 
 pub struct LoadCargoConfig {
@@ -51,7 +50,6 @@ pub fn load_workspace_at(
     load_workspace(workspace, &cargo_config.extra_env, load_config)
 }
 
-#[instrument(skip_all)]
 pub fn load_workspace(
     ws: ProjectWorkspace,
     extra_env: &FxHashMap<String, String>,

crates/load-cargo/src/lib.rs

@@ -275,6 +275,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())
@@ -285,16 +294,17 @@ impl ProjectJson {
     }
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
 pub struct ProjectJsonData {
     sysroot: Option<Utf8PathBuf>,
     sysroot_src: Option<Utf8PathBuf>,
     crates: Vec<CrateData>,
     #[serde(default)]
     runnables: Vec<RunnableData>,
+    pub buildfile: Option<Utf8PathBuf>,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
 struct CrateData {
     display_name: Option<String>,
     root_module: Utf8PathBuf,
@@ -318,7 +328,7 @@ struct CrateData {
     build: Option<BuildData>,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
 #[serde(rename = "edition")]
 enum EditionData {
     #[serde(rename = "2015")]
@@ -331,7 +341,7 @@ enum EditionData {
     Edition2024,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
 pub struct BuildData {
     label: String,
     build_file: Utf8PathBuf,
@@ -418,7 +428,7 @@ pub(crate) struct Dep {
     pub(crate) name: CrateName,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
 struct CrateSource {
     include_dirs: Vec<Utf8PathBuf>,
     exclude_dirs: Vec<Utf8PathBuf>,

crates/project-model/src/project_json.rs

@@ -30,6 +30,7 @@ use crate::{
     utf8_stdout, CargoConfig, CargoWorkspace, InvocationStrategy, ManifestPath, Package,
     ProjectJson, ProjectManifest, Sysroot, TargetData, TargetKind, WorkspaceBuildScripts,
 };
+use tracing::{debug, error, info};
 
 pub type FileLoader<'a> = &'a mut dyn for<'b> FnMut(&'b AbsPath) -> Option<FileId>;
 
@@ -249,7 +250,7 @@ impl ProjectWorkspace {
                 };
 
                 let rustc =  rustc_dir.and_then(|rustc_dir| {
-                    tracing::info!(workspace = %cargo_toml, rustc_dir = %rustc_dir, "Using rustc source");
+                    info!(workspace = %cargo_toml, rustc_dir = %rustc_dir, "Using rustc source");
                     match CargoWorkspace::fetch_metadata(
                         &rustc_dir,
                         cargo_toml.parent(),
@@ -772,9 +773,9 @@ impl ProjectWorkspace {
         };
 
         if matches!(sysroot.mode(), SysrootMode::Stitched(_)) && crate_graph.patch_cfg_if() {
-            tracing::debug!("Patched std to depend on cfg-if")
+            debug!("Patched std to depend on cfg-if")
         } else {
-            tracing::debug!("Did not patch std to depend on cfg-if")
+            debug!("Did not patch std to depend on cfg-if")
         }
         (crate_graph, proc_macros)
     }
@@ -919,6 +920,11 @@ fn project_json_to_crate_graph(
                         CrateOrigin::Local { repo: None, name: None }
                     },
                 );
+                debug!(
+                    ?crate_graph_crate_id,
+                    crate = display_name.as_ref().map(|name| name.canonical_name()),
+                    "added root to crate graph"
+                );
                 if *is_proc_macro {
                     if let Some(path) = proc_macro_dylib_path.clone() {
                         let node = Ok((
@@ -933,6 +939,7 @@ fn project_json_to_crate_graph(
         )
         .collect();
 
+    debug!(map = ?idx_to_crate_id);
     for (from_idx, krate) in project.crates() {
         if let Some(&from) = idx_to_crate_id.get(&from_idx) {
             public_deps.add_to_crate_graph(crate_graph, from);
@@ -1158,7 +1165,7 @@ fn detached_file_to_crate_graph(
     let file_id = match load(detached_file) {
         Some(file_id) => file_id,
         None => {
-            tracing::error!("Failed to load detached file {:?}", detached_file);
+            error!("Failed to load detached file {:?}", detached_file);
             return (crate_graph, FxHashMap::default());
         }
     };
@@ -1355,7 +1362,7 @@ fn add_target_crate_root(
     crate_id
 }
 
-#[derive(Default)]
+#[derive(Default, Debug)]
 struct SysrootPublicDeps {
     deps: Vec<(CrateName, CrateId, bool)>,
 }

crates/project-model/src/workspace.rs

@@ -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"

crates/rust-analyzer/Cargo.toml

@@ -176,6 +176,7 @@ fn run_server() -> anyhow::Result<()> {
             return Err(e.into());
         }
     };
+
     tracing::info!("InitializeParams: {}", initialize_params);
     let lsp_types::InitializeParams {
         root_uri,
@@ -265,7 +266,10 @@ fn run_server() -> anyhow::Result<()> {
         return Err(e.into());
     }
 
-    if !config.has_linked_projects() && config.detached_files().is_empty() {
+    if config.discover_command().is_none()
+        && !config.has_linked_projects()
+        && config.detached_files().is_empty()
+    {
         config.rediscover_workspaces();
     }