incremental compilation without a worker

This is considerably less invasive than bazelbuild#667, bazelbuild#517 and bazelbuild#421 - there
is no extra code to bootstrap, and no toolchains have to be plumbed
into the rules.

We had been using a worker to get around sandboxing restrictions, but
as @hlopko pointed out on bazelbuild#667, that turns out not to be necessary -
even normal rules have access to /tmp. Unfortunately it seems that rustc
does not expect the source files to change location, and it will
consistently crash when used in a sandboxed context. So the approach
this PR takes is to disable sandboxing on targets that are being compiled
incrementally. This fixes the compiler crashes, and as a bonus, means
we're not limited to saving the cache in /tmp.

This PR adds a --@rules_rust//:experimental_incremental_base flag to
specify the path where incremental build products are stored - if not
provided, the rules will function as they normally do.

It also requires targets to be tagged "incremental" - any without the
tag will be compiled normally, even if a base folder is provided. Cargo's
behaviour appears to be to only store incremental products for the
product being built (eg, all the dependencies you pull in from crates.io
do not have incremental build products stored), so manual tagging seems
preferable to an "include everything" approach.

Author: dae

BUILD.bazel

@@ -1,5 +1,6 @@
 load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
 load("//rust:rust.bzl", "error_format")
+load("//rust/private:rustc.bzl", "string_flag")
 
 exports_files(["LICENSE"])
 
@@ -17,3 +18,10 @@ error_format(
     build_setting_default = "human",
     visibility = ["//visibility:public"],
 )
+
+# Optional incremental compilation - see docs/index.md
+string_flag(
+    name = "experimental_incremental_base",
+    build_setting_default = "",
+    visibility = ["//visibility:public"],
+)

docs/index.md

@@ -90,3 +90,20 @@ bazel build @examples//hello_world_wasm --platforms=@rules_rust//rust/platform:w
 
 `rust_wasm_bindgen` will automatically transition to the `wasm` platform and can be used when
 building WebAssembly code for the host target.
+
+## Incremental Compilation
+
+There is an experimental flag that enables incremental compilation, which can considerably
+speed up rebuilds during development.
+
+Enabling it is a two step process:
+
+- add a tag called "incremental" to any rust library, test, binary or build script targets
+  that you want to compile incrementally.
+- invoke bazel build with the following argument, changing the path to one of your liking:
+
+  --@rules_rust//:experimental_incremental_base=/home/user/cache/bazel_incremental
+
+When these two conditions have been met, sandboxing is disabled for the target, and it
+will be compiled using the local strategy, with incremental build products being placed
+into a subfolder of the one you have provided.

rust/private/rust.bzl

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+load("@bazel_skylib//rules:common_settings.bzl", "BuildSettingInfo")
+
 # buildifier: disable=module-docstring
 load("//rust/private:common.bzl", "rust_common")
 load("//rust/private:rustc.bzl", "rustc_compile_action")
@@ -263,6 +265,7 @@ def _rust_library_common(ctx, crate_type):
             is_test = False,
         ),
         output_hash = output_hash,
+        incremental_base = ctx.attr._incremental_base[BuildSettingInfo].value,
     )
 
 def _rust_binary_impl(ctx):
@@ -297,6 +300,7 @@ def _rust_binary_impl(ctx):
             rustc_env = ctx.attr.rustc_env,
             is_test = False,
         ),
+        incremental_base = ctx.attr._incremental_base[BuildSettingInfo].value,
     )
 
 def _create_test_launcher(ctx, toolchain, output, providers):
@@ -434,6 +438,7 @@ def _rust_test_common(ctx, toolchain, output):
         crate_type = crate_type,
         crate_info = crate_info,
         rust_flags = ["--test"],
+        incremental_base = ctx.attr._incremental_base[BuildSettingInfo].value,
     )
 
     return _create_test_launcher(ctx, toolchain, output, providers)
@@ -673,6 +678,7 @@ _common_attrs = {
         default = "@bazel_tools//tools/cpp:current_cc_toolchain",
     ),
     "_error_format": attr.label(default = "//:error_format"),
+    "_incremental_base": attr.label(default = "//:experimental_incremental_base"),
     "_process_wrapper": attr.label(
         default = Label("//util/process_wrapper"),
         executable = True,

rust/private/rustc.bzl

@@ -27,6 +27,7 @@ load(
     "get_preferred_artifact",
     "relativize",
 )
+load("@bazel_skylib//rules:common_settings.bzl", "BuildSettingInfo")
 
 BuildInfo = provider(
     doc = "A provider containing `rustc` build settings for a given Crate.",
@@ -492,7 +493,8 @@ def rustc_compile_action(
         crate_info,
         output_hash = None,
         rust_flags = [],
-        environ = {}):
+        environ = {},
+        incremental_base = None):
     """Create and run a rustc compile action based on the current rule's attributes
 
     Args:
@@ -503,6 +505,7 @@ def rustc_compile_action(
         output_hash (str, optional): The hashed path of the crate root. Defaults to None.
         rust_flags (list, optional): Additional flags to pass to rustc. Defaults to [].
         environ (dict, optional): A set of makefile expandable environment variables for the action
+        incremental_base (str, optional): path to store incremental build products in.
 
     Returns:
         list: A list of the following providers:
@@ -554,14 +557,32 @@ def rustc_compile_action(
     else:
         formatted_version = ""
 
+    if incremental_base and "incremental" in ctx.attr.tags:
+        incremental_dir = "{}/{}_{}".format(
+            incremental_base,
+            ctx.var["COMPILATION_MODE"],
+            toolchain.target_triple,
+        )
+        args.add("--codegen", "incremental=" + incremental_dir)
+
+        # with sandboxing enabled, subsequent rustc invocations will crash,
+        # as it doesn't expect the source files to have moved
+        execution_requirements = {"no-sandbox": "1"}
+        mnemonic = "RustcIncr"
+    else:
+        execution_requirements = {}
+        mnemonic = "Rustc"
+
     ctx.actions.run(
         executable = ctx.executable._process_wrapper,
         inputs = compile_inputs,
         outputs = [crate_info.output],
         env = env,
         arguments = [args],
-        mnemonic = "Rustc",
-        progress_message = "Compiling Rust {} {}{} ({} files)".format(
+        mnemonic = mnemonic,
+        execution_requirements = execution_requirements,
+        progress_message = "Compiling {} {} {}{} ({} files)".format(
+            mnemonic,
             crate_info.type,
             ctx.label.name,
             formatted_version,
@@ -934,3 +955,21 @@ error_format = rule(
     implementation = _error_format_impl,
     build_setting = config.string(flag = True),
 )
+
+def _string_flag_impl(ctx):
+    """Implementation for the string_flag() rule
+
+    Args:
+        ctx (ctx): The rule's context object
+
+    Returns:
+        BuildSettingInfo: an object with a value attribute containing the string.
+    """
+    value = ctx.build_setting_value
+    return BuildSettingInfo(value = value)
+
+string_flag = rule(
+    build_setting = config.string(flag = True),
+    implementation = _string_flag_impl,
+    doc = "Helper to declare a command line argument that accepts an arbitrary string.",
+)