refactor: move both sides of --driver-mode=cl check to Tool::get_base_compiler

Do this by plumbing through `args` associated with the compiler wrapper,
if any, instead of handling it in calling code.

Author: ErichDonGubler

src/lib.rs

@@ -2753,16 +2753,13 @@ impl Build {
         let tool_opt: Option<Tool> = self
             .env_tool(env)
             .map(|(tool, wrapper, args)| {
-                // find the driver mode, if any
-                const DRIVER_MODE: &str = "--driver-mode=";
-                let driver_mode = args.iter().find_map(|a| a.strip_suffix(DRIVER_MODE));
                 // Chop off leading/trailing whitespace to work around
                 // semi-buggy build scripts which are shared in
                 // makefiles/configure scripts (where spaces are far more
                 // lenient)
-                let mut t = Tool::with_clang_driver(
+                let mut t = Tool::with_args(
                     tool,
-                    driver_mode,
+                    args.clone(),
                     &self.build_cache.cached_compiler_family,
                     &self.cargo_output,
                     out_dir,
@@ -2882,7 +2879,7 @@ impl Build {
             };
             let mut nvcc_tool = Tool::with_features(
                 nvcc,
-                None,
+                vec![],
                 self.cuda,
                 &self.build_cache.cached_compiler_family,
                 &self.cargo_output,

src/tool.rs

@@ -46,24 +46,24 @@ impl Tool {
     ) -> Self {
         Self::with_features(
             path,
-            None,
+            vec![],
             false,
             cached_compiler_family,
             cargo_output,
             out_dir,
         )
     }
 
-    pub(crate) fn with_clang_driver(
+    pub(crate) fn with_args(
         path: PathBuf,
-        clang_driver: Option<&str>,
+        args: Vec<String>,
         cached_compiler_family: &RwLock<HashMap<Box<Path>, ToolFamily>>,
         cargo_output: &CargoOutput,
         out_dir: Option<&Path>,
     ) -> Self {
         Self::with_features(
             path,
-            clang_driver,
+            args,
             false,
             cached_compiler_family,
             cargo_output,
@@ -88,7 +88,7 @@ impl Tool {
 
     pub(crate) fn with_features(
         path: PathBuf,
-        clang_driver: Option<&str>,
+        args: Vec<String>,
         cuda: bool,
         cached_compiler_family: &RwLock<HashMap<Box<Path>, ToolFamily>>,
         cargo_output: &CargoOutput,
@@ -235,12 +235,19 @@ impl Tool {
                 Some(fname) if fname.ends_with("cl") || fname == "cl.exe" => {
                     ToolFamily::Msvc { clang_cl: false }
                 }
-                Some(fname) if fname.contains("clang") => match clang_driver {
-                    Some("cl") => ToolFamily::Msvc { clang_cl: true },
-                    _ => ToolFamily::Clang {
-                        zig_cc: is_zig_cc(&path, cargo_output),
-                    },
-                },
+                Some(fname) if fname.contains("clang") => {
+                    let is_clang_cl = args
+                        .iter()
+                        .find_map(|a| a.strip_prefix("--driver-mode="))
+                        .map_or(false, |dm| dm == "cl");
+                    if is_clang_cl {
+                        ToolFamily::Msvc { clang_cl: true }
+                    } else {
+                        ToolFamily::Clang {
+                            zig_cc: is_zig_cc(&path, cargo_output),
+                        }
+                    }
+                }
                 Some(fname) if fname.contains("zig") => ToolFamily::Clang { zig_cc: true },
                 _ => ToolFamily::Gnu,
             }