rust-project check TARGET

integrations/rust-project/src/buck.rs

@@ -50,6 +50,7 @@ pub(crate) fn to_json_project(
     aliases: FxHashMap<Target, AliasedTargetInfo>,
     relative_paths: bool,
     check_cycles: bool,
+    use_clippy: bool,
 ) -> Result<JsonProject, anyhow::Error> {
     let mode = select_mode(None);
     let buck = Buck::new(mode);
@@ -94,7 +95,7 @@ pub(crate) fn to_json_project(
 
     let mut crates: Vec<Crate> = Vec::with_capacity(targets_vec.len());
     for target in &targets_vec {
-        let info = target_index.get(&target).unwrap();
+        let info = target_index.get(target).unwrap();
 
         let dep_targets = resolve_aliases(&info.deps, &aliases, &proc_macros);
         let deps = as_deps(&dep_targets, info, &targets_to_ids, &target_index);
@@ -194,10 +195,35 @@ pub(crate) fn to_json_project(
         check_cycles_in_crate_graph(&crates);
     }
 
-    let jp = JsonProject {
-        sysroot,
-        crates,
-        runnables: vec![
+    let mut runnables = vec![
+        Runnable {
+            kind: RunnableKind::Flycheck,
+            program: "rust-project".to_owned(),
+            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(),
+                "-c=client.id=rust-project".to_owned(),
+                "{label}".to_string(),
+            ],
+            cwd: project_root.clone(),
+        },
+    ];
+
+    #[cfg(fbcode_build)]
+    {
+        runnables.extend([
             Runnable {
                 program: "buck".to_owned(),
                 args: vec![
@@ -219,9 +245,48 @@ pub(crate) fn to_json_project(
                     "--print-passing-details".to_owned(),
                 ],
                 cwd: project_root.to_owned(),
+            },
+        ]);
+    }
+
+    // OSS `buck2 test` supports different args, chiefly --test-arg
+    //
+    #[cfg(not(fbcode_build))]
+    {
+        runnables.extend([
+            #[cfg(not(fbcode_build))]
+            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 = JsonProject {
+        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"),
@@ -485,6 +550,24 @@ impl Buck {
         cmd
     }
 
+    /// Return the absolute path of the CELL root for a given buck target label
+    pub(crate) fn resolve_target_cell_root(&self, label: &str) -> Result<PathBuf, anyhow::Error> {
+        let (cell, _path) = label
+            .split_once("//")
+            .unwrap_or(("root", label.trim_start_matches("//")));
+
+        let mut command = self.command_without_config(["audit", "cell", "--paths-only", cell]);
+
+        let mut stdout = utf8_output(command.output(), &command)?;
+        truncate_line_ending(&mut stdout);
+
+        if enabled!(Level::TRACE) {
+            trace!(%stdout, target=%label, cell=%cell, "got cell root from buck");
+        }
+
+        Ok(stdout.into())
+    }
+
     /// Return the absolute path of the current Buck project root.
     pub(crate) fn resolve_project_root(&self) -> Result<PathBuf, anyhow::Error> {
         let mut command = self.command_without_config(["root"]);
@@ -558,17 +641,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.
@@ -578,17 +654,40 @@ impl Buck {
             command.current_dir(parent_dir);
         }
 
+        tracing::debug!(?command, "running bxl");
+
         let output = command.output();
-        if let Ok(output) = &output {
-            if output.stdout.is_empty() {
-                return Ok(vec![]);
-            }
-        }
 
         let files = deserialize_output(output, &command)?;
         Ok(files)
     }
 
+    #[instrument(fields(use_clippy, target = %target))]
+    pub(crate) fn check_target(
+        &self,
+        use_clippy: bool,
+        target: &str,
+    ) -> Result<Vec<PathBuf>, 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)?;
+        Ok(files)
+    }
     #[instrument(skip_all)]
     pub(crate) fn expand_and_resolve(
         &self,
@@ -611,6 +710,9 @@ impl Buck {
             "--targets",
         ]);
         command.args(targets);
+
+        tracing::debug!(?command, "running bxl");
+
         deserialize_output(command.output(), &command)
     }
 

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

@@ -8,7 +8,6 @@
  */
 
 use std::path::Path;
-use std::path::PathBuf;
 use std::str::FromStr;
 
 use tracing::info;
@@ -17,34 +16,31 @@ use tracing::instrument;
 use crate::buck;
 use crate::buck::select_mode;
 use crate::diagnostics;
-use crate::path::canonicalize;
 
 pub(crate) struct Check {
     pub(crate) buck: buck::Buck,
     pub(crate) use_clippy: bool,
-    pub(crate) saved_file: PathBuf,
+    pub(crate) target: String,
 }
 
 impl Check {
-    pub(crate) fn new(mode: Option<String>, use_clippy: bool, saved_file: PathBuf) -> Self {
-        let saved_file = canonicalize(&saved_file).unwrap_or(saved_file);
-
+    pub(crate) fn new(mode: Option<String>, use_clippy: bool, target: String) -> Self {
         let mode = select_mode(mode.as_deref());
         let buck = buck::Buck::new(mode);
         Self {
             buck,
             use_clippy,
-            saved_file,
+            target,
         }
     }
 
-    #[instrument(name = "check", skip_all, fields(saved_file = %self.saved_file.display()))]
+    #[instrument(name = "check", skip_all, fields(target = %self.target))]
     pub(crate) fn run(&self) -> Result<(), anyhow::Error> {
         let start = std::time::Instant::now();
         let buck = &self.buck;
 
-        let cell_root = buck.resolve_root_of_file(&self.saved_file)?;
-        let diagnostic_files = buck.check_saved_file(self.use_clippy, &self.saved_file)?;
+        let cell_root = buck.resolve_target_cell_root(&self.target)?;
+        let diagnostic_files = buck.check_target(self.use_clippy, &self.target)?;
 
         let mut diagnostics = vec![];
         for path in diagnostic_files {