rust-project: Include buckified sysroot in project

Summary:
rust-analyzer wants to drop support for their "stitched sysroot" (where it will assume the structure of the sysroot) in favor of relying on the build tool to tell it the sysroot layout. Since we have a buckified sysroot, that can be buck, and we can include a nested JsonProject for the sysroot.

Corresponding rust-analyzer change: rust-lang/rust-analyzer#19096

Reviewed By: davidbarsky

Differential Revision: D69328620

fbshipit-source-id: ee0b461b2e144bfefd30970d6f6ce35ae89e8ee1

Author: darichey

integrations/rust-project/src/buck.rs

@@ -187,7 +187,7 @@ pub(crate) fn to_json_project(
     }
 
     let jp = JsonProject {
-        sysroot,
+        sysroot: Box::new(sysroot),
         crates,
         runnables: vec![
             Runnable {
@@ -504,10 +504,7 @@ impl Buck {
             sysroot_src_path: PathBuf,
         }
         let cfg: BuckConfig = deserialize_output(child.wait_with_output(), &command)?;
-        // the `library` path component needs to be appended to the `sysroot_src_path`
-        // so that rust-analyzer will be able to find standard library sources.
-        let cfg = cfg.sysroot_src_path.join("library");
-        Ok(cfg)
+        Ok(cfg.sysroot_src_path)
     }
 
     /// Determines the owning target(s) of the saved file and builds them.

integrations/rust-project/src/cli.rs

@@ -21,6 +21,7 @@ pub(crate) enum Input {
 use std::path::PathBuf;
 
 pub(crate) use check::Check;
+pub(crate) use develop::develop_with_sysroot;
 pub(crate) use develop::Develop;
 pub(crate) use new::New;
 pub(crate) use new::ProjectKind;

integrations/rust-project/src/cli/develop.rs

@@ -21,6 +21,7 @@ use super::Input;
 use crate::buck;
 use crate::buck::select_mode;
 use crate::buck::to_json_project;
+use crate::buck::Buck;
 use crate::json_project::JsonProject;
 use crate::json_project::Sysroot;
 use crate::path::safe_canonicalize;
@@ -232,36 +233,31 @@ impl Develop {
             ..
         } = self;
 
-        let project_root = buck.resolve_project_root()?;
-
-        info!("building generated code");
-        let exclude_workspaces =
-            std::env::var("RUST_PROJECT_EXCLUDE_WORKSPACES").is_ok_and(|it| it != "0");
-        let expanded_and_resolved = buck.expand_and_resolve(&targets, exclude_workspaces)?;
-
-        info!("resolving aliased libraries");
-        let aliased_libraries =
-            buck.query_aliased_libraries(&expanded_and_resolved.expanded_targets)?;
-
         info!("fetching sysroot");
         let sysroot = match &sysroot {
             SysrootConfig::Sysroot(path) => Sysroot {
                 sysroot: safe_canonicalize(&expand_tilde(path)?),
                 sysroot_src: None,
+                sysroot_project: None,
             },
-            SysrootConfig::BuckConfig => resolve_buckconfig_sysroot(&buck, &project_root)?,
+            SysrootConfig::BuckConfig => {
+                let project_root = buck.resolve_project_root()?;
+                resolve_buckconfig_sysroot(&buck, &project_root)?
+            }
             SysrootConfig::Rustup => resolve_rustup_sysroot()?,
         };
-        info!("converting buck info to rust-project.json");
-        let rust_project = to_json_project(
+
+        let exclude_workspaces =
+            std::env::var("RUST_PROJECT_EXCLUDE_WORKSPACES").is_ok_and(|it| it != "0");
+
+        develop_with_sysroot(
+            buck,
+            targets,
             sysroot,
-            expanded_and_resolved,
-            aliased_libraries,
+            exclude_workspaces,
             *check_cycles,
             *include_all_buildfiles,
-        )?;
-
-        Ok(rust_project)
+        )
     }
 
     /// For every Rust file, return the relevant buck targets that should be used to configure rust-analyzer.
@@ -292,3 +288,30 @@ fn expand_tilde(path: &Path) -> Result<PathBuf, anyhow::Error> {
         Ok(path.to_path_buf())
     }
 }
+
+pub(crate) fn develop_with_sysroot(
+    buck: &Buck,
+    targets: Vec<Target>,
+    sysroot: Sysroot,
+    exclude_workspaces: bool,
+    check_cycles: bool,
+    include_all_buildfiles: bool,
+) -> Result<JsonProject, anyhow::Error> {
+    info!("building generated code");
+    let expanded_and_resolved = buck.expand_and_resolve(&targets, exclude_workspaces)?;
+
+    info!("resolving aliased libraries");
+    let aliased_libraries =
+        buck.query_aliased_libraries(&expanded_and_resolved.expanded_targets)?;
+
+    info!("converting buck info to rust-project.json");
+    let rust_project = to_json_project(
+        sysroot,
+        expanded_and_resolved,
+        aliased_libraries,
+        check_cycles,
+        include_all_buildfiles,
+    )?;
+
+    Ok(rust_project)
+}

integrations/rust-project/src/json_project.rs

@@ -27,7 +27,7 @@ use crate::target::Target;
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 pub(crate) struct JsonProject {
     #[serde(flatten)]
-    pub(crate) sysroot: Sysroot,
+    pub(crate) sysroot: Box<Sysroot>,
 
     /// The set of crates comprising the project.
     ///
@@ -216,7 +216,7 @@ pub(crate) struct Dep {
 
 /// Sysroot paths. These are documented in the rust-analyzer manual:
 ///
-/// <https://rust-analyzer.github.io/manual.html#non-cargo-based-projects>
+/// <https://rust-analyzer.github.io/book/non_cargo_based_projects.html>
 ///
 /// rust-analyzer treats both paths as optional, but we always provide sysroot.
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
@@ -241,4 +241,11 @@ pub(crate) struct Sysroot {
     /// are packaged seperately from binaries such as `rust-analyzer-proc-macro-srv`.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub(crate) sysroot_src: Option<PathBuf>,
+    /// A nested rust-project for the sysroot itself. If not provided, rust-analyzer
+    /// will attempt to compute the sysroot layout with Cargo.
+    ///
+    /// Inside Meta, we have a Buck-ified rust toolchain and we can provide the
+    /// sysroot layout directly with Buck.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub(crate) sysroot_project: Option<JsonProject>,
 }

integrations/rust-project/src/sysroot.rs

@@ -18,7 +18,9 @@ use tracing::instrument;
 use crate::buck::truncate_line_ending;
 use crate::buck::utf8_output;
 use crate::buck::Buck;
+use crate::cli::develop_with_sysroot;
 use crate::json_project::Sysroot;
+use crate::target::Target;
 
 #[derive(Debug)]
 pub(crate) enum SysrootConfig {
@@ -40,7 +42,6 @@ pub(crate) fn resolve_buckconfig_sysroot(
     buck: &Buck,
     project_root: &Path,
 ) -> Result<Sysroot, anyhow::Error> {
-    let sysroot_src = project_root.join(buck.resolve_sysroot_src()?);
     let sysroot: PathBuf = {
         // TODO(diliopoulos): remove hardcoded path to toolchain sysroot and replace with something
         // derived from buck, e.g.
@@ -66,9 +67,29 @@ pub(crate) fn resolve_buckconfig_sysroot(
         sysroot.into()
     };
 
+    let sysroot_src = buck.resolve_sysroot_src()?;
+    let sysroot_targets = Target::new(format!("fbsource//{}:", sysroot_src.to_string_lossy()));
+    // the `library` path component needs to be appended to the `sysroot_src_path`
+    // so that rust-analyzer will be able to find standard library sources.
+    let sysroot_src = project_root.join(sysroot_src).join("library");
+
+    let sysroot_project = develop_with_sysroot(
+        buck,
+        vec![sysroot_targets],
+        Sysroot {
+            sysroot: sysroot.clone(),
+            sysroot_src: Some(sysroot_src.clone()),
+            sysroot_project: None,
+        },
+        true,
+        false,
+        false,
+    )?;
+
     Ok(Sysroot {
         sysroot,
         sysroot_src: Some(sysroot_src),
+        sysroot_project: Some(sysroot_project),
     })
 }
 
@@ -93,6 +114,7 @@ pub(crate) fn resolve_rustup_sysroot() -> Result<Sysroot, anyhow::Error> {
     let sysroot = Sysroot {
         sysroot,
         sysroot_src: Some(sysroot_src),
+        sysroot_project: None, // rustup sysroot is not buckified
     };
     Ok(sysroot)
 }