fix: don't prefer clang for -Clinker-plugin-lto=no (#2046)

`prefer_clang` looked for the text `linker-plugin-lto` anywhere in
`CARGO_ENCODED_RUSTFLAGS`, so `-Clinker-plugin-lto=no` (or `n`, `off`,
`false`, or a later `=no` after an enabling flag) and unrelated flags
that merely contain the text still made cc look for `clang` first when
`CC` is not set.

Use the parsed value from `RustcCodegenFlags` instead, the same one
that decides whether `-flto=thin` is passed.

Author: waltuov

src/flags.rs

@@ -281,6 +281,11 @@ impl<'this> RustcCodegenFlags<'this> {
         }
     }
 
+    /// Whether the last `-Clinker-plugin-lto` enables linker-plugin LTO.
+    pub(crate) fn linker_plugin_lto(&self) -> bool {
+        self.linker_plugin_lto.unwrap_or(false)
+    }
+
     // Rust and clang/cc don't agree on what equivalent flags should look like.
     pub(crate) fn cc_flags(
         &self,
@@ -435,7 +440,7 @@ impl<'this> RustcCodegenFlags<'this> {
                 }
 
                 // https://doc.rust-lang.org/rustc/linker-plugin-lto.html
-                if self.linker_plugin_lto.unwrap_or(false) {
+                if self.linker_plugin_lto() {
                     // https://clang.llvm.org/docs/ClangCommandLineReference.html#cmdoption-clang-flto
                     // In order to use linker-plugin-lto to achieve cross-lang lto, cc has to use thin LTO
                     // to compile the c/c++ libraries because llvm linker plugin/lld uses thin LTO by default.

src/lib.rs

@@ -3962,9 +3962,14 @@ impl Build {
         cmd
     }
 
+    /// Whether to look for `clang` (or `clang++`) first when no compiler is
+    /// set, so that C and C++ code can take part in rustc's linker-plugin LTO.
     fn prefer_clang(&self) -> bool {
         if let Some(env) = self.get_cargo_env("CARGO_ENCODED_RUSTFLAGS") {
-            env.to_string_lossy().contains("linker-plugin-lto")
+            // Flags that don't parse are left for rustc and
+            // `add_inherited_rustflags` to report.
+            RustcCodegenFlags::parse(&env.to_string_lossy())
+                .map_or(false, |flags| flags.linker_plugin_lto())
         } else {
             false
         }

tests/rustflags.rs

@@ -128,3 +128,31 @@ fn enabled_linker_plugin_lto_preserves_clang_lto() {
         test.cmd_for_source("foo.c").must_have("-flto=thin");
     }
 }
+
+#[test]
+fn linker_plugin_lto_prefers_clang() {
+    for (flags, program) in [
+        ("-Clinker-plugin-lto", "clang"),
+        ("-Clinker-plugin-lto=yes", "clang"),
+        ("-Clinker-plugin-lto=/path/to/LLVMgold.so", "clang"),
+        ("-C\u{1f}linker-plugin-lto", "clang"),
+        ("-Clinker-plugin-lto=no\u{1f}-Clinker-plugin-lto", "clang"),
+        ("-Clinker-plugin-lto=n", "cc"),
+        ("-Clinker-plugin-lto=no", "cc"),
+        ("-Clinker-plugin-lto=off", "cc"),
+        ("-Clinker-plugin-lto=false", "cc"),
+        ("--codegen\u{1f}linker-plugin-lto=no", "cc"),
+        ("-Clinker-plugin-lto\u{1f}-Clinker-plugin-lto=no", "cc"),
+        ("-L/opt/linker-plugin-lto/lib", "cc"),
+        ("", "cc"),
+    ] {
+        let mut test = Test::gnu();
+        test.shim("clang");
+        // cc looks for `clang` on the inherited `PATH`, not on the one set
+        // with `Build::env`.
+        test.env.set("PATH", test.td.path());
+        test.env.set("CARGO_ENCODED_RUSTFLAGS", flags);
+        test.gcc().file("foo.c").compile("foo");
+        test.cmd_for_source("foo.c").must_run(program);
+    }
+}