Emit warning on env variable case mismatch

src/cargo/util/config/mod.rs

@@ -167,6 +167,8 @@ pub struct Config {
     target_dir: Option<Filesystem>,
     /// Environment variables, separated to assist testing.
     env: HashMap<String, String>,
+    /// Environment variables, converted to uppercase to check for case mismatch
+    upper_case_env: HashMap<String, String>,
     /// Tracks which sources have been updated to avoid multiple updates.
     updated_sources: LazyCell<RefCell<HashSet<SourceId>>>,
     /// Lock, if held, of the global package cache along with the number of
@@ -211,6 +213,16 @@ impl Config {
             })
             .collect();
 
+        let mut upper_case_env: HashMap<String, String> = HashMap::new();
+
+        if !cfg!(windows) {
+            upper_case_env = env
+                .clone()
+                .into_iter()
+                .map(|(k, _)| (k.to_uppercase().replace("-", "_"), k))
+                .collect();
+        }
+
         let cache_rustc_info = match env.get("CARGO_CACHE_RUSTC_INFO") {
             Some(cache) => cache != "0",
             _ => true,
@@ -244,6 +256,7 @@ impl Config {
             creation_time: Instant::now(),
             target_dir: None,
             env,
+            upper_case_env,
             updated_sources: LazyCell::new(),
             package_cache_lock: RefCell::new(None),
             http_config: LazyCell::new(),
@@ -525,7 +538,10 @@ impl Config {
                     definition,
                 }))
             }
-            None => Ok(None),
+            None => {
+                self.check_environment_key_case_mismatch(key);
+                Ok(None)
+            }
         }
     }
 
@@ -545,9 +561,27 @@ impl Config {
                 return true;
             }
         }
+        self.check_environment_key_case_mismatch(key);
+
         false
     }
 
+    fn check_environment_key_case_mismatch(&self, key: &ConfigKey) {
+        if cfg!(windows) {
+            return;
+        }
+        match self.upper_case_env.get(key.as_env_key()) {
+            Some(env_key) => {
+                let _ = self.shell().warn(format!(
+                    "Variables in environment require uppercase,
+                        but given variable: {}, contains lowercase or dash.",
+                    env_key
+                ));
+            }
+            None => {}
+        }
+    }
+
     /// Get a string config value.
     ///
     /// See `get` for more details.
@@ -640,7 +674,10 @@ impl Config {
     ) -> CargoResult<()> {
         let env_val = match self.env.get(key.as_env_key()) {
             Some(v) => v,
-            None => return Ok(()),
+            None => {
+                self.check_environment_key_case_mismatch(key);
+                return Ok(());
+            }
         };
 
         let def = Definition::Environment(key.as_env_key().to_string());

tests/testsuite/tool_paths.rs

@@ -353,6 +353,29 @@ fn custom_linker_env() {
         .run();
 }
 
+#[cargo_test]
+#[cfg(not(windows))]
+fn target_in_environment_contains_lower_case() {
+    let p = project().file("src/main.rs", "fn main() {}").build();
+
+    let target_keys = [
+        "CARGO_TARGET_X86_64_UNKNOWN_LINUX_musl_LINKER",
+        "CARGO_TARGET_x86_64_unknown_linux_musl_LINKER",
+    ];
+
+    for target_key in &target_keys {
+        p.cargo("build -v --target x86_64-unknown-linux-musl")
+            .env(target_key, "nonexistent-linker")
+            .with_status(101)
+            .with_stderr_contains(format!(
+                "warning: Variables in environment require uppercase,
+                        but given variable: {}, contains lowercase or dash.",
+                target_key
+            ))
+            .run();
+    }
+}
+
 #[cargo_test]
 fn cfg_ignored_fields() {
     // Test for some ignored fields in [target.'cfg()'] tables.