fix: include wrapper args. in stdout family heuristics

This can be particularly significant for compilers that can dynamically
change what options they accept based on arguments, like `clang
--driver-mode=cl`.

Author: ErichDonGubler

CHANGELOG.md

@@ -6,6 +6,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+- Include compiler wrapper arguments (i.e., `CC=compiler arg1 arg2`) in the classification of compilers' tool family. This fixes cases like `clang --driver-mode=cl` being incorrectly detected as needing `clang`-like arguments, rather than `cl`-like arguments. [#????](https://github.com/rust-lang/cc-rs/????).
+
 ## [1.2.10](https://github.com/rust-lang/cc-rs/compare/cc-v1.2.9...cc-v1.2.10) - 2025-01-17
 
 ### Other

src/lib.rs

@@ -277,7 +277,7 @@ struct BuildCache {
     env_cache: RwLock<HashMap<Box<str>, Env>>,
     apple_sdk_root_cache: RwLock<HashMap<Box<str>, Arc<OsStr>>>,
     apple_versions_cache: RwLock<HashMap<Box<str>, Arc<str>>>,
-    cached_compiler_family: RwLock<HashMap<Box<Path>, ToolFamily>>,
+    cached_compiler_family: RwLock<HashMap<(Box<Path>, Vec<String>), ToolFamily>>,
     known_flag_support_status_cache: RwLock<HashMap<CompilerFlag, bool>>,
     target_info_parser: target::TargetInfoParser,
 }

src/tool.rs

@@ -40,7 +40,7 @@ pub struct Tool {
 impl Tool {
     pub(crate) fn new(
         path: PathBuf,
-        cached_compiler_family: &RwLock<HashMap<Box<Path>, ToolFamily>>,
+        cached_compiler_family: &RwLock<HashMap<(Box<Path>, Vec<String>), ToolFamily>>,
         cargo_output: &CargoOutput,
         out_dir: Option<&Path>,
     ) -> Self {
@@ -57,7 +57,7 @@ impl Tool {
     pub(crate) fn with_args(
         path: PathBuf,
         args: Vec<String>,
-        cached_compiler_family: &RwLock<HashMap<Box<Path>, ToolFamily>>,
+        cached_compiler_family: &RwLock<HashMap<(Box<Path>, Vec<String>), ToolFamily>>,
         cargo_output: &CargoOutput,
         out_dir: Option<&Path>,
     ) -> Self {
@@ -90,7 +90,7 @@ impl Tool {
         path: PathBuf,
         args: Vec<String>,
         cuda: bool,
-        cached_compiler_family: &RwLock<HashMap<Box<Path>, ToolFamily>>,
+        cached_compiler_family: &RwLock<HashMap<(Box<Path>, Vec<String>), ToolFamily>>,
         cargo_output: &CargoOutput,
         out_dir: Option<&Path>,
     ) -> Self {
@@ -114,21 +114,25 @@ impl Tool {
         fn guess_family_from_stdout(
             stdout: &str,
             path: &Path,
+            args: &[String],
             cargo_output: &CargoOutput,
         ) -> Result<ToolFamily, Error> {
             cargo_output.print_debug(&stdout);
 
             // https://gitlab.kitware.com/cmake/cmake/-/blob/69a2eeb9dff5b60f2f1e5b425002a0fd45b7cadb/Modules/CMakeDetermineCompilerId.cmake#L267-271
             // stdin is set to null to ensure that the help output is never paginated.
-            let accepts_cl_style_flags =
-                run(Command::new(path).arg("-?").stdin(Stdio::null()), path, &{
+            let accepts_cl_style_flags = run(
+                Command::new(path).args(args).arg("-?").stdin(Stdio::null()),
+                path,
+                &{
                     // the errors are not errors!
                     let mut cargo_output = cargo_output.clone();
                     cargo_output.warnings = cargo_output.debug;
                     cargo_output.output = OutputKind::Discard;
                     cargo_output
-                })
-                .is_ok();
+                },
+            )
+            .is_ok();
 
             let clang = stdout.contains(r#""clang""#);
             let gcc = stdout.contains(r#""gcc""#);
@@ -153,6 +157,7 @@ impl Tool {
 
         fn detect_family_inner(
             path: &Path,
+            args: &[String],
             cargo_output: &CargoOutput,
             out_dir: Option<&Path>,
         ) -> Result<ToolFamily, Error> {
@@ -207,25 +212,29 @@ impl Tool {
                     &compiler_detect_output,
                 )?;
                 let stdout = String::from_utf8_lossy(&stdout);
-                guess_family_from_stdout(&stdout, path, cargo_output)
+                guess_family_from_stdout(&stdout, path, args, cargo_output)
             } else {
-                guess_family_from_stdout(&stdout, path, cargo_output)
+                guess_family_from_stdout(&stdout, path, args, cargo_output)
             }
         }
-        let detect_family = |path: &Path| -> Result<ToolFamily, Error> {
-            if let Some(family) = cached_compiler_family.read().unwrap().get(path) {
+        let detect_family = |path: &Path, args: &[String]| -> Result<ToolFamily, Error> {
+            let cache_key = (Box::from(path), args.to_vec());
+            if let Some(family) = cached_compiler_family.read().unwrap().get(&cache_key) {
                 return Ok(*family);
             }
 
-            let family = detect_family_inner(path, cargo_output, out_dir)?;
+            let family = {
+                let (path, args) = &cache_key;
+                detect_family_inner(path, args, cargo_output, out_dir)?
+            };
             cached_compiler_family
                 .write()
                 .unwrap()
-                .insert(path.into(), family);
+                .insert(cache_key, family);
             Ok(family)
         };
 
-        let family = detect_family(&path).unwrap_or_else(|e| {
+        let family = detect_family(&path, &args).unwrap_or_else(|e| {
             cargo_output.print_warning(&format_args!(
                 "Compiler family detection failed due to error: {}",
                 e