Adopt CARGO_ENCODED_RUSTFLAGS

Author: Jon Gjengset

src/cargo/core/compiler/build_context/target_info.rs

@@ -548,6 +548,7 @@ fn output_err_info(cmd: &ProcessBuilder, stdout: &str, stderr: &str) -> String {
 ///
 /// The locations are:
 ///
+///  - the `CARGO_ENCODED_RUSTFLAGS` environment variable
 ///  - the `RUSTFLAGS` environment variable
 ///
 /// then if this was not found
@@ -595,7 +596,14 @@ fn env_args(
         return Ok(Vec::new());
     }
 
-    // First try RUSTFLAGS from the environment
+    // First try CARG_ENCODED_RUSTFLAGS from the environment.
+    // Prefer this over RUSTFLAGS since it's less prone to encoding errors.
+    if let Ok(a) = env::var(format!("CARGO_ENCODED_{}", name)) {
+        let args = a.split('\x1f').map(str::to_string);
+        return Ok(args.collect());
+    }
+
+    // Then try RUSTFLAGS from the environment
     if let Ok(a) = env::var(name) {
         let args = a
             .split(' ')

src/cargo/core/compiler/custom_build.rs

@@ -255,7 +255,11 @@ fn build_work(cx: &mut Context<'_, '_>, unit: &Unit) -> CargoResult<Job> {
     } else {
         cmd.env_remove("RUSTC_WRAPPER");
     }
-    cmd.env("RUSTFLAGS", bcx.rustflags_args(unit).join(" "));
+    cmd.env(
+        "CARGO_ENCODED_RUSTFLAGS",
+        bcx.rustflags_args(unit).join("\x1f"),
+    );
+    cmd.env_remove("RUSTFLAGS");
     let version = &bcx.rustc().version;
     cmd.env(
         "RUSTC_VERSION",

src/doc/src/reference/environment-variables.md

@@ -35,11 +35,17 @@ system:
 * `RUSTDOCFLAGS` — A space-separated list of custom flags to pass to all `rustdoc`
   invocations that Cargo performs. In contrast with [`cargo rustdoc`], this is
   useful for passing a flag to *all* `rustdoc` instances. See
-  [`build.rustdocflags`] for some more ways to set flags.
+  [`build.rustdocflags`] for some more ways to set flags. This string is
+  split by whitespace; for a more robust encoding of multiple arguments,
+  set `CARGO_ENCODED_RUSTDOCFLAGS` instead with arguments separated by
+  `0x1f` (ASCII Unit Separator).
 * `RUSTFLAGS` — A space-separated list of custom flags to pass to all compiler
   invocations that Cargo performs. In contrast with [`cargo rustc`], this is
   useful for passing a flag to *all* compiler instances. See
-  [`build.rustflags`] for some more ways to set flags.
+  [`build.rustflags`] for some more ways to set flags. This string is
+  split by whitespace; for a more robust encoding of multiple arguments,
+  set `CARGO_ENCODED_RUSTFLAGS` instead with arguments separated by
+  `0x1f` (ASCII Unit Separator).
 * `CARGO_INCREMENTAL` — If this is set to 1 then Cargo will force [incremental
   compilation] to be enabled for the current compilation, and when set to 0 it
   will force disabling it. If this env var isn't present then cargo's defaults
@@ -341,8 +347,10 @@ let out_dir = env::var("OUT_DIR").unwrap();
                    changed by editing `.cargo/config.toml`; see the documentation
                    about [cargo configuration][cargo-config] for more
                    information.
-* `RUSTFLAGS` — the `RUSTFLAGS` that Cargo invokes `rustc` with.
-                See [`build.rustflags`].
+* `CARGO_ENCODED_RUSTFLAGS` — extra flags that Cargo invokes `rustc`
+			      with, separated by a `0x1f` character
+			      (ASCII Unit Separator). See
+			      [`build.rustflags`].
 * `CARGO_PKG_<var>` - The package information variables, with the same names and values as are [provided during crate building][variables set for crates].
 * `RUSTC_VERSION` - The version of rustc used by the cargo that invokes
 		    the build script. Its constituent parts are also

tests/testsuite/build_script.rs

@@ -122,7 +122,8 @@ fn custom_build_env_vars() {
 
                 assert!(env::var("RUSTC_LINKER").is_err());
 
-                let rustflags = env::var("RUSTFLAGS").unwrap();
+                assert!(env::var("RUSTFLAGS").is_err());
+                let rustflags = env::var("CARGO_ENCODED_RUSTFLAGS").unwrap();
                 assert_eq!(rustflags, "");
 
                 let version = env::var("RUSTC_VERSION").unwrap();
@@ -173,11 +174,12 @@ fn custom_build_env_var_rustflags() {
 
                 fn main() {{
                     // Static assertion that exactly one of the cfg paths is always taken.
+                    assert!(env::var("RUSTFLAGS").is_err());
                     let x;
                     #[cfg(special)]
-                    {{ assert_eq!(env::var("RUSTFLAGS").unwrap(), "{}"); x = String::new(); }}
+                    {{ assert_eq!(env::var("CARGO_ENCODED_RUSTFLAGS").unwrap(), "{}"); x = String::new(); }}
                     #[cfg(notspecial)]
-                    {{ assert_eq!(env::var("RUSTFLAGS").unwrap(), "{}"); x = String::new(); }}
+                    {{ assert_eq!(env::var("CARGO_ENCODED_RUSTFLAGS").unwrap(), "{}"); x = String::new(); }}
                     let _ = x;
                 }}
                 "#,
@@ -193,6 +195,32 @@ fn custom_build_env_var_rustflags() {
     p.cargo("check").env("RUSTFLAGS", rustflags_alt).run();
 }
 
+#[cargo_test]
+fn custom_build_env_var_rustflags_escape() {
+    let p = project()
+        .file(
+            ".cargo/config",
+            r#"
+            [build]
+            rustflags = ["-Clink-arg=-add_empty_section text foobar", "--cfg=foo"]
+            "#,
+        )
+        .file(
+            "build.rs",
+            r#"
+                use std::env;
+
+                fn main() {{
+                    assert_eq!(env::var("CARGO_ENCODED_RUSTFLAGS").unwrap(), "-Clink-arg=-add_empty_section text foobar\x1f--cfg=foo");
+                }}
+                "#,
+        )
+        .file("src/lib.rs", "")
+        .build();
+
+    p.cargo("check").run();
+}
+
 #[cargo_test]
 fn custom_build_env_var_rustc_wrapper() {
     let wrapper = tools::echo_wrapper();