Add support for [env] section in .cargo/config.toml

This adds support for an `[env]` section in the config.toml files. Environment variables set in this section will be applied to the environment of any processes executed by cargo.

```
[env]
FOOBAR = "Apple"
PATH_TO_SOME_TOOL = { value = "bin/tool", relative = true }
USERNAME = { value = "test_user", force = true }
```

Author: wickerwaka

src/cargo/core/compiler/compilation.rs

@@ -339,6 +339,15 @@ impl<'cfg> Compilation<'cfg> {
             )
             .env("CARGO_PKG_AUTHORS", &pkg.authors().join(":"))
             .cwd(pkg.root());
+        
+
+        // Apply any environment variables from the config
+        for (key, value) in self.config.env_config()?.iter() {
+            if value.is_force() || cmd.get_env(&key).is_none() {
+                cmd.env(&key, value.resolve(&self.config));
+            }
+        }
+
         Ok(cmd)
     }
 }

src/cargo/util/config/mod.rs

@@ -62,6 +62,8 @@ use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::sync::Once;
 use std::time::Instant;
+use std::borrow::Cow;
+use std::ffi::OsStr;
 
 use anyhow::{anyhow, bail, format_err};
 use curl::easy::Easy;
@@ -181,6 +183,7 @@ pub struct Config {
     target_cfgs: LazyCell<Vec<(String, TargetCfgConfig)>>,
     doc_extern_map: LazyCell<RustdocExternMap>,
     progress_config: ProgressConfig,
+    env_config: LazyCell<EnvConfig>,
 }
 
 impl Config {
@@ -264,6 +267,7 @@ impl Config {
             target_cfgs: LazyCell::new(),
             doc_extern_map: LazyCell::new(),
             progress_config: ProgressConfig::default(),
+            env_config: LazyCell::new(),
         }
     }
 
@@ -1244,6 +1248,41 @@ impl Config {
         &self.progress_config
     }
 
+    /// Create an EnvConfigValue hashmap from the "env" table
+    fn get_env_config(&self) -> CargoResult<EnvConfig> {
+        // We cannot use pure serde handling for this. The Value<_> type does not
+        // work when parsing the env table to a hashmap. So iterator through each
+        // entry in the "env" table, determine it's type and then use `get` method
+        // to deserialize it.
+        let env_table = &self.get_table(&ConfigKey::from_str("env"))?;
+        let mut vars = EnvConfig::new();
+
+        if env_table.is_none() {
+            return Ok(vars);
+        }
+
+        let env_table = &env_table.as_ref().unwrap().val;
+
+        for (key, value) in env_table.iter() {
+            let full_key = format!("env.{}", key);
+            let e = match value {
+                ConfigValue::Table(..) => self.get::<EnvConfigValue>(&full_key)?,
+                _ => {
+                    let v = self.get::<Value<String>>(&full_key)?;
+                    EnvConfigValue::from_value(v)
+                }
+            };
+            vars.insert(key.clone(), e);
+        }
+        Ok(vars)
+    }
+
+    pub fn env_config(&self) -> CargoResult<&EnvConfig> {
+        self.env_config.try_borrow_with(|| {
+            self.get_env_config()
+        })
+    }
+
     /// This is used to validate the `term` table has valid syntax.
     ///
     /// This is necessary because loading the term settings happens very
@@ -1953,6 +1992,40 @@ where
     deserializer.deserialize_option(ProgressVisitor)
 }
 
+#[derive(Debug, Deserialize)]
+pub struct EnvConfigValue {
+    value: Value<String>,
+    #[serde(default)]
+    force: bool,
+    #[serde(default)]
+    relative: bool,
+}
+
+impl EnvConfigValue {
+    fn from_value(value: Value<String>) -> EnvConfigValue {
+        EnvConfigValue {
+            value,
+            force: false,
+            relative: false
+        }
+    }
+
+    pub fn is_force(&self) -> bool {
+        self.force
+    }
+
+    pub fn resolve<'a>(&'a self, config: &Config) -> Cow<'a, OsStr> {
+        if self.relative {
+            let p = self.value.definition.root(config).join(&self.value.val);
+            Cow::Owned(p.into_os_string())
+        } else {
+            Cow::Borrowed(OsStr::new(&self.value.val))
+        }
+    }
+}
+
+pub type EnvConfig = HashMap<String, EnvConfigValue>;
+
 /// A type to deserialize a list of strings from a toml file.
 ///
 /// Supports deserializing either a whitespace-separated list of arguments in a

tests/testsuite/cargo_env_config.rs

@@ -0,0 +1,110 @@
+//! Tests for `[env]` config.
+
+use cargo_test_support::{basic_bin_manifest, project};
+
+#[cargo_test]
+fn env_basic() {
+    let p = project()
+        .file("Cargo.toml", &basic_bin_manifest("foo"))
+        .file("src/main.rs", r#"
+        use std::env;
+        fn main() {
+            println!( "compile-time:{}", env!("ENV_TEST_1233") );
+            println!( "run-time:{}", env::var("ENV_TEST_1233").unwrap());
+        }
+        "#)
+        .file(
+        ".cargo/config",
+        r#"
+                [env]
+                ENV_TEST_1233 = "Hello"
+            "#,
+        )
+        .build();
+
+    p.cargo("run")
+        .with_stdout_contains("compile-time:Hello")
+        .with_stdout_contains("run-time:Hello")
+        .run();
+}
+
+#[cargo_test]
+fn env_invalid() {
+    let p = project()
+        .file("Cargo.toml", &basic_bin_manifest("foo"))
+        .file("src/main.rs", r#"
+        fn main() {
+        }
+        "#)
+        .file(
+        ".cargo/config",
+        r#"
+                [env]
+                ENV_TEST_BOOL = false
+            "#,
+        )
+        .build();
+
+    p.cargo("build")
+        .with_status(101)
+        .with_stderr_contains("[..]`env.ENV_TEST_BOOL` expected a string, but found a boolean")
+        .run();
+}
+
+#[cargo_test]
+fn env_force() {
+    let p = project()
+        .file("Cargo.toml", &basic_bin_manifest("foo"))
+        .file("src/main.rs", r#"
+        use std::env;
+        fn main() {
+            println!( "ENV_TEST_FORCED:{}", env!("ENV_TEST_FORCED") );
+            println!( "ENV_TEST_UNFORCED:{}", env!("ENV_TEST_UNFORCED") );
+        }
+        "#)
+        .file(
+        ".cargo/config",
+        r#"
+                [env]
+                ENV_TEST_UNFORCED = "from-config"
+                ENV_TEST_FORCED = { value = "from-config", force = true }
+            "#,
+        )
+        .build();
+
+    p.cargo("run")
+        .env("ENV_TEST_FORCED", "from-env")
+        .env("ENV_TEST_UNFORCED", "from-env")
+        .with_stdout_contains("ENV_TEST_FORCED:from-config")
+        .with_stdout_contains("ENV_TEST_UNFORCED:from-env")
+        .run();
+}
+
+#[cargo_test]
+fn env_relative() {
+    let p = project()
+        .file("Cargo.toml", &basic_bin_manifest("foo2"))
+        .file("src/main.rs", r#"
+        use std::env;
+        use std::path::Path;
+        fn main() {
+            println!( "ENV_TEST_RELATIVE:{}", env!("ENV_TEST_RELATIVE") );
+            println!( "ENV_TEST_ABSOLUTE:{}", env!("ENV_TEST_ABSOLUTE") );
+
+            assert!( Path::new(env!("ENV_TEST_ABSOLUTE")).is_absolute() );
+            assert!( !Path::new(env!("ENV_TEST_RELATIVE")).is_absolute() );
+        }
+        "#)
+        .file(
+        ".cargo/config",
+        r#"
+                [env]
+                ENV_TEST_RELATIVE = "Cargo.toml"
+                ENV_TEST_ABSOLUTE = { value = "Cargo.toml", relative = true }
+            "#,
+        )
+        .build();
+
+    p.cargo("run")
+        .run();
+}

tests/testsuite/main.rs

@@ -24,6 +24,7 @@ mod build_script_extra_link_arg;
 mod cache_messages;
 mod cargo_alias_config;
 mod cargo_command;
+mod cargo_env_config;
 mod cargo_features;
 mod cargo_targets;
 mod cfg;