Replace --define=EXECUTOR=remote with toolchains and select

This allows for cross-platform builds to work seamlessly without a need to manually toggle between prebuilt and from source toolchains.

Author: fmeum

site/en/remote/sandbox.md

@@ -71,7 +71,6 @@ build:docker-sandbox --javabase=<...>
 build:docker-sandbox --crosstool_top=<...>
 build:docker-sandbox --experimental_docker_image=<...>
 build:docker-sandbox --spawn_strategy=docker --strategy=Javac=docker --genrule_strategy=docker
-build:docker-sandbox --define=EXECUTOR=remote
 build:docker-sandbox --experimental_docker_verbose
 build:docker-sandbox --experimental_enable_docker_sandbox
 ```

src/MODULE.tools

@@ -45,4 +45,7 @@ bazel_dep(name = "rules_shell", version = "0.3.0")
 # add rules_android
 # add apple_support
 
-register_toolchains("//tools/test:all")
+register_toolchains(
+    "//tools/launcher:all",
+    "//tools/test:all",
+)

src/conditions/BUILD

@@ -220,12 +220,6 @@ config_setting(
     visibility = ["//visibility:public"],
 )
 
-config_setting(
-    name = "remote",
-    values = {"define": "EXECUTOR=remote"},
-    visibility = ["//visibility:public"],
-)
-
 config_setting(
     name = "debian_build",
     values = {

src/conditions/BUILD.tools

@@ -164,6 +164,7 @@ alias(
 
 config_setting(
     name = "remote",
+    deprecation = "No longer used by Bazel and may be removed in the future. Migrate to toolchains or define your own version of this setting.",
     values = {"define": "EXECUTOR=remote"},
     visibility = ["//visibility:public"],
 )

src/test/py/bazel/py_test.py

@@ -165,7 +165,6 @@ def _RunRemoteBazel(self, args):
         '--strategy=Javac=remote',
         '--strategy=Closure=remote',
         '--genrule_strategy=remote',
-        '--define=EXECUTOR=remote',
         '--remote_executor=grpc://localhost:' + str(self._worker_port),
         '--remote_cache=grpc://localhost:' + str(self._worker_port),
         '--remote_timeout=3600',

src/test/py/bazel/windows_remote_test.py

@@ -30,7 +30,6 @@ def _RunRemoteBazel(self, args, env_remove=None, env_add=None):
             '--strategy=Javac=remote',
             '--strategy=Closure=remote',
             '--genrule_strategy=remote',
-            '--define=EXECUTOR=remote',
             '--remote_executor=grpc://localhost:' + str(self._worker_port),
             '--remote_cache=grpc://localhost:' + str(self._worker_port),
             '--remote_timeout=3600',

src/test/shell/bazel/bazel_java_test.sh

@@ -1582,8 +1582,7 @@ EOF
 function test_build_hello_world_with_remote_embedded_tool_targets() {
   write_hello_library_files
 
-  bazel build //java/main:main_deploy.jar --define EXECUTOR=remote \
-    &> $TEST_log || fail "build failed"
+  bazel build //java/main:main_deploy.jar &> $TEST_log || fail "build failed"
 }
 
 

tools/BUILD.tools

@@ -1,3 +1,4 @@
+load("@platforms//host:constraints.bzl", "HOST_CONSTRAINTS")
 load(":build_defs.bzl", "BZLMOD_ENABLED")
 
 package(default_visibility = ["//visibility:public"])
@@ -13,6 +14,12 @@ platform(
     visibility = ["//visibility:private"],
 )
 
+config_setting(
+    name = "matches_host_constraints",
+    constraint_values = HOST_CONSTRAINTS,
+    visibility = ["//tools:__subpackages__"],
+)
+
 # All bzl files in the built in repo '@bazel_tools'.
 filegroup(
     name = "bzl_srcs",

tools/build_defs.bzl

@@ -14,6 +14,10 @@
 
 """Utility for compiling at Java 8."""
 
+load("@platforms//host:constraints.bzl", "HOST_CONSTRAINTS")
+
+visibility("//tools/...")
+
 _java_language_version_8_transition = transition(
     implementation = lambda settings, attr: {
         "//command_line_option:java_language_version": "8",
@@ -48,3 +52,57 @@ def transition_java_language_8_filegroup(name, files, visibility):
     )
 
 BZLMOD_ENABLED = str(Label("@bazel_tools//:foo")).startswith("@@")
+
+IS_HOST_WINDOWS = Label("@platforms//os:windows") in [Label(l) for l in HOST_CONSTRAINTS]
+
+def _single_binary_toolchain_rule_impl(ctx):
+    return platform_common.ToolchainInfo(
+        binary = ctx.attr.binary,
+    )
+
+_single_binary_toolchain_rule = rule(
+    implementation = _single_binary_toolchain_rule_impl,
+    attrs = {
+        "binary": attr.label(allow_single_file = True),
+    },
+)
+
+def single_binary_toolchain(
+        *,
+        name,
+        toolchain_type,
+        binary = None,
+        target_compatible_with = [],
+        exec_compatible_with = []):
+    """Declares a toolchain together with its implementation for an optional single binary."""
+    impl_name = name + "_impl"
+
+    _single_binary_toolchain_rule(
+        name = impl_name,
+        binary = binary,
+        # Avoid eager loading of the binary, which may come from a remote
+        # repository, in wildcard builds.
+        tags = ["manual"],
+        visibility = ["//visibility:private"],
+    )
+
+    native.toolchain(
+        name = name,
+        toolchain_type = toolchain_type,
+        toolchain = ":" + impl_name,
+        target_compatible_with = target_compatible_with,
+        exec_compatible_with = exec_compatible_with,
+        visibility = ["//visibility:private"],
+    )
+
+def _current_toolchain_base_impl(ctx, *, toolchain_type):
+    return DefaultInfo(files = depset([ctx.toolchains[toolchain_type].binary]))
+
+def _make_current_toolchain_rule(toolchain_type):
+    return rule(
+        implementation = lambda ctx: _current_toolchain_base_impl(ctx, toolchain_type = toolchain_type),
+        toolchains = [toolchain_type],
+    )
+
+current_launcher_binary = _make_current_toolchain_rule("//tools/launcher:launcher_toolchain_type")
+current_launcher_maker_binary = _make_current_toolchain_rule("//tools/launcher:launcher_maker_toolchain_type")

tools/def_parser/BUILD.tools

@@ -1,19 +1,20 @@
-package(default_visibility = ["//visibility:public"])
+load("//tools:build_defs.bzl", "IS_HOST_WINDOWS")
 
-filegroup(
-    name = "def_parser_windows",
-    srcs = select({
-        "//src/conditions:remote": ["//third_party/def_parser:def_parser"],
-        "//conditions:default": ["def_parser.exe"],
-    }),
-)
+package(default_visibility = ["//visibility:public"])
 
+# This should use a toolchain setup like the one for //tools/launcher, but that
+# doesn't provide a good way to bootstrap the def_parser from source build and
+# targets such as `--malloc`, which must not depend on def_parser. Instead,
+# the cc_* rules use a computed default and exclude tags. Since def_parser is
+# only used when targeting Windows and itself only runs on Windows, we only
+# match on the target platform here (which is the exec platform after the exec
+# transition applied by the implicit dep edge from cc_* rules).
+# TODO: Consider improving the situation by wrapping the targets with exclusions
+#  with transitions.
 filegroup(
     name = "def_parser",
     srcs = select({
-        "//src/conditions:host_windows": ["def_parser_windows"],
-        "//conditions:default": [
-            "no_op.bat",
-        ],
+        "@platforms//os:windows": ["def_parser.exe"] if IS_HOST_WINDOWS else ["//third_party/def_parser:def_parser"],
+        "//conditions:default": ["no_op.bat"],
     }),
 )

tools/launcher/BUILD.tools

@@ -1,37 +1,73 @@
+load("@platforms//host:constraints.bzl", "HOST_CONSTRAINTS")
+load(
+    "//tools:build_defs.bzl",
+    "IS_HOST_WINDOWS",
+    "current_launcher_binary",
+    "current_launcher_maker_binary",
+    "single_binary_toolchain",
+)
+
 package(default_visibility = ["//visibility:public"])
 
-filegroup(
-    name = "launcher_windows",
-    srcs = select({
-        "//src/conditions:remote": ["//src/tools/launcher:launcher"],
-        "//conditions:default": ["launcher.exe"],
-    }),
-)
-
-filegroup(
-    name = "launcher",
-    srcs = select({
-        "//src/conditions:host_windows": [":launcher_windows"],
-        "//conditions:default": [
-            "//src/tools/launcher:launcher",
-        ],
-    }),
-)
-
-filegroup(
-    name = "launcher_maker",
-    srcs = select({
-        "//src/conditions:host_windows": [":launcher_maker_windows"],
-        "//conditions:default": [
-            "//src/tools/launcher:launcher_maker",
-        ],
-    }),
-)
-
-filegroup(
-    name = "launcher_maker_windows",
-    srcs = select({
-        "//src/conditions:remote": ["//src/tools/launcher:launcher_maker"],
-        "//conditions:default": ["launcher_maker.exe"],
-    }),
+current_launcher_binary(name = "launcher")
+
+current_launcher_maker_binary(name = "launcher_maker")
+
+# WARNING: These toolchain types and their associated toolchains only exist for
+# the purposes of rulesets formerly included in Bazel itself and may change or
+# be removed at any time.
+
+toolchain_type(
+    name = "launcher_toolchain_type",
+    visibility = ["//visibility:private"],
+)
+
+toolchain_type(
+    name = "launcher_maker_toolchain_type",
+    visibility = ["//visibility:private"],
+)
+
+# Toolchains are prefixed with a number to ensure that their order of definition
+# matches their precedence in the toolchain resolution process when registered
+# with a wildcard pattern (which sorts by name).
+# TODO(#19587): Make all prebuilt binaries available in external repos and add
+#  toolchains for them below so that cross-platform builds can use them without
+#  needing to build from source.
+IS_HOST_WINDOWS and single_binary_toolchain(
+    name = "1_prebuilt_launcher",
+    binary = "launcher.exe",
+    target_compatible_with = HOST_CONSTRAINTS,
+    toolchain_type = ":launcher_toolchain_type",
+)
+
+single_binary_toolchain(
+    name = "2_source_launcher_toolchain",
+    binary = "//src/tools/launcher",
+    target_compatible_with = ["@platforms//os:windows"],
+    toolchain_type = ":launcher_toolchain_type",
+)
+
+single_binary_toolchain(
+    name = "3_no_launcher_toolchain",
+    toolchain_type = ":launcher_toolchain_type",
+)
+
+IS_HOST_WINDOWS and single_binary_toolchain(
+    name = "1_prebuilt_launcher_maker",
+    binary = "launcher_maker.exe",
+    exec_compatible_with = HOST_CONSTRAINTS,
+    target_compatible_with = ["@platforms//os:windows"],
+    toolchain_type = ":launcher_maker_toolchain_type",
+)
+
+single_binary_toolchain(
+    name = "2_source_launcher_maker_toolchain",
+    binary = "//src/tools/launcher:launcher_maker",
+    target_compatible_with = ["@platforms//os:windows"],
+    toolchain_type = ":launcher_maker_toolchain_type",
+)
+
+single_binary_toolchain(
+    name = "3_no_launcher_maker_toolchain",
+    toolchain_type = ":launcher_maker_toolchain_type",
 )

tools/zip/BUILD.tools

@@ -3,8 +3,8 @@ package(default_visibility = ["//visibility:public"])
 filegroup(
     name = "zipper",
     srcs = select({
-        "//src/conditions:remote": ["//third_party/ijar:zipper"],
-        "//conditions:default": glob(["zipper/*"]),
+        "//tools:matches_host_constraints": glob(["zipper/*"]),
+        "//conditions:default": ["//third_party/ijar:zipper"],
     }),
 )