Stop printing rustc command line if non-verbose

We used to print a wall of text especially in larger projects like the
compiler, now we print a much smaller message. It's not generally useful
to know the full compiler command anyway.

Author: Mark-Simulacrum

src/cargo/util/config.rs

@@ -207,6 +207,7 @@ impl Config {
             } else {
                 None
             },
+            self.extra_verbose(),
         )
     }
 

src/cargo/util/process_builder.rs

@@ -3,12 +3,12 @@ use std::env;
 use std::ffi::{OsStr, OsString};
 use std::fmt;
 use std::path::Path;
-use std::process::{Command, Output, Stdio};
+use std::process::{Command, Output, Stdio, ExitStatus};
 
 use jobserver::Client;
 use shell_escape::escape;
 
-use util::{process_error, CargoResult, CargoResultExt, read2};
+use util::{process_error, ProcessError, CargoResult, CargoResultExt, read2};
 
 /// A builder object for an external process, similar to `std::process::Command`.
 #[derive(Clone, Debug)]
@@ -26,6 +26,10 @@ pub struct ProcessBuilder {
     ///
     /// [jobserver_docs]: https://docs.rs/jobserver/0.1.6/jobserver/
     jobserver: Option<Client>,
+    /// Should we give as much information as possible?
+    ///
+    /// Currently this controls whether to print out the command line on failure.
+    verbose_output: bool,
 }
 
 impl fmt::Display for ProcessBuilder {
@@ -88,6 +92,11 @@ impl ProcessBuilder {
         self
     }
 
+    pub fn verbose(&mut self, verbose: bool) -> &mut ProcessBuilder {
+        self.verbose_output = verbose;
+        self
+    }
+
     /// Get the executable name.
     pub fn get_program(&self) -> &OsString {
         &self.program
@@ -128,6 +137,19 @@ impl ProcessBuilder {
         self
     }
 
+    fn unsuccessful(&self, exit: &ExitStatus, output: Option<&Output>) -> ProcessError {
+        let msg = if self.verbose_output {
+            format!("proces didn't exit successfully: {:?}", self.program)
+        } else {
+            format!("process didn't exit successfully: {}", self)
+        };
+        process_error(
+            &msg,
+            Some(exit),
+            output,
+        )
+    }
+
     /// Run the process, waiting for completion, and mapping non-success exit codes to an error.
     pub fn exec(&self) -> CargoResult<()> {
         let mut command = self.build_command();
@@ -142,11 +164,7 @@ impl ProcessBuilder {
         if exit.success() {
             Ok(())
         } else {
-            Err(process_error(
-                &format!("process didn't exit successfully: {}", self),
-                Some(&exit),
-                None,
-            ).into())
+            Err(self.unsuccessful(&exit, None).into())
         }
     }
 
@@ -191,11 +209,7 @@ impl ProcessBuilder {
         if output.status.success() {
             Ok(output)
         } else {
-            Err(process_error(
-                &format!("process didn't exit successfully: {}", self),
-                Some(&output.status),
-                Some(&output),
-            ).into())
+            Err(self.unsuccessful(&output.status, Some(&output)).into())
         }
     }
 
@@ -269,11 +283,7 @@ impl ProcessBuilder {
         {
             let to_print = if print_output { Some(&output) } else { None };
             if !output.status.success() {
-                return Err(process_error(
-                    &format!("process didn't exit successfully: {}", self),
-                    Some(&output.status),
-                    to_print,
-                ).into());
+                return Err(self.unsuccessful(&output.status, to_print).into());
             } else if let Some(e) = callback_error {
                 let cx = process_error(
                     &format!("failed to parse process output: {}", self),
@@ -322,5 +332,6 @@ pub fn process<T: AsRef<OsStr>>(cmd: T) -> ProcessBuilder {
         cwd: None,
         env: HashMap::new(),
         jobserver: None,
+        verbose_output: false,
     }
 }

src/cargo/util/rustc.rs

@@ -23,6 +23,8 @@ pub struct Rustc {
     pub verbose_version: String,
     /// The host triple (arch-platform-OS), this comes from verbose_version.
     pub host: String,
+    /// Should termination print out command line.
+    pub verbose: bool,
     cache: Mutex<Cache>,
 }
 
@@ -37,6 +39,7 @@ impl Rustc {
         wrapper: Option<PathBuf>,
         rustup_rustc: &Path,
         cache_location: Option<PathBuf>,
+        verbose: bool,
     ) -> CargoResult<Rustc> {
         let _p = profile::start("Rustc::new");
 
@@ -60,21 +63,24 @@ impl Rustc {
             wrapper,
             verbose_version,
             host,
+            verbose,
             cache: Mutex::new(cache),
         })
     }
 
     /// Get a process builder set up to use the found rustc version, with a wrapper if Some
     pub fn process(&self) -> ProcessBuilder {
-        if let Some(ref wrapper) = self.wrapper {
+        let mut process = if let Some(ref wrapper) = self.wrapper {
             let mut cmd = util::process(wrapper);
             {
                 cmd.arg(&self.path);
             }
             cmd
         } else {
             util::process(&self.path)
-        }
+        };
+        process.verbose(self.verbose);
+        process
     }
 
     pub fn cached_output(&self, cmd: &ProcessBuilder) -> CargoResult<(String, String)> {

tests/testsuite/shell_quoting.rs

@@ -34,10 +34,6 @@ fn features_are_quoted() {
             .with_status(101)
             .with_stderr_contains(
                 r#"[RUNNING] `rustc [..] --cfg 'feature="default"' --cfg 'feature="some_feature"' [..]`"#
-            ).with_stderr_contains(
-                r#"
-Caused by:
-  process didn't exit successfully: [..] --cfg 'feature="default"' --cfg 'feature="some_feature"' [..]"#
             )
     );
 }

tests/testsuite/support/mod.rs

@@ -1307,6 +1307,7 @@ pub static RUSTC: Rustc = Rustc::new(
     None,
     Path::new("should be path to rustup rustc, but we don't care in tests"),
     None,
+    false,
 ).unwrap()
 );