feature: move linked_projects discovery to the rust-analyzer server

Author: davidbarsky

Cargo.lock

@@ -24,6 +24,7 @@ command-group.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,76 @@
+//! A `cargo-metadata`-equivalent for non-Cargo build systems.
+use std::{io, process::Command};
+
+use crossbeam_channel::Sender;
+use paths::AbsPathBuf;
+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>,
+}
+
+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> {
+        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);
+
+        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 {
+    Progress { message: String },
+    Finished { project_json: Vec<ProjectJsonData> },
+}
+
+impl ParseFromLine for DiscoverProjectMessage {
+    fn from_line(line: &str, _error: &mut String) -> Option<Self> {
+        let value = serde_json::from_str::<serde_json::Value>(&line).unwrap();
+
+        // let mut deserializer = serde_json::Deserializer::from_str(line);
+        // deserializer.disable_recursion_limit();
+
+        if let Ok(project) = serde_json::from_value::<ProjectJsonData>(value.clone()) {
+            return Some(DiscoverProjectMessage::Finished { project_json: vec![project] });
+        }
+
+        if let Some(message) = value.pointer("/fields/message") {
+            return Some(DiscoverProjectMessage::Progress {
+                message: message.as_str().unwrap().to_owned(),
+            });
+        }
+
+        None
+    }
+
+    fn from_eof() -> Option<Self> {
+        None
+    }
+}

crates/flycheck/src/json_workspace.rs

@@ -22,9 +22,11 @@ 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, JsonWorkspace, JsonWorkspaceHandle};
 pub use test_runner::{CargoTestHandle, CargoTestMessage, TestState};
 
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
@@ -227,7 +229,7 @@ enum Event {
     CheckEvent(Option<CargoCheckMessage>),
 }
 
-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,7 @@ use itertools::Itertools;
 use proc_macro_api::{MacroDylib, ProcMacroServer};
 use project_model::{CargoConfig, PackageRoot, ProjectManifest, ProjectWorkspace};
 use span::Span;
-use tracing::{instrument, Level};
+use tracing::Level;
 use vfs::{file_set::FileSetConfig, loader::Handle, AbsPath, AbsPathBuf, VfsPath};
 
 pub struct LoadCargoConfig {
@@ -51,7 +51,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

@@ -14,6 +14,7 @@ doctest = false
 [dependencies]
 anyhow.workspace = true
 cargo_metadata.workspace = true
+crossbeam-channel.workspace = true
 rustc-hash.workspace = true
 semver.workspace = true
 serde_json.workspace = true

crates/project-model/Cargo.toml

@@ -175,7 +175,7 @@ impl ProjectJson {
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct ProjectJsonData {
-    sysroot: Option<Utf8PathBuf>,
+    pub sysroot: Option<Utf8PathBuf>,
     sysroot_src: Option<Utf8PathBuf>,
     crates: Vec<CrateData>,
 }

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::{info, Level, error, debug};
 
 pub type FileLoader<'a> = &'a mut dyn for<'b> FnMut(&'b AbsPath) -> Option<FileId>;
 
@@ -240,7 +241,7 @@ impl ProjectWorkspace {
                 let sysroot_ref = sysroot.as_ref().ok();
 
                 if let Ok(sysroot) = &sysroot {
-                    tracing::info!(workspace = %cargo_toml, src_root = ?sysroot.src_root(), root = %sysroot.root(), "Using sysroot");
+                    info!(workspace = %cargo_toml, src_root = ?sysroot.src_root(), root = %sysroot.root(), "Using sysroot");
                 }
 
                 let rustc_dir = match &config.rustc_source {
@@ -255,7 +256,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(),
@@ -356,6 +357,7 @@ impl ProjectWorkspace {
     ) -> ProjectWorkspace {
         let sysroot = match (project_json.sysroot.clone(), project_json.sysroot_src.clone()) {
             (Some(sysroot), Some(sysroot_src)) => {
+
                 Ok(Sysroot::load(sysroot, Some(Ok(sysroot_src)), false))
             }
             (Some(sysroot), None) => {
@@ -755,7 +757,7 @@ impl ProjectWorkspace {
         load: FileLoader<'_>,
         extra_env: &FxHashMap<String, String>,
     ) -> (CrateGraph, ProcMacroPaths) {
-        let _p = tracing::span!(tracing::Level::INFO, "ProjectWorkspace::to_crate_graph").entered();
+        let _p = tracing::span!(tracing::Level::INFO, "to_crate_graph").entered();
 
         let Self { kind, sysroot, cfg_overrides, rustc_cfg, .. } = self;
         let ((mut crate_graph, proc_macros), sysroot) = match kind {
@@ -814,9 +816,9 @@ impl ProjectWorkspace {
         if matches!(sysroot.as_ref().map(|it| it.mode()), Ok(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)
     }
@@ -962,6 +964,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((
@@ -976,6 +983,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) {
             if let Some((public_deps, libproc_macro)) = &sysroot_deps {
@@ -1004,7 +1012,7 @@ fn cargo_to_crate_graph(
     override_cfg: &CfgOverrides,
     build_scripts: &WorkspaceBuildScripts,
 ) -> (CrateGraph, ProcMacroPaths) {
-    let _p = tracing::span!(tracing::Level::INFO, "cargo_to_crate_graph").entered();
+    let _p = tracing::span!(Level::INFO, "cargo_to_crate_graph").entered();
     let mut res = (CrateGraph::default(), ProcMacroPaths::default());
     let crate_graph = &mut res.0;
     let proc_macros = &mut res.1;
@@ -1191,7 +1199,7 @@ fn detached_file_to_crate_graph(
     sysroot: Option<&Sysroot>,
     override_cfg: &CfgOverrides,
 ) -> (CrateGraph, ProcMacroPaths) {
-    let _p = tracing::span!(tracing::Level::INFO, "detached_file_to_crate_graph").entered();
+    let _p = tracing::span!(Level::INFO, "detached_file_to_crate_graph").entered();
     let mut crate_graph = CrateGraph::default();
     let (public_deps, _libproc_macro) = match sysroot {
         Some(sysroot) => sysroot_to_crate_graph(&mut crate_graph, sysroot, rustc_cfg.clone(), load),
@@ -1207,7 +1215,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());
         }
     };
@@ -1404,7 +1412,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

@@ -172,6 +172,7 @@ fn run_server() -> anyhow::Result<()> {
             return Err(e.into());
         }
     };
+
     tracing::info!("InitializeParams: {}", initialize_params);
     let lsp_types::InitializeParams {
         root_uri,
@@ -221,6 +222,7 @@ fn run_server() -> anyhow::Result<()> {
         .unwrap_or_else(|| vec![root_path.clone()]);
     let mut config =
         Config::new(root_path, capabilities, workspace_roots, visual_studio_code_version);
+
     if let Some(json) = initialization_options {
         if let Err(e) = config.update(json) {
             use lsp_types::{
@@ -255,8 +257,10 @@ fn run_server() -> anyhow::Result<()> {
         return Err(e.into());
     }
 
-    if !config.has_linked_projects() && config.detached_files().is_empty() {
-        config.rediscover_workspaces();
+    if config.discover_command().is_none() {
+        if !config.has_linked_projects() && config.detached_files().is_empty() {
+            config.rediscover_workspaces();
+        }
     }
 
     // If the io_threads have an error, there's usually an error on the main