cc works for non-absolute-path toolchains

Bring along the files, and make sure to absolut-ise the CC path.

Also, add in the env vars required by the linker, because these are
required for proper toolchain detection on the default OSX cc_toolchain.

Author: illicitonion

cargo/cargo_build_script.bzl

@@ -1,4 +1,4 @@
-load("@io_bazel_rules_rust//rust:private/rustc.bzl", "BuildInfo", "DepInfo", "get_compilation_mode_opts")
+load("@io_bazel_rules_rust//rust:private/rustc.bzl", "BuildInfo", "DepInfo", "get_compilation_mode_opts", "get_linker_and_args")
 load("@io_bazel_rules_rust//rust:private/utils.bzl", "find_toolchain")
 load("@io_bazel_rules_rust//rust:rust.bzl", "rust_binary")
 load("@bazel_tools//tools/cpp:toolchain_utils.bzl", "find_cpp_toolchain")
@@ -20,6 +20,14 @@ def _cargo_build_script_run(ctx, script):
             crate_name = crate_name.replace("_build_script", "")
         crate_name = crate_name.replace("_", "-")
 
+    toolchain_tools = [
+        # Needed for rustc to function.
+        toolchain.rustc_lib.files,
+        toolchain.rust_lib.files,
+    ]
+
+    cc_toolchain = find_cpp_toolchain(ctx)
+
     env = {
         "CARGO_CFG_TARGET_ARCH": toolchain.target_arch,
         "CARGO_MANIFEST_DIR": manifest_dir,
@@ -31,10 +39,15 @@ def _cargo_build_script_run(ctx, script):
         "TARGET": toolchain.target_triple,
     }
 
-    cc_toolchain = find_cpp_toolchain(ctx)
+    # Pull in env vars which may be required for the cc_toolchain to work (e.g. on OSX, the SDK version).
+    # We hope that the linker env is sufficient for the whole cc_toolchain.
+    _, _, linker_env = get_linker_and_args(ctx, None)
+    env.update(**linker_env)
+
     cc_executable = cc_toolchain and cc_toolchain.compiler_executable
     if cc_executable:
         env["CC"] = cc_executable
+        toolchain_tools.append(cc_toolchain.all_files)
 
     for f in ctx.attr.crate_features:
         env["CARGO_FEATURE_" + f.upper().replace("-", "_")] = "1"
@@ -45,11 +58,7 @@ def _cargo_build_script_run(ctx, script):
             ctx.executable._cargo_build_script_runner,
             toolchain.rustc,
         ],
-        transitive = [
-            # Needed for rustc to function.
-            toolchain.rustc_lib.files,
-            toolchain.rust_lib.files,
-        ],
+        transitive = toolchain_tools,
     )
 
     # dep_env_file contains additional environment variables coming from
@@ -109,6 +118,7 @@ _build_script_run = rule(
         ),
         "deps": attr.label_list(),
     },
+    fragments = ["cpp"],
     toolchains = [
         "@io_bazel_rules_rust//rust:toolchain",
         "@bazel_tools//tools/cpp:toolchain_type",

cargo/cargo_build_script_runner/bin.rs

@@ -18,11 +18,14 @@ extern crate cargo_build_script_output_parser;
 
 use cargo_build_script_output_parser::BuildScriptOutput;
 use std::env;
-use std::fs::{File, canonicalize, create_dir_all};
+use std::fs::{canonicalize, create_dir_all, File};
 use std::io::Write;
+use std::path::Path;
 use std::process::{exit, Command};
 
 fn main() {
+    let exec_root = env::current_dir().expect("Failed to get current directory");
+
     let mut args = env::args().skip(1);
     let manifest_dir_env = env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR was not set");
     let out_dir_env = env::var("OUT_DIR").expect("OUT_DIR was not set");
@@ -31,18 +34,35 @@ fn main() {
     let rustc_env = env::var("RUSTC").expect("RUSTC was not set");
     // Because of the Bazel's sandbox, bazel cannot provide full path, convert all relative path to correct path.
     let manifest_dir = canonicalize(&manifest_dir_env).expect(&format!("Failed to canonicalize '{}'", manifest_dir_env));
-    let out_dir = canonicalize(&out_dir_env).expect(&format!("Failed to canonicalize '{}'", out_dir_env));
+    let out_dir =
+        canonicalize(&out_dir_env).expect(&format!("Failed to canonicalize '{}'", out_dir_env));
     let rustc = canonicalize(&rustc_env).expect(&format!("Failed to canonicalize '{}'", rustc_env));
+
+    let cc = env::var_os("CC").map(|env_var| {
+        let cc_path = Path::new(&env_var);
+        if cc_path.is_relative() {
+            exec_root.join(cc_path).into_os_string()
+        } else {
+            env_var
+        }
+    });
+
     match (args.next(), args.next(), args.next(), args.next(), args.next()) {
         (Some(progname), Some(crate_name), Some(envfile), Some(flagfile), Some(depenvfile)) => {
-            let output = BuildScriptOutput::from_command(
-                    Command::new(
-                        canonicalize(&progname).expect(&format!("Failed to canonicalize '{}'", progname)))
+            let mut command = Command::new(
+                canonicalize(&progname).expect(&format!("Failed to canonicalize '{}'", progname)),
+            );
+            command
                 .args(args)
                 .current_dir(manifest_dir.clone())
                 .env("OUT_DIR", out_dir)
                 .env("CARGO_MANIFEST_DIR", manifest_dir)
-                .env("RUSTC", rustc));
+                .env("RUSTC", rustc);
+
+            if let Some(cc) = cc {
+                command.env("CC", cc);
+            }
+            let output = BuildScriptOutput::from_command(&mut command);
             let mut f =
                 File::create(&envfile).expect(&format!("Unable to create file {}", envfile));
             f.write_all(BuildScriptOutput::to_env(&output).as_bytes())

rust/private/rustc.bzl

@@ -192,7 +192,7 @@ def collect_deps(label, deps, proc_macro_deps, aliases, toolchain):
         build_info,
     )
 
-def _get_linker_and_args(ctx, rpaths):
+def get_linker_and_args(ctx, rpaths):
     if (len(BAZEL_VERSION) == 0 or
         versions.is_at_least("0.18.0", BAZEL_VERSION)):
         user_link_flags = ctx.fragments.cpp.linkopts
@@ -327,7 +327,7 @@ def _construct_arguments(
     # linker since it won't understand.
     if toolchain.target_arch != "wasm32":
         rpaths = _compute_rpaths(toolchain, output_dir, dep_info)
-        ld, link_args, link_env = _get_linker_and_args(ctx, rpaths)
+        ld, link_args, link_env = get_linker_and_args(ctx, rpaths)
         env.update(link_env)
         args.add("--codegen=linker=" + ld)
         args.add_joined("--codegen", link_args, join_with = " ", format_joined = "link-args=%s")