rust: use clang-cl or cl as linkers for -msvc targets

With clang exists in the system path and cl does not, meson generates build.ninja file using
clang as linker even for -msvc targets.  Look at the target, and detect the correct C/C++
compiler based on whether it is a MSVC target.

Fixes: #6638
Signed-off-by: Paolo Bonzini <[email protected]>

Author: bonzini

mesonbuild/compilers/detect.py

@@ -1051,14 +1051,33 @@ def detect_vala_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp
         return comp_class(exelist, version, for_machine, env)
     raise EnvironmentException('Unknown compiler: ' + join_args(exelist))
 
+
+def _get_rust_target(compiler: T.List[str]) -> T.Optional[str]:
+    """Extract the Rust target from compiler arguments or rustc -vV output."""
+    # Check for explicit --target in compiler arguments
+    for i, arg in enumerate(compiler):
+        if arg == '--target' and i + 1 < len(compiler):
+            return compiler[i + 1]
+        if arg.startswith('--target='):
+            return arg.split('=', 1)[1]
+
+    # Query rustc for its host target
+    try:
+        out = Popen_safe(compiler + ['-vV'])[1]
+        for line in out.splitlines():
+            if line.startswith('host:'):
+                return line.split(':', 1)[1].strip()
+    except OSError:
+        pass
+
+    return None
+
+
 def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> RustCompiler:
     from . import rust
     from ..linkers import linkers
     popen_exceptions: T.Dict[str, Exception] = {}
     compilers, _ = _get_compilers(env, 'rust', for_machine)
-
-    cc = detect_c_compiler(env, for_machine)
-    is_link_exe = isinstance(cc.linker, linkers.VisualStudioLikeLinkerMixin)
     override = env.lookup_binary_entry(for_machine, 'rust_ld')
 
     for compiler in compilers:
@@ -1101,12 +1120,33 @@ def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> Rust
         if 'rustc' in out:
             # On Linux and mac rustc will invoke gcc (clang for mac
             # presumably) and it can do this windows, for dynamic linking.
-            # this means the easiest way to C compiler for dynamic linking.
-            # figure out what linker to use is to just get the value of the
-            # C compiler and use that as the basis of the rust linker.
+            # this means the easiest way to figure out what linker to use
+            # is to just get the value of the C compiler and use that as
+            # the basis of the rust linker.
+            #
             # However, there are two things we need to change, if CC is not
             # the default use that, and second add the necessary arguments
             # to rust to use -fuse-ld
+            #
+            # For MSVC targets, require an MSVC-compatible C compiler to get
+            # the corresponding linker
+            rust_target = _get_rust_target(compiler)
+            if rust_target and rust_target.endswith('-msvc'):
+                try:
+                    cc = _detect_c_or_cpp_compiler(env, 'c', for_machine,
+                                                   override_compiler=['clang-cl', 'cl'])
+                except EnvironmentException:
+                    popen_exceptions[join_args(compiler)] = \
+                        EnvironmentException('No MSVC-compatible C compiler found for MSVC Rust target')
+                    continue
+            else:
+                try:
+                    cc = detect_c_compiler(env, for_machine)
+                except EnvironmentException as e:
+                    popen_exceptions[join_args(compiler)] = e
+                    continue
+
+            is_link_exe = isinstance(cc.linker, linkers.VisualStudioLikeLinkerMixin)
 
             if any(a.startswith('linker=') for a in compiler):
                 mlog.warning(