Allow runner params

Author: RReverser

src/cargo/ops/cargo_rustc/compilation.rs

@@ -54,7 +54,7 @@ pub struct Compilation<'cfg> {
 
     config: &'cfg Config,
 
-    target_runner: LazyCell<Option<PathBuf>>,
+    target_runner: LazyCell<Option<(PathBuf, Vec<String>)>>,
 }
 
 impl<'cfg> Compilation<'cfg> {
@@ -94,18 +94,19 @@ impl<'cfg> Compilation<'cfg> {
         self.fill_env(process(cmd), pkg, true)
     }
 
-    fn target_runner(&self) -> CargoResult<&Option<PathBuf>> {
+    fn target_runner(&self) -> CargoResult<&Option<(PathBuf, Vec<String>)>> {
         self.target_runner.get_or_try_init(|| {
             let key = format!("target.{}.runner", self.target);
-            Ok(self.config.get_path(&key)?.map(|v| v.val))
+            Ok(self.config.get_path_and_args(&key)?.map(|v| v.val))
         })
     }
 
     /// See `process`.
     pub fn target_process<T: AsRef<OsStr>>(&self, cmd: T, pkg: &Package)
                                            -> CargoResult<ProcessBuilder> {
-        let builder = if let &Some(ref runner) = self.target_runner()? {
+        let builder = if let &Some((ref runner, ref args)) = self.target_runner()? {
             let mut builder = process(runner);
+            builder.args(args);
             builder.arg(cmd);
             builder
         } else {

src/cargo/util/config.rs

@@ -215,25 +215,40 @@ impl Config {
         }
     }
 
+    fn string_to_path(&self, value: String, definition: &Definition) -> PathBuf {
+        let is_path = value.contains('/') ||
+                      (cfg!(windows) && value.contains('\\'));
+        if is_path {
+            definition.root(self).join(value)
+        } else {
+            // A pathless name
+            PathBuf::from(value)
+        }
+    }
+
     pub fn get_path(&self, key: &str) -> CargoResult<Option<Value<PathBuf>>> {
         if let Some(val) = self.get_string(key)? {
-            let is_path = val.val.contains('/') ||
-                          (cfg!(windows) && val.val.contains('\\'));
-            let path = if is_path {
-                val.definition.root(self).join(val.val)
-            } else {
-                // A pathless name
-                PathBuf::from(val.val)
-            };
             Ok(Some(Value {
-                val: path,
-                definition: val.definition,
+                val: self.string_to_path(val.val, &val.definition),
+                definition: val.definition
             }))
         } else {
             Ok(None)
         }
     }
 
+    pub fn get_path_and_args(&self, key: &str) -> CargoResult<Option<Value<(PathBuf, Vec<String>)>>> {
+        if let Some(mut val) = self.get_list_or_split_string(key)? {
+            if !val.val.is_empty() {
+                return Ok(Some(Value {
+                    val: (self.string_to_path(val.val.remove(0), &val.definition), val.val),
+                    definition: val.definition
+                }));
+            }
+        }
+        Ok(None)
+    }
+
     pub fn get_list(&self, key: &str)
                     -> CargoResult<Option<Value<Vec<(String, PathBuf)>>>> {
         match self.get(key)? {

tests/tool-paths.rs

@@ -140,7 +140,7 @@ fn custom_runner() {
         .file("benches/bench.rs", "")
         .file(".cargo/config", &format!(r#"
             [target.{}]
-            runner = "nonexistent-runner"
+            runner = "nonexistent-runner -r"
         "#, target));
 
     foo.build();
@@ -149,15 +149,15 @@ fn custom_runner() {
                 execs().with_stderr_contains(&format!("\
 [COMPILING] foo v0.0.1 ({url})
 [FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
-[RUNNING] `nonexistent-runner target[/]debug[/]foo[EXE] --param`
+[RUNNING] `nonexistent-runner -r target[/]debug[/]foo[EXE] --param`
 ", url = foo.url())));
 
     assert_that(foo.cargo("test").args(&["--test", "test", "--verbose", "--", "--param"]),
                 execs().with_stderr_contains(&format!("\
 [COMPILING] foo v0.0.1 ({url})
 [RUNNING] `rustc [..]`
 [FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
-[RUNNING] `nonexistent-runner [..][/]target[/]debug[/]deps[/]test-[..][EXE] --param`
+[RUNNING] `nonexistent-runner -r [..][/]target[/]debug[/]deps[/]test-[..][EXE] --param`
 ", url = foo.url())));
 
     assert_that(foo.cargo("bench").args(&["--bench", "bench", "--verbose", "--", "--param"]),
@@ -166,6 +166,6 @@ fn custom_runner() {
 [RUNNING] `rustc [..]`
 [RUNNING] `rustc [..]`
 [FINISHED] release [optimized] target(s) in [..]
-[RUNNING] `nonexistent-runner [..][/]target[/]release[/]deps[/]bench-[..][EXE] --param --bench`
+[RUNNING] `nonexistent-runner -r [..][/]target[/]release[/]deps[/]bench-[..][EXE] --param --bench`
 ", url = foo.url())));
 }