1 files changed, 52 insertions, 71 deletions

diff --git a/crates/ra_flycheck/src/lib.rs b/crates/ra_flycheck/src/lib.rs
index 75aece45f..13494a731 100644
--- a/crates/ra_flycheck/src/lib.rs
+++ b/crates/ra_flycheck/src/lib.rs
@@ -4,9 +4,9 @@
 mod conv;
 
 use std::{
-    error, fmt,
-    io::{BufRead, BufReader},
-    path::{Path, PathBuf},
+    env,
+    io::{self, BufRead, BufReader},
+    path::PathBuf,
     process::{Command, Stdio},
     time::Instant,
 };
@@ -23,10 +23,9 @@ use crate::conv::{map_rust_diagnostic_to_lsp, MappedRustDiagnostic};
 pub use crate::conv::url_from_path_with_drive_lowercasing;
 
 #[derive(Clone, Debug)]
-pub struct CheckConfig {
-    pub args: Vec<String>,
-    pub command: String,
-    pub all_targets: bool,
+pub enum FlycheckConfig {
+    CargoCommand { command: String, all_targets: bool, extra_args: Vec<String> },
+    CustomCommand { command: String, args: Vec<String> },
 }
 
 /// Flycheck wraps the shared state and communication machinery used for
@@ -42,12 +41,11 @@ pub struct Flycheck {
 }
 
 impl Flycheck {
-    pub fn new(config: CheckConfig, workspace_root: PathBuf) -> Flycheck {
+    pub fn new(config: FlycheckConfig, workspace_root: PathBuf) -> Flycheck {
         let (task_send, task_recv) = unbounded::<CheckTask>();
         let (cmd_send, cmd_recv) = unbounded::<CheckCommand>();
         let handle = jod_thread::spawn(move || {
-            let mut check = FlycheckThread::new(config, workspace_root);
-            check.run(&task_send, &cmd_recv);
+            FlycheckThread::new(config, workspace_root).run(&task_send, &cmd_recv);
         });
         Flycheck { task_recv, cmd_send, handle }
     }
@@ -76,7 +74,7 @@ pub enum CheckCommand {
 }
 
 struct FlycheckThread {
-    options: CheckConfig,
+    config: FlycheckConfig,
     workspace_root: PathBuf,
     last_update_req: Option<Instant>,
     // XXX: drop order is significant
@@ -90,9 +88,9 @@ struct FlycheckThread {
 }
 
 impl FlycheckThread {
-    fn new(options: CheckConfig, workspace_root: PathBuf) -> FlycheckThread {
+    fn new(config: FlycheckConfig, workspace_root: PathBuf) -> FlycheckThread {
         FlycheckThread {
-            options,
+            config,
             workspace_root,
             last_update_req: None,
             message_recv: never(),
@@ -216,27 +214,34 @@ impl FlycheckThread {
         self.message_recv = never();
         self.check_process = None;
 
-        let mut args: Vec<String> = vec![
-            self.options.command.clone(),
-            "--workspace".to_string(),
-            "--message-format=json".to_string(),
-            "--manifest-path".to_string(),
-            format!("{}/Cargo.toml", self.workspace_root.display()),
-        ];
-        if self.options.all_targets {
-            args.push("--all-targets".to_string());
-        }
-        args.extend(self.options.args.iter().cloned());
+        let mut cmd = match &self.config {
+            FlycheckConfig::CargoCommand { command, all_targets, extra_args } => {
+                let mut cmd = Command::new(cargo_binary());
+                cmd.arg(command);
+                cmd.args(&["--workspace", "--message-format=json", "--manifest-path"]);
+                cmd.arg(self.workspace_root.join("Cargo.toml"));
+                if *all_targets {
+                    cmd.arg("--all-targets");
+                }
+                cmd.args(extra_args);
+                cmd
+            }
+            FlycheckConfig::CustomCommand { command, args } => {
+                let mut cmd = Command::new(command);
+                cmd.args(args);
+                cmd
+            }
+        };
+        cmd.current_dir(&self.workspace_root);
 
         let (message_send, message_recv) = unbounded();
-        let workspace_root = self.workspace_root.to_owned();
         self.message_recv = message_recv;
         self.check_process = Some(jod_thread::spawn(move || {
             // If we trigger an error here, we will do so in the loop instead,
             // which will break out of the loop, and continue the shutdown
             let _ = message_send.send(CheckEvent::Begin);
 
-            let res = run_cargo(&args, Some(&workspace_root), &mut |message| {
+            let res = run_cargo(cmd, &mut |message| {
                 // Skip certain kinds of messages to only spend time on what's useful
                 match &message {
                     Message::CompilerArtifact(artifact) if artifact.fresh => return true,
@@ -274,33 +279,12 @@ enum CheckEvent {
     End,
 }
 
-#[derive(Debug)]
-pub struct CargoError(String);
-
-impl fmt::Display for CargoError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Cargo failed: {}", self.0)
-    }
-}
-impl error::Error for CargoError {}
-
 fn run_cargo(
-    args: &[String],
-    current_dir: Option<&Path>,
+    mut command: Command,
     on_message: &mut dyn FnMut(cargo_metadata::Message) -> bool,
-) -> Result<(), CargoError> {
-    let mut command = Command::new("cargo");
-    if let Some(current_dir) = current_dir {
-        command.current_dir(current_dir);
-    }
-
-    let mut child = command
-        .args(args)
-        .stdout(Stdio::piped())
-        .stderr(Stdio::null())
-        .stdin(Stdio::null())
-        .spawn()
-        .expect("couldn't launch cargo");
+) -> io::Result<()> {
+    let mut child =
+        command.stdout(Stdio::piped()).stderr(Stdio::null()).stdin(Stdio::null()).spawn()?;
 
     // We manually read a line at a time, instead of using serde's
     // stream deserializers, because the deserializer cannot recover
@@ -314,13 +298,7 @@ fn run_cargo(
     let mut read_at_least_one_message = false;
 
     for line in stdout.lines() {
-        let line = match line {
-            Ok(line) => line,
-            Err(err) => {
-                log::error!("Couldn't read line from cargo: {}", err);
-                continue;
-            }
-        };
+        let line = line?;
 
         let message = serde_json::from_str::<cargo_metadata::Message>(&line);
         let message = match message {
@@ -341,19 +319,22 @@ fn run_cargo(
     // It is okay to ignore the result, as it only errors if the process is already dead
     let _ = child.kill();
 
-    let err_msg = match child.wait() {
-        Ok(exit_code) if !exit_code.success() && !read_at_least_one_message => {
-            // FIXME: Read the stderr to display the reason, see `read2()` reference in PR comment:
-            // https://github.com/rust-analyzer/rust-analyzer/pull/3632#discussion_r395605298
+    let exit_status = child.wait()?;
+    if !exit_status.success() && !read_at_least_one_message {
+        // FIXME: Read the stderr to display the reason, see `read2()` reference in PR comment:
+        // https://github.com/rust-analyzer/rust-analyzer/pull/3632#discussion_r395605298
+        return Err(io::Error::new(
+            io::ErrorKind::Other,
             format!(
-                "the command produced no valid metadata (exit code: {:?}): cargo {}",
-                exit_code,
-                args.join(" ")
-            )
-        }
-        Err(err) => format!("io error: {:?}", err),
-        Ok(_) => return Ok(()),
-    };
+                "the command produced no valid metadata (exit code: {:?}): {:?}",
+                exit_status, command
+            ),
+        ));
+    }
+
+    Ok(())
+}
 
-    Err(CargoError(err_msg))
+fn cargo_binary() -> String {
+    env::var("CARGO").unwrap_or_else(|_| "cargo".to_string())
 }