Use response files when invoking rustc

This would workaround windows command line length
limits when using lots and lots of features.

rust-lang#7759

Author: MaulingMonkey

crates/cargo-test-support/src/lib.rs

@@ -115,13 +115,13 @@ use std::fs;
 use std::io::prelude::*;
 use std::os;
 use std::path::{Path, PathBuf};
-use std::process::{Command, Output};
+use std::process::{Output};
 use std::str;
 use std::time::{self, Duration};
 use std::usize;
 
 use cargo;
-use cargo::util::{is_ci, CargoResult, ProcessBuilder, ProcessError, Rustc};
+use cargo::util::{is_ci, CargoResult, CommandAndResponseFile, ProcessBuilder, ProcessError, Rustc};
 use filetime;
 use serde_json::{self, Value};
 use url::Url;
@@ -828,7 +828,7 @@ impl Execs {
         p.exec_with_output()
     }
 
-    pub fn build_command(&mut self) -> Command {
+    pub fn build_command(&mut self) -> CommandAndResponseFile {
         self.ran = true;
         // TODO avoid unwrap
         let p = (&self.process_builder).clone().unwrap();

src/cargo/core/compiler/mod.rs

@@ -548,6 +548,7 @@ fn rustdoc<'a, 'cfg>(cx: &mut Context<'a, 'cfg>, unit: &Unit<'a>) -> CargoResult
     let bcx = cx.bcx;
     let mut rustdoc = cx.compilation.rustdoc_process(unit.pkg, unit.target)?;
     rustdoc.inherit_jobserver(&cx.jobserver);
+    rustdoc.response_file();
     rustdoc.arg("--crate-name").arg(&unit.target.crate_name());
     add_path_args(bcx, unit, &mut rustdoc);
     add_cap_lints(bcx, unit, &mut rustdoc);
@@ -709,6 +710,7 @@ fn build_base_args<'a, 'cfg>(
     } = unit.profile;
     let test = unit.mode.is_any_test();
 
+    cmd.response_file();
     cmd.arg("--crate-name").arg(&unit.target.crate_name());
 
     let edition = unit.target.edition();

src/cargo/util/command_and_response_file.rs

@@ -0,0 +1,24 @@
+use std::ops::{Deref, DerefMut};
+use std::process::Command;
+
+use tempfile::TempPath;
+
+/// A wrapper around `Command` which extends the lifetime of associated
+/// temporary response files until the command is executed.
+pub struct CommandAndResponseFile {
+    pub command:        Command,
+    pub response_file:  Option<TempPath>,
+}
+
+impl Deref for CommandAndResponseFile {
+    type Target = Command;
+    fn deref(&self) -> &Self::Target {
+        &self.command
+    }
+}
+
+impl DerefMut for CommandAndResponseFile {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.command
+    }
+}

src/cargo/util/mod.rs

@@ -1,6 +1,7 @@
 use std::time::Duration;
 
 pub use self::canonical_url::CanonicalUrl;
+pub use self::command_and_response_file::CommandAndResponseFile;
 pub use self::config::{homedir, Config, ConfigValue};
 pub use self::dependency_queue::DependencyQueue;
 pub use self::diagnostic_server::RustfixDiagnosticServer;
@@ -29,6 +30,7 @@ pub use self::workspace::{
 };
 
 mod canonical_url;
+mod command_and_response_file;
 pub mod command_prelude;
 pub mod config;
 pub mod cpu;

src/cargo/util/process_builder.rs

@@ -2,14 +2,15 @@ use std::collections::HashMap;
 use std::env;
 use std::ffi::{OsStr, OsString};
 use std::fmt;
+use std::io::Write;
 use std::path::Path;
 use std::process::{Command, Output, Stdio};
 
 use failure::Fail;
 use jobserver::Client;
 use shell_escape::escape;
 
-use crate::util::{process_error, read2, CargoResult, CargoResultExt};
+use crate::util::{internal, process_error, read2, CargoResult, CargoResultExt, CommandAndResponseFile};
 
 /// A builder object for an external process, similar to `std::process::Command`.
 #[derive(Clone, Debug)]
@@ -29,6 +30,10 @@ pub struct ProcessBuilder {
     jobserver: Option<Client>,
     /// `true` to include environment variable in display.
     display_env_vars: bool,
+    /// `true` to use a [@response_file] to workaround command line length limits.
+    /// 
+    /// [@response_file]: https://doc.rust-lang.org/rustc/command-line-arguments.html#path-load-command-line-flags-from-a-path
+    response_file: bool,
 }
 
 impl fmt::Display for ProcessBuilder {
@@ -149,6 +154,14 @@ impl ProcessBuilder {
         self
     }
 
+    /// Enables the use of a [@response_file] to workaround command line length limits.
+    /// 
+    /// [@response_file]: https://doc.rust-lang.org/rustc/command-line-arguments.html#path-load-command-line-flags-from-a-path
+    pub fn response_file(&mut self) -> &mut Self {
+        self.response_file = true;
+        self
+    }
+
     /// Runs 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();
@@ -304,16 +317,22 @@ impl ProcessBuilder {
         Ok(output)
     }
 
-    /// Converts `ProcessBuilder` into a `std::process::Command`, and handles the jobserver, if
+    /// Converts `ProcessBuilder` into a `CommandAndResponseFile`, and handles the jobserver, if
     /// present.
-    pub fn build_command(&self) -> Command {
+    pub fn build_command(&self) -> CommandAndResponseFile {
         let mut command = Command::new(&self.program);
         if let Some(cwd) = self.get_cwd() {
             command.current_dir(cwd);
         }
-        for arg in &self.args {
-            command.arg(arg);
-        }
+        let response_file = if let Ok(Some(file)) = self.build_response_file() {
+            command.arg(file.to_path_buf());
+            Some(file)
+        } else {
+            for arg in &self.args {
+                command.arg(arg);
+            }
+            None
+        };
         for (k, v) in &self.env {
             match *v {
                 Some(ref v) => {
@@ -327,7 +346,19 @@ impl ProcessBuilder {
         if let Some(ref c) = self.jobserver {
             c.configure(&mut command);
         }
-        command
+        CommandAndResponseFile { command, response_file }
+    }
+
+    fn build_response_file(&self) -> CargoResult<Option<tempfile::TempPath>> {
+        if !self.response_file || self.args.len() == 0 {
+            return Ok(None);
+        }
+        let mut file = tempfile::NamedTempFile::new()?;
+        for arg in &self.args {
+            let arg = arg.to_str().ok_or_else(|| internal(format!("argument {:?} contains invalid unicode", arg)))?;
+            writeln!(file, "{}", arg)?;
+        }
+        Ok(Some(file.into_temp_path()))
     }
 }
 
@@ -340,6 +371,7 @@ pub fn process<T: AsRef<OsStr>>(cmd: T) -> ProcessBuilder {
         env: HashMap::new(),
         jobserver: None,
         display_env_vars: false,
+        response_file: false,
     }
 }