Add build_helper::command_ext which extends std::process::Command.

Author: michaelwoerister

src/bootstrap/builder.rs

@@ -17,10 +17,10 @@ use std::fs;
 use std::hash::Hash;
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
-use std::process::Command;
 use std::time::{Instant, Duration};
 use std::collections::HashMap;
 
+use build_helper::command_ext::Command;
 use compile;
 use install;
 use dist;

src/bootstrap/cc_detect.rs

@@ -34,9 +34,9 @@
 use std::collections::HashSet;
 use std::{env, iter};
 use std::path::{Path, PathBuf};
-use std::process::Command;
 
 use build_helper::output;
+use build_helper::command_ext::Command;
 use cc;
 
 use Build;
@@ -158,7 +158,9 @@ fn set_compiler(cfg: &mut cc::Build,
                 return
             }
 
-            let output = output(c.to_command().arg("--version"));
+
+            let output = output(Command::from_std_command(c.to_command())
+                                .arg("--version"));
             let i = match output.find(" 4.") {
                 Some(i) => i,
                 None => return,

src/bootstrap/channel.rs

@@ -16,9 +16,9 @@
 //! print out as part of its version information.
 
 use std::path::Path;
-use std::process::Command;
 
 use build_helper::output;
+use build_helper::command_ext::Command;
 
 use Build;
 use config::Config;

src/bootstrap/compile.rs

@@ -22,11 +22,12 @@ use std::fs::{self, File};
 use std::io::BufReader;
 use std::io::prelude::*;
 use std::path::{Path, PathBuf};
-use std::process::{Command, Stdio};
+use std::process::Stdio;
 use std::str;
 use std::cmp::min;
 
 use build_helper::{output, mtime, up_to_date};
+use build_helper::command_ext::Command;
 use filetime::FileTime;
 use serde_json;
 

src/bootstrap/dist.rs

@@ -22,9 +22,10 @@ use std::env;
 use std::fs::{self, File};
 use std::io::{Read, Write};
 use std::path::{PathBuf, Path};
-use std::process::{Command, Stdio};
+use std::process::Stdio;
 
 use build_helper::output;
+use build_helper::command_ext::Command;
 
 use {Compiler, Mode};
 use channel;

src/bootstrap/install.rs

@@ -16,11 +16,11 @@
 use std::env;
 use std::fs;
 use std::path::{Path, PathBuf, Component};
-use std::process::Command;
 
 use dist::{self, pkgname, sanitize_sh, tmpdir};
 
 use builder::{Builder, RunConfig, ShouldRun, Step};
+use build_helper::command_ext::Command;
 use cache::Interned;
 use config::Config;
 

src/bootstrap/lib.rs

@@ -145,11 +145,12 @@ use std::env;
 use std::fs::{self, OpenOptions, File};
 use std::io::{self, Seek, SeekFrom, Write, Read};
 use std::path::{PathBuf, Path};
-use std::process::{self, Command};
+use std::process;
 use std::slice;
 use std::str;
 
 use build_helper::{run_silent, run_suppressed, try_run_silent, try_run_suppressed, output, mtime};
+use build_helper::command_ext::Command;
 use filetime::FileTime;
 
 use util::{exe, libdir, OutputFolder, CiEnv};

src/bootstrap/metadata.rs

@@ -9,10 +9,10 @@
 // except according to those terms.
 
 use std::collections::HashMap;
-use std::process::Command;
 use std::path::PathBuf;
 
 use build_helper::output;
+use build_helper::command_ext::Command;
 use serde_json;
 
 use {Build, Crate};

src/bootstrap/native.rs

@@ -23,9 +23,9 @@ use std::ffi::OsString;
 use std::fs::{self, File};
 use std::io::{Read, Write};
 use std::path::{Path, PathBuf};
-use std::process::Command;
 
 use build_helper::output;
+use build_helper::command_ext::Command;
 use cmake;
 use cc;
 

src/bootstrap/sanity.rs

@@ -24,9 +24,9 @@ use std::ffi::{OsString, OsStr};
 use std::fs::{self, File};
 use std::io::Read;
 use std::path::PathBuf;
-use std::process::Command;
 
 use build_helper::output;
+use build_helper::command_ext::Command;
 
 use Build;
 

src/bootstrap/test.rs

@@ -19,10 +19,10 @@ use std::iter;
 use std::fmt;
 use std::fs::{self, File};
 use std::path::{PathBuf, Path};
-use std::process::Command;
 use std::io::Read;
 
 use build_helper::{self, output};
+use build_helper::command_ext::Command;
 
 use builder::{Kind, RunConfig, ShouldRun, Builder, Compiler, Step};
 use Crate as CargoCrate;

src/bootstrap/tool.rs

@@ -12,11 +12,12 @@ use std::fs;
 use std::env;
 use std::iter;
 use std::path::PathBuf;
-use std::process::{Command, exit};
+use std::process::exit;
 
 use Mode;
 use Compiler;
 use builder::{Step, RunConfig, ShouldRun, Builder};
+use build_helper::command_ext::Command;
 use util::{exe, add_lib_path};
 use compile::{self, libtest_stamp, libstd_stamp, librustc_stamp};
 use native;

src/bootstrap/util.rs

@@ -18,11 +18,11 @@ use std::str;
 use std::fs;
 use std::io::{self, Write};
 use std::path::{Path, PathBuf};
-use std::process::Command;
 use std::time::{SystemTime, Instant};
 
 use config::Config;
 use builder::Builder;
+use build_helper::command_ext::Command;
 
 /// Returns the `name` as the filename of a static library for `target`.
 pub fn staticlib(name: &str, target: &str) -> String {

src/build_helper/command_ext.rs

@@ -0,0 +1,122 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::ffi::{OsStr, OsString};
+use std::io::Result;
+use std::process;
+use std::path::Path;
+
+// std::process::Command but with addition support for add arguments past
+// the `--` when invoking `cargo rustc`
+#[derive(Debug)]
+pub struct Command {
+    cmd: process::Command,
+    deferred_args: Vec<OsString>,
+}
+
+impl Command {
+
+    pub fn new<S: AsRef<OsStr>>(program: S) -> Command {
+        Command {
+            cmd: process::Command::new(program),
+            deferred_args: vec![],
+        }
+    }
+
+    pub fn from_std_command(cmd: process::Command) -> Command {
+        Command {
+            cmd,
+            deferred_args: vec![],
+        }
+    }
+
+    pub fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut Self {
+        self.cmd.arg(arg);
+        self
+    }
+
+    pub fn args<I, S>(&mut self, args: I) -> &mut Command
+    where
+        I: IntoIterator<Item = S>,
+        S: AsRef<OsStr>,
+    {
+        self.cmd.args(args);
+        self
+    }
+
+    pub fn deferred_arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut Self {
+        self.deferred_args.push(arg.as_ref().to_owned());
+        self
+    }
+
+    pub fn env<K, V>(&mut self, key: K, val: V) -> &mut Self
+    where
+        K: AsRef<OsStr>,
+        V: AsRef<OsStr>,
+    {
+        self.cmd.env(key, val);
+        self
+    }
+
+    pub fn envs<I, K, V>(&mut self, vars: I) -> &mut Command
+    where
+        I: IntoIterator<Item = (K, V)>,
+        K: AsRef<OsStr>,
+        V: AsRef<OsStr>,
+    {
+        self.cmd.envs(vars);
+        self
+    }
+
+    pub fn env_remove<K: AsRef<OsStr>>(&mut self, key: K) -> &mut Self {
+        self.cmd.env_remove(key);
+        self
+    }
+
+    pub fn env_clear(&mut self) -> &mut Command {
+        self.cmd.env_clear();
+        self
+    }
+
+    pub fn current_dir<P: AsRef<Path>>(&mut self, dir: P) -> &mut Command {
+        self.cmd.current_dir(dir);
+        self
+    }
+
+    pub fn stdin<T: Into<process::Stdio>>(&mut self, cfg: T) -> &mut Command {
+        self.cmd.stdin(cfg);
+        self
+    }
+
+    pub fn stdout<T: Into<process::Stdio>>(&mut self, cfg: T) -> &mut Command {
+        self.cmd.stdout(cfg);
+        self
+    }
+
+    pub fn stderr<T: Into<process::Stdio>>(&mut self, cfg: T) -> &mut Command {
+        self.cmd.stderr(cfg);
+        self
+    }
+
+    pub fn spawn(&mut self) -> Result<process::Child> {
+        self.cmd.args(self.deferred_args.clone().into_iter());
+        self.cmd.spawn()
+    }
+
+    pub fn output(&mut self) -> Result<process::Output> {
+        self.cmd.args(self.deferred_args.clone().into_iter());
+        self.cmd.output()
+    }
+
+    pub fn status(&mut self) -> Result<process::ExitStatus> {
+        self.cmd.args(self.deferred_args.clone().into_iter());
+        self.cmd.status()
+    }
+}

src/build_helper/lib.rs

@@ -10,10 +10,14 @@
 
 use std::fs::File;
 use std::path::{Path, PathBuf};
-use std::process::{Command, Stdio};
+use std::process::Stdio;
 use std::time::{SystemTime, UNIX_EPOCH};
 use std::{env, fs};
 
+pub mod command_ext;
+
+use command_ext::Command;
+
 /// A helper macro to `unwrap` a result except also print out details like:
 ///
 /// * The file/line of the panic

src/liballoc_jemalloc/build.rs

@@ -15,8 +15,8 @@ extern crate cc;
 
 use std::env;
 use std::path::PathBuf;
-use std::process::Command;
 use build_helper::{run, native_lib_boilerplate};
+use build_helper::command_ext::Command;
 
 fn main() {
     // FIXME: This is a hack to support building targets that don't

src/librustc_llvm/build.rs

@@ -11,11 +11,11 @@
 extern crate cc;
 extern crate build_helper;
 
-use std::process::Command;
 use std::env;
 use std::path::{PathBuf, Path};
 
 use build_helper::output;
+use build_helper::command_ext::Command;
 
 fn detect_llvm_link() -> (&'static str, &'static str) {
     // Force the link mode we want, preferring static by default, but

src/libstd/build.rs

@@ -13,8 +13,8 @@
 extern crate build_helper;
 
 use std::env;
-use std::process::Command;
 use build_helper::{run, native_lib_boilerplate};
+use build_helper::command_ext::Command;
 
 fn main() {
     let target = env::var("TARGET").expect("TARGET was not set");