rust-project: support check TARGET, OSS flycheck runnables

Port of facebook#767 by Cormac Relf:

- `rust-project check` now accepts a target label (detected by a `:`)
  in addition to a saved file path
- emits flycheck/run/test runnables for OSS rust-analyzer, doing
  flychecks via `rust-project check {label}` (requires rust-analyzer
  with `{label}` interpolation support, rust-lang/rust-analyzer#18043)
- adds `--use-clippy` to `develop`/`develop-json`
- adds `--sysroot-src` and validates the sysroot contains the rust-src
  component, failing early otherwise
- gates the fbcode-only `buck test` runnable behind #[cfg(fbcode_build)]

Adapted for this fork: kept CLIENT_METADATA_RUST_PROJECT unconditional
(used by every buck command here), threaded use_clippy through the
global/first-party extra-cfgs signatures, taught file_from_command about
target labels, ungated the TargetOrFile import in scuba.rs, and added
the license header to the new target_or_file.rs.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LnkZs4NrYWyHv6nREsWeeH
Signed-off-by: Austin Seipp <aseipp@pobox.com>

Author: 2 people

integrations/rust-project/src/buck.rs

@@ -89,6 +89,7 @@ pub(crate) fn to_project_json(
     aliases: FxHashMap<Target, AliasedTargetInfo>,
     check_cycles: bool,
     include_all_buildfiles: bool,
+    use_clippy: bool,
     global_extra_cfgs: &[String],
     first_party_extra_cfgs: &[String],
     buck: &Buck,
@@ -261,10 +262,11 @@ pub(crate) fn to_project_json(
         check_cycles_in_crate_graph(&crates);
     }
 
-    let jp = ProjectJson {
-        sysroot: Box::new(sysroot),
-        crates,
-        runnables: vec![Runnable {
+    let mut runnables = vec![];
+
+    #[cfg(fbcode_build)]
+    {
+        runnables.extend([Runnable {
             program: "buck".to_owned(),
             args: vec![
                 "test".to_owned(),
@@ -276,7 +278,66 @@ pub(crate) fn to_project_json(
             ],
             cwd: project_root.to_owned(),
             kind: RunnableKind::TestOne,
-        }],
+        }]);
+    }
+
+    // OSS `buck2 test` supports different args, chiefly --test-arg
+    //
+    #[cfg(not(fbcode_build))]
+    {
+        let rust_project_executable = std::env::args().next().unwrap();
+        runnables.extend([
+            Runnable {
+                kind: RunnableKind::Flycheck,
+                program: rust_project_executable,
+                args: {
+                    let mut args = vec!["check".to_owned(), "{label}".to_owned()];
+                    if !use_clippy {
+                        args.push("--use-clippy".to_owned());
+                        args.push("false".to_owned());
+                    }
+                    args
+                },
+                cwd: project_root.clone(),
+            },
+            Runnable {
+                kind: RunnableKind::Run,
+                program: "buck2".to_string(),
+                args: vec!["run".to_owned(), "{label}".to_string()],
+                cwd: project_root.clone(),
+            },
+            Runnable {
+                kind: RunnableKind::TestOne,
+                program: "buck2".to_string(),
+                args: vec![
+                    "test".to_owned(),
+                    "-c=client.id=rust-project".to_owned(),
+                    "{label}".to_owned(),
+                    "--".to_owned(),
+                    // R-A substitutes {test_id} with e.g. `mycrate::tests::one`
+                    // --test-arg tells `buck2 test` to pass that string through to
+                    // the test program, which we will assume to be the rust test
+                    // harness. Same overall effect as `cargo test -- mycrate::tests::one`,
+                    //
+                    // But this is a bit less than ideal, because buck will build
+                    // all of the related test binaries, including integration tests.
+                    // We don't know your naming conventions for library tests.
+                    // You might have a rust_test target named `mycrate-test`. So
+                    // we might need a way (probably buck metadata in the library
+                    // target, or just querying the related tests)
+                    // to tell rust-project about these.
+                    "--test-arg".to_owned(),
+                    "{test_id}".to_owned(),
+                ],
+                cwd: project_root.clone(),
+            },
+        ]);
+    }
+
+    let jp = ProjectJson {
+        sysroot: Box::new(sysroot),
+        crates,
+        runnables,
         // needed to ignore the generated `rust-project.json` in diffs, but including the actual
         // string will mark this file as generated
         generated: String::from("\x40generated"),
@@ -622,17 +683,10 @@ impl Buck {
 
         command.arg("prelude//rust/rust-analyzer/check.bxl:check");
 
-        let mut file_path = saved_file.to_owned();
-        if !file_path.is_absolute() {
-            if let Ok(cwd) = std::env::current_dir() {
-                file_path = cwd.join(saved_file);
-            }
-        }
-
         // apply BXL scripts-specific arguments:
-        command.args(["--", "--file"]);
-        command.arg(file_path.as_os_str());
-
+        command.arg("--");
+        command.args(["--file"]);
+        command.arg(saved_file.as_os_str());
         command.args(["--use-clippy", &use_clippy.to_string()]);
 
         // Set working directory to the containing directory of the target file.
@@ -642,6 +696,35 @@ impl Buck {
             command.current_dir(parent_dir);
         }
 
+        tracing::debug!(?command, "running bxl");
+
+        let output = command.output();
+
+        let files = deserialize_output(output, &command)?;
+        Ok(files)
+    }
+
+    #[instrument(fields(use_clippy, target = %target))]
+    pub(crate) fn check_target(
+        &self,
+        use_clippy: bool,
+        target: &Target,
+    ) -> Result<CheckOutput, anyhow::Error> {
+        let mut command = self.command(["bxl"]);
+
+        if let Some(mode) = &self.mode {
+            command.arg(mode);
+        }
+
+        command.arg("prelude//rust/rust-analyzer/check.bxl:check");
+
+        command.arg("--");
+        command.arg("--target");
+        command.arg(target);
+        command.args(["--use-clippy", &use_clippy.to_string()]);
+
+        tracing::debug!(?command, "running bxl");
+
         let output = command.output();
 
         let files = deserialize_output(output, &command)?;
@@ -671,6 +754,8 @@ impl Buck {
         ]);
         command.args(targets);
 
+        tracing::debug!(?command, "running bxl");
+
         let mut res: ExpandedAndResolved = deserialize_file_output(command.output(), &command)?;
 
         res.expanded_targets = res

integrations/rust-project/src/cli.rs

@@ -11,6 +11,7 @@
 mod check;
 mod develop;
 mod new;
+mod target_or_file;
 
 #[derive(Debug, Clone)]
 pub(crate) enum Input {
@@ -26,5 +27,6 @@ pub(crate) use develop::Develop;
 pub(crate) use develop::develop_with_sysroot;
 pub(crate) use new::New;
 pub(crate) use new::ProjectKind;
+pub(crate) use target_or_file::TargetOrFile;
 
 use crate::target::Target;

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

@@ -9,39 +9,42 @@
  */
 
 use std::path::Path;
-use std::path::PathBuf;
 use std::str::FromStr;
 
 use anyhow::Context as _;
 use rustc_hash::FxHashSet;
 
 use crate::buck;
 use crate::buck::Buck;
+use crate::cli::TargetOrFile;
 use crate::diagnostics;
-use crate::path::safe_canonicalize;
 
 pub(crate) struct Check {
     pub(crate) buck: buck::Buck,
     pub(crate) use_clippy: bool,
-    pub(crate) saved_file: PathBuf,
+    pub(crate) target_or_saved_file: TargetOrFile,
 }
 
 impl Check {
-    pub(crate) fn new(buck: Buck, use_clippy: bool, saved_file: PathBuf) -> Self {
-        let saved_file = safe_canonicalize(&saved_file);
+    pub(crate) fn new(buck: Buck, use_clippy: bool, target_or_saved_file: TargetOrFile) -> Self {
+        let target_or_saved_file = target_or_saved_file.canonicalize();
 
         Self {
             buck,
             use_clippy,
-            saved_file,
+            target_or_saved_file,
         }
     }
 
+    #[tracing::instrument(name = "check", skip_all, fields(target = %self.target_or_saved_file))]
     pub(crate) fn run(&self) -> Result<(), anyhow::Error> {
         let start = std::time::Instant::now();
         let buck = &self.buck;
 
-        let check_output = buck.check_saved_file(self.use_clippy, &self.saved_file)?;
+        let check_output = match &self.target_or_saved_file {
+            TargetOrFile::Target(target) => buck.check_target(self.use_clippy, target)?,
+            TargetOrFile::File(saved_file) => buck.check_saved_file(self.use_clippy, saved_file)?,
+        };
 
         let contents: Vec<String> = check_output
             .diagnostic_paths
@@ -60,7 +63,7 @@ impl Check {
             println!("{out}");
         }
 
-        crate::scuba::log_check(start.elapsed(), &self.saved_file, self.use_clippy);
+        crate::scuba::log_check(start.elapsed(), &self.target_or_saved_file, self.use_clippy);
 
         Ok(())
     }