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` (and `RunfilesGroupMetadataInfo`) 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,
  * first-party `java_library` code, the binary's own jars, and the executable
    at the executable tier.

Libraries propagate fine-grained per-target groups up through their
dependents; 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.
`java_import` gains a `runfiles_weight` attribute so dependency-management
rulesets can hint at relative sizes to guide those merge decisions.

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.0.1")
 bazel_dep(name = "protobuf", version = "32.1", repo_name = "com_google_protobuf")
 bazel_dep(name = "zlib", version = "1.3.1.bcr.5")
 

WORKSPACE

@@ -39,9 +39,9 @@ http_archive(
 
 http_archive(
     name = "bazel_features",
-    sha256 = "a660027f5a87f13224ab54b8dc6e191693c554f2692fcca46e8e29ee7dabc43b",
-    strip_prefix = "bazel_features-1.30.0",
-    url = "https://github.com/bazel-contrib/bazel_features/releases/download/v1.30.0/bazel_features-v1.30.0.tar.gz",
+    sha256 = "497a10560c07b0478026f49766ebdb6fd07b4fba9767db4f1c25cb6ab2fa1cdb",
+    strip_prefix = "bazel_features-1.46.0",
+    url = "https://github.com/bazel-contrib/bazel_features/releases/download/v1.46.0/bazel_features-v1.46.0.tar.gz",
 )
 
 load("@bazel_features//:deps.bzl", "bazel_features_deps")

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:
@@ -41,9 +42,9 @@ http_archive(
 
 http_archive(
     name = "bazel_features",
-    sha256 = "a660027f5a87f13224ab54b8dc6e191693c554f2692fcca46e8e29ee7dabc43b",
-    strip_prefix = "bazel_features-1.30.0",
-    url = "https://github.com/bazel-contrib/bazel_features/releases/download/v1.30.0/bazel_features-v1.30.0.tar.gz",
+    sha256 = "497a10560c07b0478026f49766ebdb6fd07b4fba9767db4f1c25cb6ab2fa1cdb",
+    strip_prefix = "bazel_features-1.46.0",
+    url = "https://github.com/bazel-contrib/bazel_features/releases/download/v1.46.0/bazel_features-v1.46.0.tar.gz",
 )
 
 load("@bazel_features//:deps.bzl", "bazel_features_deps")

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", "lib")
+load("@rules_runfiles_group//runfiles_group:providers.bzl", "RunfilesGroupInfo", "RunfilesGroupMetadataInfo")
 load("//java/common:java_semantics.bzl", "semantics")
 load(
     "//java/common/rules:android_lint.bzl",
@@ -100,9 +102,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 +118,8 @@ def bazel_base_binary_impl(ctx, is_test_rule_class):
         executable = default_info.executable,
     )
 
+    _add_runfiles_group_providers(providers, ctx, java_attrs, executable, toolchain_files, test_support)
+
     info = providers.pop("InternalDeployJarInfo")
     create_deploy_archives(
         ctx,
@@ -128,6 +134,34 @@ def bazel_base_binary_impl(ctx, is_test_rule_class):
 
     return providers.values()
 
+def _add_runfiles_group_providers(providers, ctx, java_attrs, executable, toolchain_files, test_support):
+    all_deps = list(ctx.attr.deps) + list(ctx.attr.runtime_deps)
+    if test_support:
+        all_deps.append(test_support)
+    dep_collected = lib.collect_groups(ctx, all_deps)
+    data_collected = lib.collect_groups(ctx, ctx.attr.data) if hasattr(ctx.attr, "data") else struct(groups = {}, metadata = None)
+
+    groups = {}
+    groups.update(dep_collected.groups)
+    groups.update(data_collected.groups)
+
+    own_group_name = str(ctx.label)
+    groups[own_group_name] = ctx.runfiles(transitive_files = java_attrs.runtime_jars)
+
+    groups["rules_java#java_runtime"] = ctx.runfiles(transitive_files = toolchain_files)
+
+    groups["rules_java#binary"] = ctx.runfiles(files = [executable] if executable else [])
+
+    own_metadata = RunfilesGroupMetadataInfo(groups = {
+        "rules_java#java_runtime": lib.group_metadata(rank = lib.RANK_FOUNDATION, do_not_merge = True, merge_affinity = "rules_java"),
+        own_group_name: lib.group_metadata(rank = lib.RANK_EXECUTABLE, merge_affinity = "rules_java"),
+        "rules_java#binary": lib.group_metadata(rank = lib.RANK_EXECUTABLE, executable_group = True, merge_affinity = "rules_java"),
+    })
+    metadata = lib.merge_metadata(dep_collected.metadata, data_collected.metadata, own_metadata)
+
+    providers["RunfilesGroupInfo"] = RunfilesGroupInfo(**groups)
+    providers["RunfilesGroupMetadataInfo"] = metadata
+
 def _get_coverage_runner(ctx):
     if ctx.configuration.coverage_enabled and ctx.attr.create_executable:
         toolchain = semantics.find_java_toolchain(ctx)

java/bazel/rules/bazel_java_import.bzl

@@ -33,6 +33,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(

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,6 +17,8 @@ Definition of java_import rule.
 """
 
 load("@rules_cc//cc/common:cc_info.bzl", "CcInfo")
+load("@rules_runfiles_group//runfiles_group:lib.bzl", "lib")
+load("@rules_runfiles_group//runfiles_group:providers.bzl", "RunfilesGroupInfo", "RunfilesGroupMetadataInfo")
 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")
@@ -85,7 +87,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 +106,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 RunfilesGroupMetadataInfo. If > 0, set as weight.
 
     Returns:
       (list[provider]) A list containing DefaultInfo, JavaInfo,
@@ -182,4 +186,24 @@ def bazel_java_import_rule(
             "_hidden_top_level_INTERNAL_": target["ProguardSpecProvider"].specs,
         }
     )
+
+    if not neverlink:
+        _add_runfiles_group_providers(target, ctx, collected_jars, deps, exports, runtime_deps, runfiles_weight = runfiles_weight)
+
     return target
+
+def _add_runfiles_group_providers(target, ctx, own_jars, deps, exports, runtime_deps, runfiles_weight = 0):
+    collected = lib.collect_groups(ctx, deps + exports + runtime_deps)
+
+    groups = dict(collected.groups)
+    own_group_name = str(ctx.label)
+    groups[own_group_name] = ctx.runfiles(files = own_jars)
+
+    own_weight = runfiles_weight if runfiles_weight > 0 else None
+    own_metadata = RunfilesGroupMetadataInfo(groups = {
+        own_group_name: lib.group_metadata(rank = lib.RANK_SHARED_DEPS, weight = own_weight, merge_affinity = "rules_java"),
+    })
+    metadata = lib.merge_metadata(collected.metadata, own_metadata)
+
+    target["RunfilesGroupInfo"] = RunfilesGroupInfo(**groups)
+    target["RunfilesGroupMetadataInfo"] = metadata

java/common/rules/impl/bazel_java_library_impl.bzl

@@ -16,6 +16,8 @@
 Definition of java_library rule.
 """
 
+load("@rules_runfiles_group//runfiles_group:lib.bzl", "lib")
+load("@rules_runfiles_group//runfiles_group:providers.bzl", "RunfilesGroupInfo", "RunfilesGroupMetadataInfo")
 load("//java/common/rules/impl:basic_java_library_impl.bzl", "basic_java_library", "construct_defaultinfo")
 
 # copybara: default visibility
@@ -98,4 +100,21 @@ def bazel_java_library_rule(
     )
     target["OutputGroupInfo"] = OutputGroupInfo(**base_info.output_groups)
 
+    if not neverlink:
+        _add_runfiles_group_providers(target, ctx, base_info.runfiles, deps, exports, runtime_deps)
+
     return target
+
+def _add_runfiles_group_providers(target, ctx, own_runfiles, deps, exports, runtime_deps):
+    collected = lib.collect_groups(ctx, deps + exports + runtime_deps)
+
+    groups = dict(collected.groups)
+    own_group_name = str(ctx.label)
+    groups[own_group_name] = ctx.runfiles(files = own_runfiles)
+    own_metadata = RunfilesGroupMetadataInfo(groups = {
+        own_group_name: lib.group_metadata(merge_affinity = "rules_java"),
+    })
+    metadata = lib.merge_metadata(collected.metadata, own_metadata)
+
+    target["RunfilesGroupInfo"] = RunfilesGroupInfo(**groups)
+    target["RunfilesGroupMetadataInfo"] = metadata

java/common/rules/java_import.bzl

@@ -124,5 +124,14 @@ This corresponds to the javac and JVM --add-opens= flags.
         """,
     ),
     "licenses": attr.license() if hasattr(attr, "license") else attr.string_list(),
+    "runfiles_weight": attr.int(
+        default = 0,
+        doc = """
+Weight hint for RunfilesGroupMetadataInfo. If set to a value greater than 0,
+this weight is attached to the target's runfiles group to help packaging rules
+make informed merge decisions. Intended to be set by dependency management
+rulesets (e.g. rules_jvm_external) using actual jar byte sizes.
+        """,
+    ),
     "_java_toolchain_type": attr.label(default = semantics.JAVA_TOOLCHAIN_TYPE),
 }