add run_in_execroot flag to cargo_build_script()

Re discussion on
bazelbuild#461 (review)

Author: dae

cargo/cargo_build_script.bzl

@@ -60,6 +60,9 @@ def _build_script_impl(ctx):
         # OUT_DIR is set by the runner itself, rather than on the action.
     })
 
+    if ctx.attr.run_in_execroot:
+        env["RUN_IN_EXECROOT"] = "1"
+
     if ctx.attr.version:
         version = ctx.attr.version.split("+")[0].split(".")
         patch = version[2].split("-") if len(version) > 2 else [""]
@@ -174,6 +177,9 @@ _build_script_run = rule(
             doc = "Data or tools required by the build script.",
             allow_files = True,
         ),
+        "run_in_execroot": attr.bool(
+            doc = "Whether to start in execroot, or the manifest dir.",
+        ),
         "_cc_toolchain": attr.label(
             default = Label("@bazel_tools//tools/cpp:current_cc_toolchain"),
         ),
@@ -199,6 +205,7 @@ def cargo_build_script(
         deps = [],
         build_script_env = {},
         data = [],
+        run_in_execroot = False,
         **kwargs):
     """Compile and execute a rust build script to generate build attributes
 
@@ -236,12 +243,14 @@ def cargo_build_script(
            "CARGO_PKG_VERSION": "0.1.2",
         },
         # Optional environment variables passed during build.rs execution.
-        # The path will be relative to the folder above bazel-out, so your
-        # build script will need to walk up the tree first - see build.rs
-        # in examples/env_locations for a demo.
         build_script_env = {
             "SOME_TOOL_OR_FILE": "$(execroot @tool//:binary)"
         }
+        # When passsing locations in, this must be set so the build script
+        # runs relative to execroot. When not set, the build script runs
+        # in CARGO_MANIFEST_DIR, for compatibility with crates imported
+        # via cargo raze.
+        run_in_execroot = True,
         # Optional data/tool dependencies
         data = ["@tool//:binary"],
     )
@@ -266,6 +275,7 @@ def cargo_build_script(
         deps (list, optional): The dependencies of the crate defined by `crate_name`.
         build_script_env (dict, optional): Environment variables for build scripts.
         data (list, optional): Files or tools needed by the build script.
+        run_in_execroot (bool, optional): Run in execroot instead of manifest folder, for location expansion.
         **kwargs: Forwards to the underlying `rust_binary` rule.
     """
     rust_binary(
@@ -284,4 +294,5 @@ def cargo_build_script(
         version = version,
         build_script_env = build_script_env,
         data = data,
+        run_in_execroot = run_in_execroot,
     )

cargo/cargo_build_script_runner/bin.rs

@@ -37,6 +37,11 @@ fn main() -> Result<(), String> {
     let rustc_env = env::var("RUSTC").expect("RUSTC was not set");
     let manifest_dir = exec_root.join(&manifest_dir_env);
     let rustc = exec_root.join(&rustc_env);
+    let working_dir = if env::var("RUN_IN_EXECROOT").is_ok() {
+        &exec_root
+    } else {
+        &manifest_dir
+    };
 
     match (args.next(), args.next(), args.next(), args.next(), args.next(), args.next(), args.next()) {
         (Some(progname), Some(crate_name), Some(out_dir), Some(envfile), Some(flagfile), Some(linkflags), Some(depenvfile)) => {
@@ -48,7 +53,7 @@ fn main() -> Result<(), String> {
 
             let mut command = Command::new(exec_root.join(&progname));
             command
-                .current_dir(manifest_dir.clone())
+                .current_dir(working_dir)
                 .envs(target_env_vars)
                 .env("OUT_DIR", out_dir_abs)
                 .env("CARGO_MANIFEST_DIR", manifest_dir)

examples/env_locations/BUILD

@@ -30,6 +30,7 @@ cargo_build_script(
         "SOME_TOOL": "$(execpath @com_google_protobuf//:protoc)",
     },
     data = _data,
+    run_in_execroot = True,
 )
 
 rust_test(

examples/env_locations/build.rs

@@ -1,28 +1,17 @@
 use std::{fs,env};
 
 fn main() {
-    // walk up and locate bazel-out
-    let mut execroot = env::current_dir().unwrap(); 
-    let mut should_continue = true;
-    loop {
-        should_continue = !execroot.ends_with("bazel-out");
-        execroot.pop();
-        if !should_continue {
-            break;
-        }
-    }
-
     // our source file should be readable
-    let path = execroot.join(env::var("SOURCE_FILE").unwrap());
+    let path = env::var("SOURCE_FILE").unwrap();
     let generated_data = fs::read_to_string(&path).unwrap();
     assert_eq!(generated_data, "source\n");
 
     // our generated data file should be readable
-    let path = execroot.join(env::var("GENERATED_DATA").unwrap());
+    let path = env::var("GENERATED_DATA").unwrap();
     let generated_data = fs::read_to_string(&path).unwrap();
     assert_eq!(generated_data, "hello\n");
 
     // and we should be able to read (and thus execute) our tool
-    let path = execroot.join(env::var("SOME_TOOL").unwrap());
+    let path = env::var("SOME_TOOL").unwrap();
     assert_eq!(fs::read(&path).unwrap().is_empty(), false);
 }