Add tests for prefer_clang_cl_over_msvc

Author: dennisameling

src/windows/find_tools.rs

@@ -287,6 +287,7 @@ mod impl_ {
 
     use super::{EnvGetter, TargetArch, MSVC_FAMILY};
     use crate::Tool;
+    use crate::ToolFamily;
 
     struct MsvcTool {
         tool: PathBuf,
@@ -555,7 +556,7 @@ mod impl_ {
                 base_path.push(tool);
                 base_path
                     .is_file()
-                    .then(|| Tool::with_family(base_path, MSVC_FAMILY))
+                    .then(|| Tool::with_family(base_path, ToolFamily::Msvc { clang_cl: true }))
             })
             .next()
     }

tests/support/mod.rs

@@ -14,6 +14,7 @@ pub struct Test {
     pub td: TempDir,
     pub gcc: PathBuf,
     pub msvc: bool,
+    pub msvc_autodetect: bool,
 }
 
 pub struct Execution {
@@ -53,6 +54,7 @@ impl Test {
             td,
             gcc,
             msvc: false,
+            msvc_autodetect: false,
         }
     }
 
@@ -69,6 +71,14 @@ impl Test {
         t
     }
 
+    // For msvc_autodetect, don't explicitly set the compiler - let the build system discover it
+    pub fn msvc_autodetect() -> Test {
+        let mut t = Test::new();
+        t.shim("cl").shim("clang-cl.exe").shim("lib.exe");
+        t.msvc_autodetect = true;
+        t
+    }
+
     pub fn clang() -> Test {
         let t = Test::new();
         t.shim("clang").shim("clang++").shim("ar");
@@ -87,7 +97,7 @@ impl Test {
 
     pub fn gcc(&self) -> cc::Build {
         let mut cfg = cc::Build::new();
-        let target = if self.msvc {
+        let target = if self.msvc || self.msvc_autodetect {
             "x86_64-pc-windows-msvc"
         } else if cfg!(target_os = "macos") {
             "x86_64-apple-darwin"

tests/test.rs

@@ -851,3 +851,97 @@ fn clang_android() {
         test.cmd(0).must_not_have("--target=arm-linux-androideabi");
     }
 }
+
+#[test]
+#[cfg(windows)]
+fn msvc_prefer_clang_cl_over_msvc_disabled_by_default() {
+    reset_env();
+
+    let test = Test::msvc_autodetect();
+
+    // When prefer_clang_cl_over_msvc is not called (default false), should use MSVC
+    let compiler = test
+        .gcc()
+        .try_get_compiler()
+        .expect("Failed to get compiler");
+
+    // By default, should be using MSVC (cl.exe) and NOT clang-cl
+    assert!(compiler.is_like_msvc(), "Should use MSVC by default");
+    assert!(
+        !compiler.is_like_clang_cl(),
+        "Should not use clang-cl by default"
+    );
+}
+
+#[test]
+#[cfg(windows)]
+fn msvc_prefer_clang_cl_over_msvc_enabled() {
+    reset_env();
+
+    let test = Test::msvc_autodetect();
+
+    let compiler = test
+        .gcc()
+        // When prefer_clang_cl_over_msvc is true, should use clang-cl.exe
+        .prefer_clang_cl_over_msvc(true)
+        .try_get_compiler()
+        .expect("Failed to get compiler");
+
+    assert!(
+        compiler.is_like_clang_cl(),
+        "clang-cl.exe should be identified as clang-cl-like, got {:?}",
+        compiler
+    );
+    assert!(
+        compiler.is_like_msvc(),
+        "clang-cl should still be MSVC-like"
+    );
+}
+
+#[test]
+#[cfg(windows)]
+fn msvc_prefer_clang_cl_over_msvc_respects_explicit_cc_env() {
+    reset_env();
+
+    let test = Test::msvc_autodetect();
+    let compiler = test
+        .gcc()
+        // We can't set the CC=cl.exe environment variable directly in the test as it's removed
+        // in mod.rs, so we simulate it by setting the compiler directly
+        .compiler("cl.exe")
+        .prefer_clang_cl_over_msvc(true)
+        .try_get_compiler()
+        .expect("Failed to get compiler");
+
+    // The preference should not override explicit compiler setting
+    assert!(compiler.is_like_msvc(), "Should still be MSVC-like");
+    assert!(
+        !compiler.is_like_clang_cl(),
+        "Should NOT use clang-cl when CC is explicitly set to cl.exe, got {:?}",
+        compiler
+    );
+}
+
+#[test]
+#[cfg(windows)]
+fn msvc_prefer_clang_cl_over_msvc_cpp_mode() {
+    reset_env();
+
+    let test = Test::msvc_autodetect();
+    let compiler = test
+        .gcc()
+        .cpp(true)
+        .prefer_clang_cl_over_msvc(true)
+        .try_get_compiler()
+        .expect("Failed to get compiler");
+
+    // Verify clang-cl.exe works correctly in C++ mode
+    assert!(
+        compiler.is_like_clang_cl(),
+        "clang-cl.exe should be identified as clang-cl-like in C++ mode"
+    );
+    assert!(
+        compiler.is_like_msvc(),
+        "clang-cl should still be MSVC-like in C++ mode"
+    );
+}