Support RunfilesGroupInfo

Teach the Java rules to describe their runfiles as named, ordered groups
so that downstream packaging rules can build more efficient artifacts.

`java_binary`, `java_test`, `java_library`, and `java_import` now return
`RunfilesGroupInfo` from the `rules_runfiles_group` ruleset alongside
`DefaultInfo`. Instead of seeing a single flat runfiles tree, a packaging rule
(e.g. a container-image or archive rule) can split a binary's runfiles into
layers and order them so that the content that changes least often lands in the
most cacheable layers:

  * the JDK / java_runtime at the foundation tier (never merged),
  * `java_import` targets (typically third-party jars) at the shared-deps tier,
  * `java_library` code, the binary's own jars, and the executable at the
    executable tier, marked `first_party` only for targets in the main
    repository -- plenty of Java code Bazel builds from source belongs to
    somebody else.

Libraries propagate fine-grained per-target groups up through their dependents
as a depset of group entries, each carrying its own metadata, so what a target
retains does not grow with the size of its closure. The binary collects them,
adds its own groups, and tags every group it produces with the `rules_java`
merge affinity so that JVM-shaped groups stay together when a packager has to
merge groups to fit a layer limit. A dependency that returns `JavaInfo` but no
`RunfilesGroupInfo` -- a custom rule, or `rules_jvm_external`'s `jvm_import` --
gets a synthesized group covering its transitive runtime jars and its default
runfiles, so a packager never silently loses its files. `java_import` gains a
`runfiles_weight` attribute so dependency-management rulesets can hint at
relative sizes to guide those merge decisions.

Emission is off by default and gated on the ruleset-wide
`--@rules_runfiles_group//runfiles_group:enabled` flag, so a build that packages
nothing pays nothing for the providers. Consumers that don't understand
`RunfilesGroupInfo` are unaffected and keep using
`DefaultInfo.default_runfiles`.

Adds a dependency on `rules_runfiles_group` for both Bzlmod and WORKSPACE
setups.

Author: malt3

MODULE.bazel

@@ -9,6 +9,7 @@ bazel_dep(name = "platforms", version = "0.0.11")
 bazel_dep(name = "rules_cc", version = "0.2.17")
 bazel_dep(name = "bazel_features", version = "1.30.0")
 bazel_dep(name = "bazel_skylib", version = "1.6.1")
+bazel_dep(name = "rules_runfiles_group", version = "0.1.0")
 bazel_dep(name = "protobuf", version = "32.1", repo_name = "com_google_protobuf")
 bazel_dep(name = "zlib", version = "1.3.1.bcr.5")
 

distro/relnotes.bzl

@@ -20,11 +20,12 @@ bazel_dep(name = "rules_java", version = "{VERSION}")
 
 **WORKSPACE setup**
 
-With Bazel 8.0.0 and before 8.3.0, add the following to your `.bazelrc` file:
+With Bazel 8.x, add the following to your `.bazelrc` file:
 
 ~~~
+# https://github.com/bazelbuild/bazel/issues/23043
 # https://github.com/bazelbuild/bazel/pull/26119
-common --repositories_without_autoloads=bazel_features_version,bazel_features_globals
+common --repositories_without_autoloads=rules_runfiles_group,bazel_features_version,bazel_features_globals
 ~~~
 
 In all cases, add the following to your `WORKSPACE` file:

java/bazel/rules/BUILD.bazel

@@ -36,6 +36,8 @@ bzl_library(
         "@bazel_skylib//lib:paths",
         "@rules_cc//cc:find_cc_toolchain_bzl",
         "@rules_cc//cc/common",
+        "@rules_runfiles_group//runfiles_group:lib",
+        "@rules_runfiles_group//runfiles_group:providers",
     ],
 )
 

java/bazel/rules/bazel_java_binary.bzl

@@ -16,6 +16,8 @@
 load("@bazel_features//:features.bzl", "bazel_features")
 load("@bazel_skylib//lib:paths.bzl", "paths")
 load("@rules_cc//cc:find_cc_toolchain.bzl", "use_cc_toolchain")
+load("@rules_runfiles_group//runfiles_group:lib.bzl", "runfiles_groups")
+load("@rules_runfiles_group//runfiles_group:providers.bzl", "RunfilesGroupInfo")
 load("//java/common:java_semantics.bzl", "semantics")
 load(
     "//java/common/rules:android_lint.bzl",
@@ -26,6 +28,16 @@ load("//java/common/rules:rule_util.bzl", "merge_attrs")
 load("//java/common/rules/impl:java_binary_deploy_jar.bzl", "create_deploy_archives")
 load("//java/common/rules/impl:java_binary_impl.bzl", "basic_java_binary", "binary_provider_helper")
 load("//java/common/rules/impl:java_helper.bzl", "helper")
+load(
+    "//java/common/rules/impl:runfiles_group_support.bzl",
+    "BINARY_GROUP",
+    "JAVA_RUNTIME_GROUP",
+    "MERGE_AFFINITY",
+    "RUNFILES_GROUP_ATTRS",
+    "collect_entries",
+    "own_kind",
+    "runfiles_groups_enabled",
+)
 load("//java/private:java_info.bzl", "JavaInfo")
 
 def _bazel_java_binary_impl(ctx):
@@ -100,9 +112,11 @@ def bazel_base_binary_impl(ctx, is_test_rule_class):
 
     runfiles = default_info.runfiles
 
+    toolchain_files = depset()
     if executable:
         runtime_toolchain = semantics.find_java_runtime_toolchain(ctx)
-        runfiles = runfiles.merge(ctx.runfiles(transitive_files = runtime_toolchain.files))
+        toolchain_files = runtime_toolchain.files
+        runfiles = runfiles.merge(ctx.runfiles(transitive_files = toolchain_files))
 
     test_support = helper.get_test_support(ctx)
     if test_support:
@@ -114,6 +128,8 @@ def bazel_base_binary_impl(ctx, is_test_rule_class):
         executable = default_info.executable,
     )
 
+    _add_runfiles_group_provider(providers, ctx, java_attrs, executable, toolchain_files, test_support)
+
     info = providers.pop("InternalDeployJarInfo")
     create_deploy_archives(
         ctx,
@@ -128,6 +144,52 @@ def bazel_base_binary_impl(ctx, is_test_rule_class):
 
     return providers.values()
 
+def _add_runfiles_group_provider(providers, ctx, java_attrs, executable, toolchain_files, test_support):
+    if not runfiles_groups_enabled(ctx):
+        return
+
+    own = [runfiles_groups.entry(
+        name = ctx.label,
+        content = java_attrs.runtime_jars,
+        kind = own_kind(ctx.label),
+        rank = runfiles_groups.RANK_EXECUTABLE,
+        merge_affinity = MERGE_AFFINITY,
+    )]
+
+    executable_group = None
+    if executable:
+        # toolchain_files is only populated for a target with an executable.
+        own.append(runfiles_groups.entry(
+            name = JAVA_RUNTIME_GROUP,
+            content = toolchain_files,
+            kind = "foundation",
+            rank = runfiles_groups.RANK_FOUNDATION,
+            do_not_merge = True,
+            merge_affinity = MERGE_AFFINITY,
+        ))
+        own.append(runfiles_groups.entry(
+            name = BINARY_GROUP,
+            content = depset([executable]),
+            kind = own_kind(ctx.label),
+            rank = runfiles_groups.RANK_EXECUTABLE,
+            merge_affinity = MERGE_AFFINITY,
+        ))
+        executable_group = BINARY_GROUP
+
+    deps = [ctx.attr.deps, ctx.attr.runtime_deps]
+    if test_support:
+        deps.append(test_support)
+
+    providers["RunfilesGroupInfo"] = RunfilesGroupInfo(
+        entries = collect_entries(
+            ctx,
+            deps = deps,
+            data = [getattr(ctx.attr, "data", [])],
+            own = own,
+        ),
+        executable_group = executable_group,
+    )
+
 def _get_coverage_runner(ctx):
     if ctx.configuration.coverage_enabled and ctx.attr.create_executable:
         toolchain = semantics.find_java_toolchain(ctx)
@@ -370,6 +432,7 @@ logic as the Java package of source files. For example, a source file at
             executable = True,
         ),
     } if not bazel_features.rules._has_launcher_maker_toolchain else {},
+    RUNFILES_GROUP_ATTRS,
 )
 
 def make_java_binary(executable):

java/bazel/rules/bazel_java_import.bzl

@@ -18,7 +18,9 @@ Definition of java_import rule.
 
 load("//java/common:java_semantics.bzl", "semantics")
 load("//java/common/rules:java_import.bzl", "JAVA_IMPORT_ATTRS")
+load("//java/common/rules:rule_util.bzl", "merge_attrs")
 load("//java/common/rules/impl:bazel_java_import_impl.bzl", "bazel_java_import_rule")
+load("//java/common/rules/impl:runfiles_group_support.bzl", "RUNFILES_GROUP_ATTRS")
 load("//java/private:java_info.bzl", "JavaInfo")
 
 def _proxy(ctx):
@@ -33,6 +35,7 @@ def _proxy(ctx):
         ctx.files.proguard_specs,
         ctx.attr.add_exports,
         ctx.attr.add_opens,
+        runfiles_weight = ctx.attr.runfiles_weight,
     ).values()
 
 java_import = rule(
@@ -59,7 +62,7 @@ java_import = rule(
 </code>
 </pre>
     """,
-    attrs = JAVA_IMPORT_ATTRS,
+    attrs = merge_attrs(JAVA_IMPORT_ATTRS, RUNFILES_GROUP_ATTRS),
     provides = [JavaInfo],
     fragments = ["java", "cpp"],
     toolchains = [semantics.JAVA_TOOLCHAIN],

java/bazel/rules/bazel_java_library.bzl

@@ -19,7 +19,9 @@ Definition of java_library rule.
 load("//java/common:java_semantics.bzl", "semantics")
 load("//java/common/rules:android_lint.bzl", "android_lint_subrule")
 load("//java/common/rules:java_library.bzl", "JAVA_LIBRARY_ATTRS")
+load("//java/common/rules:rule_util.bzl", "merge_attrs")
 load("//java/common/rules/impl:bazel_java_library_impl.bzl", "bazel_java_library_rule")
+load("//java/common/rules/impl:runfiles_group_support.bzl", "RUNFILES_GROUP_ATTRS")
 load("//java/private:java_info.bzl", "JavaInfo")
 
 def _proxy(ctx):
@@ -53,7 +55,7 @@ java_library = rule(
     jar").</li>
 </ul>
     """,
-    attrs = JAVA_LIBRARY_ATTRS,
+    attrs = merge_attrs(JAVA_LIBRARY_ATTRS, RUNFILES_GROUP_ATTRS),
     provides = [JavaInfo],
     outputs = {
         "classjar": "lib%{name}.jar",

java/common/rules/impl/BUILD

@@ -23,6 +23,8 @@ bzl_library(
         "//java/common:proguard_spec_info_bzl",
         "@com_google_protobuf//bazel/common:proto_info_bzl",
         "@rules_cc//cc/common:cc_helper_bzl",
+        "@rules_runfiles_group//runfiles_group:lib",
+        "@rules_runfiles_group//runfiles_group:providers",
     ],
 )
 

java/common/rules/impl/bazel_java_import_impl.bzl

@@ -17,9 +17,12 @@ Definition of java_import rule.
 """
 
 load("@rules_cc//cc/common:cc_info.bzl", "CcInfo")
+load("@rules_runfiles_group//runfiles_group:lib.bzl", "runfiles_groups")
+load("@rules_runfiles_group//runfiles_group:providers.bzl", "RunfilesGroupInfo")
 load("//java/common:java_semantics.bzl", "semantics")
 load("//java/common/rules/impl:basic_java_library_impl.bzl", "construct_defaultinfo")
 load("//java/common/rules/impl:import_deps_check.bzl", "import_deps_check")
+load("//java/common/rules/impl:runfiles_group_support.bzl", "MERGE_AFFINITY", "collect_entries", "runfiles_groups_enabled")
 load("//java/private:java_common.bzl", "java_common")
 load("//java/private:java_common_internal.bzl", _run_ijar_private_for_builtins = "run_ijar")
 load("//java/private:java_info.bzl", "JavaInfo")
@@ -85,7 +88,8 @@ def bazel_java_import_rule(
         add_exports = [],
         add_opens = [],
         permit_exports = True,
-        skip_incomplete_deps_check = True):
+        skip_incomplete_deps_check = True,
+        runfiles_weight = 0):
     """Implements java_import.
 
     This rule allows the use of precompiled .jar files as libraries in other Java rules.
@@ -103,6 +107,7 @@ def bazel_java_import_rule(
       add_opens: (list[str]) Allow this library to reflectively access the given <module>/<package>.
       permit_exports: (bool) Allow using exports
       skip_incomplete_deps_check: (bool) If this target is allowed to have incomplete deps
+      runfiles_weight: (int) Weight hint for the target's runfiles group entry. If > 0, set as weight.
 
     Returns:
       (list[provider]) A list containing DefaultInfo, JavaInfo,
@@ -182,4 +187,26 @@ def bazel_java_import_rule(
             "_hidden_top_level_INTERNAL_": target["ProguardSpecProvider"].specs,
         }
     )
+
+    if not neverlink:
+        _add_runfiles_group_provider(target, ctx, collected_jars, deps, exports, runtime_deps, runfiles_weight = runfiles_weight)
+
     return target
+
+def _add_runfiles_group_provider(target, ctx, own_jars, deps, exports, runtime_deps, runfiles_weight = 0):
+    if not runfiles_groups_enabled(ctx):
+        return
+
+    target["RunfilesGroupInfo"] = RunfilesGroupInfo(entries = collect_entries(
+        ctx,
+        deps = [deps, exports, runtime_deps],
+        data = [getattr(ctx.attr, "data", [])],
+        own = [runfiles_groups.entry(
+            name = ctx.label,
+            content = depset(own_jars),
+            kind = "third_party",
+            rank = runfiles_groups.RANK_SHARED_DEPS,
+            weight = runfiles_weight if runfiles_weight > 0 else None,
+            merge_affinity = MERGE_AFFINITY,
+        )],
+    ))

java/common/rules/impl/bazel_java_library_impl.bzl

@@ -16,7 +16,10 @@
 Definition of java_library rule.
 """
 
+load("@rules_runfiles_group//runfiles_group:lib.bzl", "runfiles_groups")
+load("@rules_runfiles_group//runfiles_group:providers.bzl", "RunfilesGroupInfo")
 load("//java/common/rules/impl:basic_java_library_impl.bzl", "basic_java_library", "construct_defaultinfo")
+load("//java/common/rules/impl:runfiles_group_support.bzl", "MERGE_AFFINITY", "collect_entries", "own_kind", "runfiles_groups_enabled")
 
 # copybara: default visibility
 
@@ -98,4 +101,23 @@ def bazel_java_library_rule(
     )
     target["OutputGroupInfo"] = OutputGroupInfo(**base_info.output_groups)
 
+    if not neverlink:
+        _add_runfiles_group_provider(target, ctx, base_info.runfiles, deps, exports, runtime_deps)
+
     return target
+
+def _add_runfiles_group_provider(target, ctx, own_runfiles, deps, exports, runtime_deps):
+    if not runfiles_groups_enabled(ctx):
+        return
+
+    target["RunfilesGroupInfo"] = RunfilesGroupInfo(entries = collect_entries(
+        ctx,
+        deps = [deps, exports, runtime_deps],
+        data = [getattr(ctx.attr, "data", [])],
+        own = [runfiles_groups.entry(
+            name = ctx.label,
+            content = depset(own_runfiles),
+            kind = own_kind(ctx.label),
+            merge_affinity = MERGE_AFFINITY,
+        )],
+    ))