From 18c1fb90daa120279c9e89f49878d9c46735a210 Mon Sep 17 00:00:00 2001 From: AgraVator Date: Tue, 18 Aug 2026 15:59:06 +0530 Subject: [PATCH 1/9] Adopt proto_lang_toolchain for java_grpc_library() --- .bazelrc | 2 +- compiler/BUILD.bazel | 8 ++++++-- java_grpc_library.bzl | 45 +++++++++++++++++++++++++++++++++++++++---- xds/BUILD.bazel | 8 ++++++-- 4 files changed, 54 insertions(+), 9 deletions(-) diff --git a/.bazelrc b/.bazelrc index 453acedb593..88d4fc627ac 100644 --- a/.bazelrc +++ b/.bazelrc @@ -1,3 +1,3 @@ build --cxxopt=-std=c++17 --host_cxxopt=-std=c++17 -common:skip_android --deleted_packages=android,binder \ No newline at end of file +common:skip_android --deleted_packages=android,binder diff --git a/compiler/BUILD.bazel b/compiler/BUILD.bazel index a9ffe77a55a..f3027821379 100644 --- a/compiler/BUILD.bazel +++ b/compiler/BUILD.bazel @@ -42,10 +42,14 @@ java_library( ], ) -java_rpc_toolchain( +load("@rules_proto//proto:defs.bzl", "proto_lang_toolchain") + +proto_lang_toolchain( name = "java_grpc_library_toolchain", + command_line = "--rpc-plugin_out=%s", plugin = "//compiler:grpc_java_plugin", - runtime = [":java_grpc_library_deps__do_not_reference"], + plugin_format_flag = "--plugin=protoc-gen-rpc-plugin=%s", + runtime = ":java_grpc_library_deps__do_not_reference", visibility = ["//visibility:public"], ) diff --git a/java_grpc_library.bzl b/java_grpc_library.bzl index e6afc028883..9e71c0ee01c 100644 --- a/java_grpc_library.bzl +++ b/java_grpc_library.bzl @@ -1,7 +1,7 @@ -"""Build rule for java_grpc_library.""" - load("@com_google_protobuf//bazel/common:proto_info.bzl", "ProtoInfo") +load("@com_google_protobuf//bazel/common:proto_lang_toolchain_info.bzl", "ProtoLangToolchainInfo") load("@rules_java//java:defs.bzl", "JavaInfo", "JavaPluginInfo", "java_common") +load("@rules_proto//proto:defs.bzl", "proto_common") _JavaRpcToolchainInfo = provider( fields = [ @@ -122,6 +122,41 @@ def _java_rpc_library_impl(ctx): return [java_info] +def _java_grpc_library_impl(ctx): + if len(ctx.attr.srcs) != 1: + fail("Exactly one src value supported", "srcs") + if ctx.attr.srcs[0].label.package != ctx.label.package: + print(("in srcs attribute of {0}: Proto source with label {1} should be in " + + "same package as consuming rule").format(ctx.label, ctx.attr.srcs[0].label)) + + toolchain = ctx.attr._toolchain[ProtoLangToolchainInfo] + srcs = ctx.attr.srcs[0][ProtoInfo] + + srcjar = ctx.actions.declare_file("%s-proto-gensrc.jar" % ctx.label.name) + + proto_common.compile( + actions = ctx.actions, + proto_info = srcs, + proto_lang_toolchain_info = toolchain, + generated_files = [srcjar], + plugin_output = srcjar.path, + ) + + deps_java_info = java_common.merge([dep[JavaInfo] for dep in ctx.attr.deps]) + + java_info = java_common.compile( + ctx, + java_toolchain = ctx.toolchains["@bazel_tools//tools/jdk:toolchain_type"].java, + source_jars = [srcjar], + output = ctx.outputs.jar, + output_source_jar = ctx.outputs.srcjar, + deps = [ + java_common.make_non_strict(deps_java_info), + ] + ([toolchain.runtime[JavaInfo]] if toolchain.runtime else []), + ) + + return [java_info] + _java_grpc_library = rule( attrs = { "srcs": attr.label_list( @@ -136,6 +171,7 @@ _java_grpc_library = rule( ), "_toolchain": attr.label( default = Label("//compiler:java_grpc_library_toolchain"), + providers = [ProtoLangToolchainInfo], ), }, toolchains = ["@bazel_tools//tools/jdk:toolchain_type"], @@ -145,7 +181,7 @@ _java_grpc_library = rule( "srcjar": "lib%{name}-src.jar", }, provides = [JavaInfo], - implementation = _java_rpc_library_impl, + implementation = _java_grpc_library_impl, ) # A copy of _java_grpc_library, except with a neverlink=1 _toolchain @@ -163,6 +199,7 @@ INTERNAL_java_grpc_library_for_xds = rule( ), "_toolchain": attr.label( default = Label("//xds:java_grpc_library_toolchain"), + providers = [ProtoLangToolchainInfo], ), }, toolchains = ["@bazel_tools//tools/jdk:toolchain_type"], @@ -172,7 +209,7 @@ INTERNAL_java_grpc_library_for_xds = rule( "srcjar": "lib%{name}-src.jar", }, provides = [JavaInfo], - implementation = _java_rpc_library_impl, + implementation = _java_grpc_library_impl, ) _java_lite_grpc_library = rule( diff --git a/xds/BUILD.bazel b/xds/BUILD.bazel index 47831c5139c..35ea6aaabf5 100644 --- a/xds/BUILD.bazel +++ b/xds/BUILD.bazel @@ -319,10 +319,14 @@ java_grpc_library( deps = [":xds_orca_java_proto"], ) -java_rpc_toolchain( +load("@rules_proto//proto:defs.bzl", "proto_lang_toolchain") + +proto_lang_toolchain( name = "java_grpc_library_toolchain", + command_line = "--rpc-plugin_out=%s", plugin = "//compiler:grpc_java_plugin", - runtime = [":java_grpc_library_deps"], + plugin_format_flag = "--plugin=protoc-gen-rpc-plugin=%s", + runtime = ":java_grpc_library_deps", ) java_library( From fa8710e1c194e1d701800ec0a701a275ca57981c Mon Sep 17 00:00:00 2001 From: AgraVator Date: Thu, 20 Aug 2026 12:29:18 +0530 Subject: [PATCH 2/9] Address PR feedback: remove dead toolchain code and format with buildifier --- compiler/BUILD.bazel | 11 ++-- java_grpc_library.bzl | 129 ++---------------------------------------- xds/BUILD.bazel | 5 +- 3 files changed, 13 insertions(+), 132 deletions(-) diff --git a/compiler/BUILD.bazel b/compiler/BUILD.bazel index f3027821379..b4953739033 100644 --- a/compiler/BUILD.bazel +++ b/compiler/BUILD.bazel @@ -1,7 +1,7 @@ load("@rules_cc//cc:defs.bzl", "cc_binary") load("@rules_java//java:defs.bzl", "java_library") load("@rules_jvm_external//:defs.bzl", "artifact") -load("//:java_grpc_library.bzl", "java_rpc_toolchain") +load("@rules_proto//proto:defs.bzl", "proto_lang_toolchain") # This should not generally be referenced. Users should use java_grpc_library cc_binary( @@ -42,8 +42,6 @@ java_library( ], ) -load("@rules_proto//proto:defs.bzl", "proto_lang_toolchain") - proto_lang_toolchain( name = "java_grpc_library_toolchain", command_line = "--rpc-plugin_out=%s", @@ -53,10 +51,11 @@ proto_lang_toolchain( visibility = ["//visibility:public"], ) -java_rpc_toolchain( +proto_lang_toolchain( name = "java_lite_grpc_library_toolchain", + command_line = "--rpc-plugin_out=lite:%s", plugin = "//compiler:grpc_java_plugin", - plugin_arg = "lite", - runtime = [":java_lite_grpc_library_deps__do_not_reference"], + plugin_format_flag = "--plugin=protoc-gen-rpc-plugin=%s", + runtime = ":java_lite_grpc_library_deps__do_not_reference", visibility = ["//visibility:public"], ) diff --git a/java_grpc_library.bzl b/java_grpc_library.bzl index 9e71c0ee01c..a6aaf2253c8 100644 --- a/java_grpc_library.bzl +++ b/java_grpc_library.bzl @@ -1,83 +1,10 @@ +"""Build rule for java_grpc_library.""" + load("@com_google_protobuf//bazel/common:proto_info.bzl", "ProtoInfo") load("@com_google_protobuf//bazel/common:proto_lang_toolchain_info.bzl", "ProtoLangToolchainInfo") -load("@rules_java//java:defs.bzl", "JavaInfo", "JavaPluginInfo", "java_common") +load("@rules_java//java:defs.bzl", "JavaInfo", "java_common") load("@rules_proto//proto:defs.bzl", "proto_common") -_JavaRpcToolchainInfo = provider( - fields = [ - "java_toolchain", - "java_plugins", - "plugin", - "plugin_arg", - "protoc", - "runtime", - ], -) - -def _java_rpc_toolchain_impl(ctx): - return [ - _JavaRpcToolchainInfo( - java_toolchain = ctx.attr._java_toolchain, - java_plugins = ctx.attr.java_plugins, - plugin = ctx.attr.plugin, - plugin_arg = ctx.attr.plugin_arg, - protoc = ctx.attr._protoc, - runtime = ctx.attr.runtime, - ), - platform_common.ToolchainInfo(), # Magic for b/78647825 - ] - -java_rpc_toolchain = rule( - attrs = { - # This attribute has a "magic" name recognized by the native DexArchiveAspect (b/78647825). - "runtime": attr.label_list( - cfg = "target", - providers = [JavaInfo], - ), - "plugin": attr.label( - cfg = "exec", - executable = True, - ), - "plugin_arg": attr.string(), - "_protoc": attr.label( - cfg = "exec", - default = Label("@com_google_protobuf//:protoc"), - executable = True, - ), - "java_plugins": attr.label_list( - default = [], - providers = [JavaPluginInfo], - ), - "_java_toolchain": attr.label( - default = Label("@bazel_tools//tools/jdk:current_java_toolchain"), - ), - }, - provides = [ - _JavaRpcToolchainInfo, - platform_common.ToolchainInfo, - ], - implementation = _java_rpc_toolchain_impl, -) - -# "repository" here is for Bazel builds that span multiple WORKSPACES. -def _path_ignoring_repository(f): - # Bazel creates a _virtual_imports directory in case the .proto source files - # need to be accessed at a path that's different from their source path: - # https://github.com/bazelbuild/bazel/blob/0.27.1/src/main/java/com/google/devtools/build/lib/rules/proto/ProtoCommon.java#L289 - # - # In that case, the import path of the .proto file is the path relative to - # the virtual imports directory of the rule in question. - virtual_imports = "/_virtual_imports/" - if virtual_imports in f.path: - return f.path.split(virtual_imports)[1].split("/", 1)[1] - elif len(f.owner.workspace_root) == 0: - # |f| is in the main repository - return f.short_path - else: - # If |f| is a generated file, it will have "bazel-out/*/genfiles" prefix - # before "external/workspace", so we need to add the starting index of "external/workspace" - return f.path[f.path.find(f.owner.workspace_root) + len(f.owner.workspace_root) + 1:] - def _java_rpc_library_impl(ctx): if len(ctx.attr.srcs) != 1: fail("Exactly one src value supported", "srcs") @@ -85,50 +12,6 @@ def _java_rpc_library_impl(ctx): print(("in srcs attribute of {0}: Proto source with label {1} should be in " + "same package as consuming rule").format(ctx.label, ctx.attr.srcs[0].label)) - toolchain = ctx.attr._toolchain[_JavaRpcToolchainInfo] - srcs = ctx.attr.srcs[0][ProtoInfo].direct_sources - descriptor_set_in = ctx.attr.srcs[0][ProtoInfo].transitive_descriptor_sets - - srcjar = ctx.actions.declare_file("%s-proto-gensrc.jar" % ctx.label.name) - - args = ctx.actions.args() - args.add(toolchain.plugin[DefaultInfo].files_to_run.executable, format = "--plugin=protoc-gen-rpc-plugin=%s") - args.add("--rpc-plugin_out={0}:{1}".format(toolchain.plugin_arg, srcjar.path)) - args.add_joined("--descriptor_set_in", descriptor_set_in, join_with = ctx.configuration.host_path_separator) - args.add_all(srcs, map_each = _path_ignoring_repository) - - ctx.actions.run( - inputs = depset(srcs, transitive = [descriptor_set_in, toolchain.plugin[DefaultInfo].files]), - outputs = [srcjar], - executable = toolchain.protoc[DefaultInfo].files_to_run, - arguments = [args], - use_default_shell_env = True, - toolchain = None, - ) - - deps_java_info = java_common.merge([dep[JavaInfo] for dep in ctx.attr.deps]) - - java_info = java_common.compile( - ctx, - java_toolchain = toolchain.java_toolchain[java_common.JavaToolchainInfo], - source_jars = [srcjar], - output = ctx.outputs.jar, - output_source_jar = ctx.outputs.srcjar, - plugins = [plugin[JavaPluginInfo] for plugin in toolchain.java_plugins], - deps = [ - java_common.make_non_strict(deps_java_info), - ] + [dep[JavaInfo] for dep in toolchain.runtime], - ) - - return [java_info] - -def _java_grpc_library_impl(ctx): - if len(ctx.attr.srcs) != 1: - fail("Exactly one src value supported", "srcs") - if ctx.attr.srcs[0].label.package != ctx.label.package: - print(("in srcs attribute of {0}: Proto source with label {1} should be in " + - "same package as consuming rule").format(ctx.label, ctx.attr.srcs[0].label)) - toolchain = ctx.attr._toolchain[ProtoLangToolchainInfo] srcs = ctx.attr.srcs[0][ProtoInfo] @@ -181,7 +64,7 @@ _java_grpc_library = rule( "srcjar": "lib%{name}-src.jar", }, provides = [JavaInfo], - implementation = _java_grpc_library_impl, + implementation = _java_rpc_library_impl, ) # A copy of _java_grpc_library, except with a neverlink=1 _toolchain @@ -209,7 +92,7 @@ INTERNAL_java_grpc_library_for_xds = rule( "srcjar": "lib%{name}-src.jar", }, provides = [JavaInfo], - implementation = _java_grpc_library_impl, + implementation = _java_rpc_library_impl, ) _java_lite_grpc_library = rule( @@ -224,9 +107,9 @@ _java_lite_grpc_library = rule( allow_empty = False, providers = [JavaInfo], ), - # This attribute has a "magic" name recognized by the native DexArchiveAspect (b/78647825). "_toolchain": attr.label( default = Label("//compiler:java_lite_grpc_library_toolchain"), + providers = [ProtoLangToolchainInfo], ), }, toolchains = ["@bazel_tools//tools/jdk:toolchain_type"], diff --git a/xds/BUILD.bazel b/xds/BUILD.bazel index 35ea6aaabf5..9899d822d88 100644 --- a/xds/BUILD.bazel +++ b/xds/BUILD.bazel @@ -3,7 +3,8 @@ load("@com_google_protobuf//bazel:java_proto_library.bzl", "java_proto_library") load("@com_google_protobuf//bazel:proto_library.bzl", "proto_library") load("@rules_java//java:defs.bzl", "java_binary", "java_library", "java_test") load("@rules_jvm_external//:defs.bzl", "artifact") -load("//:java_grpc_library.bzl", "INTERNAL_java_grpc_library_for_xds", "java_grpc_library", "java_rpc_toolchain") +load("@rules_proto//proto:defs.bzl", "proto_lang_toolchain") +load("//:java_grpc_library.bzl", "INTERNAL_java_grpc_library_for_xds", "java_grpc_library") # Mirrors the dependencies included in the artifact on Maven Central for usage # with maven_install's override_targets. Should only be used as a dep for @@ -319,8 +320,6 @@ java_grpc_library( deps = [":xds_orca_java_proto"], ) -load("@rules_proto//proto:defs.bzl", "proto_lang_toolchain") - proto_lang_toolchain( name = "java_grpc_library_toolchain", command_line = "--rpc-plugin_out=%s", From c42741952f569565bbfb3520e6347c48e99266c3 Mon Sep 17 00:00:00 2001 From: agrawalabhi Date: Tue, 1 Sep 2026 14:14:01 +0000 Subject: [PATCH 3/9] Address PR feedback for proto_lang_toolchain migration --- compiler/BUILD.bazel | 2 +- java_grpc_library.bzl | 164 +++++++++++++++++++++++++++++++++++------- xds/BUILD.bazel | 2 +- 3 files changed, 140 insertions(+), 28 deletions(-) diff --git a/compiler/BUILD.bazel b/compiler/BUILD.bazel index b4953739033..0f50d11514e 100644 --- a/compiler/BUILD.bazel +++ b/compiler/BUILD.bazel @@ -1,7 +1,7 @@ load("@rules_cc//cc:defs.bzl", "cc_binary") load("@rules_java//java:defs.bzl", "java_library") load("@rules_jvm_external//:defs.bzl", "artifact") -load("@rules_proto//proto:defs.bzl", "proto_lang_toolchain") +load("@com_google_protobuf//bazel/toolchains:proto_lang_toolchain.bzl", "proto_lang_toolchain") # This should not generally be referenced. Users should use java_grpc_library cc_binary( diff --git a/java_grpc_library.bzl b/java_grpc_library.bzl index a6aaf2253c8..7f5dec331eb 100644 --- a/java_grpc_library.bzl +++ b/java_grpc_library.bzl @@ -2,9 +2,84 @@ load("@com_google_protobuf//bazel/common:proto_info.bzl", "ProtoInfo") load("@com_google_protobuf//bazel/common:proto_lang_toolchain_info.bzl", "ProtoLangToolchainInfo") -load("@rules_java//java:defs.bzl", "JavaInfo", "java_common") +load("@rules_java//java:defs.bzl", "JavaInfo", "JavaPluginInfo", "java_common") load("@rules_proto//proto:defs.bzl", "proto_common") +_JavaRpcToolchainInfo = provider( + fields = [ + "java_toolchain", + "java_plugins", + "plugin", + "plugin_arg", + "protoc", + "runtime", + ], +) + +def _java_rpc_toolchain_impl(ctx): + return [ + _JavaRpcToolchainInfo( + java_toolchain = ctx.attr._java_toolchain, + java_plugins = ctx.attr.java_plugins, + plugin = ctx.attr.plugin, + plugin_arg = ctx.attr.plugin_arg, + protoc = ctx.attr._protoc, + runtime = ctx.attr.runtime, + ), + platform_common.ToolchainInfo(), # Magic for b/78647825 + ] + +java_rpc_toolchain = rule( + attrs = { + # This attribute has a "magic" name recognized by the native DexArchiveAspect (b/78647825). + "runtime": attr.label_list( + cfg = "target", + providers = [JavaInfo], + ), + "plugin": attr.label( + cfg = "exec", + executable = True, + ), + "plugin_arg": attr.string(), + "_protoc": attr.label( + cfg = "exec", + default = Label("@com_google_protobuf//:protoc"), + executable = True, + ), + "java_plugins": attr.label_list( + default = [], + providers = [JavaPluginInfo], + ), + "_java_toolchain": attr.label( + default = Label("@bazel_tools//tools/jdk:current_java_toolchain"), + ), + }, + provides = [ + _JavaRpcToolchainInfo, + platform_common.ToolchainInfo, + ], + implementation = _java_rpc_toolchain_impl, +) + +# "repository" here is for Bazel builds that span multiple WORKSPACES. +def _path_ignoring_repository(f): + # Bazel creates a _virtual_imports directory in case the .proto source files + # need to be accessed at a path that's different from their source path: + # https://github.com/bazelbuild/bazel/blob/0.27.1/src/main/java/com/google/devtools/build/lib/rules/proto/ProtoCommon.java#L289 + # + # In that case, the import path of the .proto file is the path relative to + # the virtual imports directory of the rule in question. + virtual_imports = "/_virtual_imports/" + if virtual_imports in f.path: + return f.path.split(virtual_imports)[1].split("/", 1)[1] + elif len(f.owner.workspace_root) == 0: + # |f| is in the main repository + return f.short_path + else: + # If |f| is a generated file, it will have "bazel-out/*/genfiles" prefix + # before "external/workspace", so we need to add the starting index of "external/workspace" + return f.path[f.path.find(f.owner.workspace_root) + len(f.owner.workspace_root) + 1:] + def _java_rpc_library_impl(ctx): if len(ctx.attr.srcs) != 1: fail("Exactly one src value supported", "srcs") @@ -12,33 +87,72 @@ def _java_rpc_library_impl(ctx): print(("in srcs attribute of {0}: Proto source with label {1} should be in " + "same package as consuming rule").format(ctx.label, ctx.attr.srcs[0].label)) - toolchain = ctx.attr._toolchain[ProtoLangToolchainInfo] - srcs = ctx.attr.srcs[0][ProtoInfo] + if ProtoLangToolchainInfo in ctx.attr._toolchain: + toolchain = ctx.attr._toolchain[ProtoLangToolchainInfo] + srcs = ctx.attr.srcs[0][ProtoInfo] - srcjar = ctx.actions.declare_file("%s-proto-gensrc.jar" % ctx.label.name) + srcjar = ctx.actions.declare_file("%s-proto-gensrc.jar" % ctx.label.name) + + proto_common.compile( + actions = ctx.actions, + proto_info = srcs, + proto_lang_toolchain_info = toolchain, + generated_files = [srcjar], + plugin_output = srcjar.path, + ) - proto_common.compile( - actions = ctx.actions, - proto_info = srcs, - proto_lang_toolchain_info = toolchain, - generated_files = [srcjar], - plugin_output = srcjar.path, - ) + deps_java_info = java_common.merge([dep[JavaInfo] for dep in ctx.attr.deps]) - deps_java_info = java_common.merge([dep[JavaInfo] for dep in ctx.attr.deps]) + java_info = java_common.compile( + ctx, + java_toolchain = ctx.toolchains["@bazel_tools//tools/jdk:toolchain_type"].java, + source_jars = [srcjar], + output = ctx.outputs.jar, + output_source_jar = ctx.outputs.srcjar, + deps = [ + java_common.make_non_strict(deps_java_info), + ] + ([toolchain.runtime[JavaInfo]] if toolchain.runtime else []), + ) + + return [java_info] + else: + # Legacy support for java_rpc_toolchain + toolchain = ctx.attr._toolchain[_JavaRpcToolchainInfo] + srcs = ctx.attr.srcs[0][ProtoInfo].direct_sources + descriptor_set_in = ctx.attr.srcs[0][ProtoInfo].transitive_descriptor_sets - java_info = java_common.compile( - ctx, - java_toolchain = ctx.toolchains["@bazel_tools//tools/jdk:toolchain_type"].java, - source_jars = [srcjar], - output = ctx.outputs.jar, - output_source_jar = ctx.outputs.srcjar, - deps = [ - java_common.make_non_strict(deps_java_info), - ] + ([toolchain.runtime[JavaInfo]] if toolchain.runtime else []), - ) + srcjar = ctx.actions.declare_file("%s-proto-gensrc.jar" % ctx.label.name) + + args = ctx.actions.args() + args.add(toolchain.plugin[DefaultInfo].files_to_run.executable, format = "--plugin=protoc-gen-rpc-plugin=%s") + args.add("--rpc-plugin_out={0}:{1}".format(toolchain.plugin_arg, srcjar.path)) + args.add_joined("--descriptor_set_in", descriptor_set_in, join_with = ctx.configuration.host_path_separator) + args.add_all(srcs, map_each = _path_ignoring_repository) + + ctx.actions.run( + inputs = depset(srcs, transitive = [descriptor_set_in, toolchain.plugin[DefaultInfo].files]), + outputs = [srcjar], + executable = toolchain.protoc[DefaultInfo].files_to_run, + arguments = [args], + use_default_shell_env = True, + toolchain = None, + ) + + deps_java_info = java_common.merge([dep[JavaInfo] for dep in ctx.attr.deps]) + + java_info = java_common.compile( + ctx, + java_toolchain = toolchain.java_toolchain[java_common.JavaToolchainInfo], + source_jars = [srcjar], + output = ctx.outputs.jar, + output_source_jar = ctx.outputs.srcjar, + plugins = [plugin[JavaPluginInfo] for plugin in toolchain.java_plugins], + deps = [ + java_common.make_non_strict(deps_java_info), + ] + [dep[JavaInfo] for dep in toolchain.runtime], + ) - return [java_info] + return [java_info] _java_grpc_library = rule( attrs = { @@ -54,7 +168,6 @@ _java_grpc_library = rule( ), "_toolchain": attr.label( default = Label("//compiler:java_grpc_library_toolchain"), - providers = [ProtoLangToolchainInfo], ), }, toolchains = ["@bazel_tools//tools/jdk:toolchain_type"], @@ -82,7 +195,6 @@ INTERNAL_java_grpc_library_for_xds = rule( ), "_toolchain": attr.label( default = Label("//xds:java_grpc_library_toolchain"), - providers = [ProtoLangToolchainInfo], ), }, toolchains = ["@bazel_tools//tools/jdk:toolchain_type"], @@ -107,9 +219,9 @@ _java_lite_grpc_library = rule( allow_empty = False, providers = [JavaInfo], ), + # This attribute has a "magic" name recognized by the native DexArchiveAspect (b/78647825). "_toolchain": attr.label( default = Label("//compiler:java_lite_grpc_library_toolchain"), - providers = [ProtoLangToolchainInfo], ), }, toolchains = ["@bazel_tools//tools/jdk:toolchain_type"], diff --git a/xds/BUILD.bazel b/xds/BUILD.bazel index 9899d822d88..733cbbd657d 100644 --- a/xds/BUILD.bazel +++ b/xds/BUILD.bazel @@ -3,7 +3,7 @@ load("@com_google_protobuf//bazel:java_proto_library.bzl", "java_proto_library") load("@com_google_protobuf//bazel:proto_library.bzl", "proto_library") load("@rules_java//java:defs.bzl", "java_binary", "java_library", "java_test") load("@rules_jvm_external//:defs.bzl", "artifact") -load("@rules_proto//proto:defs.bzl", "proto_lang_toolchain") +load("@com_google_protobuf//bazel/toolchains:proto_lang_toolchain.bzl", "proto_lang_toolchain") load("//:java_grpc_library.bzl", "INTERNAL_java_grpc_library_for_xds", "java_grpc_library") # Mirrors the dependencies included in the artifact on Maven Central for usage From 091d318961dbb3bf0be0ce564b64e9b9f9caf08b Mon Sep 17 00:00:00 2001 From: agrawalabhi Date: Tue, 1 Sep 2026 14:51:51 +0000 Subject: [PATCH 4/9] Load proto_common from @com_google_protobuf instead of @rules_proto --- java_grpc_library.bzl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/java_grpc_library.bzl b/java_grpc_library.bzl index 7f5dec331eb..0e14703b226 100644 --- a/java_grpc_library.bzl +++ b/java_grpc_library.bzl @@ -1,9 +1,9 @@ """Build rule for java_grpc_library.""" +load("@com_google_protobuf//bazel/common:proto_common.bzl", "proto_common") load("@com_google_protobuf//bazel/common:proto_info.bzl", "ProtoInfo") load("@com_google_protobuf//bazel/common:proto_lang_toolchain_info.bzl", "ProtoLangToolchainInfo") load("@rules_java//java:defs.bzl", "JavaInfo", "JavaPluginInfo", "java_common") -load("@rules_proto//proto:defs.bzl", "proto_common") _JavaRpcToolchainInfo = provider( fields = [ From cc9151d2fe21c8eff2084e3fcd40a086ca53f36f Mon Sep 17 00:00:00 2001 From: agrawalabhi Date: Wed, 2 Sep 2026 12:47:54 +0000 Subject: [PATCH 5/9] Format BUILD files with buildifier --- compiler/BUILD.bazel | 2 +- xds/BUILD.bazel | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/compiler/BUILD.bazel b/compiler/BUILD.bazel index 0f50d11514e..b3a10ca4222 100644 --- a/compiler/BUILD.bazel +++ b/compiler/BUILD.bazel @@ -1,7 +1,7 @@ +load("@com_google_protobuf//bazel/toolchains:proto_lang_toolchain.bzl", "proto_lang_toolchain") load("@rules_cc//cc:defs.bzl", "cc_binary") load("@rules_java//java:defs.bzl", "java_library") load("@rules_jvm_external//:defs.bzl", "artifact") -load("@com_google_protobuf//bazel/toolchains:proto_lang_toolchain.bzl", "proto_lang_toolchain") # This should not generally be referenced. Users should use java_grpc_library cc_binary( diff --git a/xds/BUILD.bazel b/xds/BUILD.bazel index 733cbbd657d..330bee3eeaa 100644 --- a/xds/BUILD.bazel +++ b/xds/BUILD.bazel @@ -1,9 +1,9 @@ load("@bazel_jar_jar//:jar_jar.bzl", "jar_jar") load("@com_google_protobuf//bazel:java_proto_library.bzl", "java_proto_library") load("@com_google_protobuf//bazel:proto_library.bzl", "proto_library") +load("@com_google_protobuf//bazel/toolchains:proto_lang_toolchain.bzl", "proto_lang_toolchain") load("@rules_java//java:defs.bzl", "java_binary", "java_library", "java_test") load("@rules_jvm_external//:defs.bzl", "artifact") -load("@com_google_protobuf//bazel/toolchains:proto_lang_toolchain.bzl", "proto_lang_toolchain") load("//:java_grpc_library.bzl", "INTERNAL_java_grpc_library_for_xds", "java_grpc_library") # Mirrors the dependencies included in the artifact on Maven Central for usage From 00f4e704a6f03054f71b9e2f9fa6dfd6ea6f507b Mon Sep 17 00:00:00 2001 From: agrawalabhi Date: Wed, 2 Sep 2026 13:10:31 +0000 Subject: [PATCH 6/9] Deduplicate common compilation logic in _java_rpc_library_impl --- java_grpc_library.bzl | 57 +++++++++++++++++-------------------------- 1 file changed, 22 insertions(+), 35 deletions(-) diff --git a/java_grpc_library.bzl b/java_grpc_library.bzl index 0e14703b226..b6d5bf9ed63 100644 --- a/java_grpc_library.bzl +++ b/java_grpc_library.bzl @@ -87,42 +87,26 @@ def _java_rpc_library_impl(ctx): print(("in srcs attribute of {0}: Proto source with label {1} should be in " + "same package as consuming rule").format(ctx.label, ctx.attr.srcs[0].label)) + srcjar = ctx.actions.declare_file("%s-proto-gensrc.jar" % ctx.label.name) + if ProtoLangToolchainInfo in ctx.attr._toolchain: toolchain = ctx.attr._toolchain[ProtoLangToolchainInfo] - srcs = ctx.attr.srcs[0][ProtoInfo] - - srcjar = ctx.actions.declare_file("%s-proto-gensrc.jar" % ctx.label.name) - proto_common.compile( actions = ctx.actions, - proto_info = srcs, + proto_info = ctx.attr.srcs[0][ProtoInfo], proto_lang_toolchain_info = toolchain, generated_files = [srcjar], plugin_output = srcjar.path, ) - - deps_java_info = java_common.merge([dep[JavaInfo] for dep in ctx.attr.deps]) - - java_info = java_common.compile( - ctx, - java_toolchain = ctx.toolchains["@bazel_tools//tools/jdk:toolchain_type"].java, - source_jars = [srcjar], - output = ctx.outputs.jar, - output_source_jar = ctx.outputs.srcjar, - deps = [ - java_common.make_non_strict(deps_java_info), - ] + ([toolchain.runtime[JavaInfo]] if toolchain.runtime else []), - ) - - return [java_info] + java_toolchain = ctx.toolchains["@bazel_tools//tools/jdk:toolchain_type"].java + java_plugins = [] + runtime_deps = [toolchain.runtime[JavaInfo]] if toolchain.runtime else [] else: # Legacy support for java_rpc_toolchain toolchain = ctx.attr._toolchain[_JavaRpcToolchainInfo] srcs = ctx.attr.srcs[0][ProtoInfo].direct_sources descriptor_set_in = ctx.attr.srcs[0][ProtoInfo].transitive_descriptor_sets - srcjar = ctx.actions.declare_file("%s-proto-gensrc.jar" % ctx.label.name) - args = ctx.actions.args() args.add(toolchain.plugin[DefaultInfo].files_to_run.executable, format = "--plugin=protoc-gen-rpc-plugin=%s") args.add("--rpc-plugin_out={0}:{1}".format(toolchain.plugin_arg, srcjar.path)) @@ -137,22 +121,25 @@ def _java_rpc_library_impl(ctx): use_default_shell_env = True, toolchain = None, ) + java_toolchain = toolchain.java_toolchain[java_common.JavaToolchainInfo] + java_plugins = [plugin[JavaPluginInfo] for plugin in toolchain.java_plugins] + runtime_deps = [dep[JavaInfo] for dep in toolchain.runtime] - deps_java_info = java_common.merge([dep[JavaInfo] for dep in ctx.attr.deps]) + deps_java_info = java_common.merge([dep[JavaInfo] for dep in ctx.attr.deps]) - java_info = java_common.compile( - ctx, - java_toolchain = toolchain.java_toolchain[java_common.JavaToolchainInfo], - source_jars = [srcjar], - output = ctx.outputs.jar, - output_source_jar = ctx.outputs.srcjar, - plugins = [plugin[JavaPluginInfo] for plugin in toolchain.java_plugins], - deps = [ - java_common.make_non_strict(deps_java_info), - ] + [dep[JavaInfo] for dep in toolchain.runtime], - ) + java_info = java_common.compile( + ctx, + java_toolchain = java_toolchain, + source_jars = [srcjar], + output = ctx.outputs.jar, + output_source_jar = ctx.outputs.srcjar, + plugins = java_plugins, + deps = [ + java_common.make_non_strict(deps_java_info), + ] + runtime_deps, + ) - return [java_info] + return [java_info] _java_grpc_library = rule( attrs = { From 2dea7c1dd3e84f02ad5f3a5cd106bb29aafd1033 Mon Sep 17 00:00:00 2001 From: agrawalabhi Date: Tue, 15 Sep 2026 12:31:37 +0000 Subject: [PATCH 7/9] bazel: use output_files = 'single' and $(OUT) in proto_lang_toolchain --- compiler/BUILD.bazel | 6 ++++-- java_grpc_library.bzl | 1 - xds/BUILD.bazel | 3 ++- 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/compiler/BUILD.bazel b/compiler/BUILD.bazel index b3a10ca4222..ef73da11578 100644 --- a/compiler/BUILD.bazel +++ b/compiler/BUILD.bazel @@ -44,7 +44,8 @@ java_library( proto_lang_toolchain( name = "java_grpc_library_toolchain", - command_line = "--rpc-plugin_out=%s", + command_line = "--rpc-plugin_out=$(OUT)", + output_files = "single", plugin = "//compiler:grpc_java_plugin", plugin_format_flag = "--plugin=protoc-gen-rpc-plugin=%s", runtime = ":java_grpc_library_deps__do_not_reference", @@ -53,7 +54,8 @@ proto_lang_toolchain( proto_lang_toolchain( name = "java_lite_grpc_library_toolchain", - command_line = "--rpc-plugin_out=lite:%s", + command_line = "--rpc-plugin_out=lite:$(OUT)", + output_files = "single", plugin = "//compiler:grpc_java_plugin", plugin_format_flag = "--plugin=protoc-gen-rpc-plugin=%s", runtime = ":java_lite_grpc_library_deps__do_not_reference", diff --git a/java_grpc_library.bzl b/java_grpc_library.bzl index b6d5bf9ed63..cf40ff3ae2f 100644 --- a/java_grpc_library.bzl +++ b/java_grpc_library.bzl @@ -96,7 +96,6 @@ def _java_rpc_library_impl(ctx): proto_info = ctx.attr.srcs[0][ProtoInfo], proto_lang_toolchain_info = toolchain, generated_files = [srcjar], - plugin_output = srcjar.path, ) java_toolchain = ctx.toolchains["@bazel_tools//tools/jdk:toolchain_type"].java java_plugins = [] diff --git a/xds/BUILD.bazel b/xds/BUILD.bazel index 330bee3eeaa..9b1bc24b5a3 100644 --- a/xds/BUILD.bazel +++ b/xds/BUILD.bazel @@ -322,7 +322,8 @@ java_grpc_library( proto_lang_toolchain( name = "java_grpc_library_toolchain", - command_line = "--rpc-plugin_out=%s", + command_line = "--rpc-plugin_out=$(OUT)", + output_files = "single", plugin = "//compiler:grpc_java_plugin", plugin_format_flag = "--plugin=protoc-gen-rpc-plugin=%s", runtime = ":java_grpc_library_deps", From 1eab117eea5d37235bff3b4b9e09073f416d1f7d Mon Sep 17 00:00:00 2001 From: agrawalabhi Date: Wed, 16 Sep 2026 10:49:03 +0000 Subject: [PATCH 8/9] bazel: remove dual toolchain code path from java_grpc_library Building a java_grpc_library happens in two phases: protoc generates Java sources, then those sources are compiled. The grpc-owned java_rpc_toolchain described both phases in a single object. proto_lang_toolchain is protobuf-owned and language-agnostic, so it can only describe the first one and has no place for java_plugins. Keeping java_plugins working was handled by branching on the toolchain's provider type and retaining the legacy implementation in the else arm. That left two protoc invocations with different behavior: the legacy one passes --descriptor_set_in, which has no SourceCodeInfo, so the comments from the .proto are dropped from the generated code. Whether comments survived, and whether java_plugins worked, both depended on which toolchain a target happened to reference, and the two could not be had at the same time. Split the configuration along the phase boundary instead. proto_lang_toolchain continues to describe the protoc invocation, and a new java_rpc_java_config rule describes the Java compilation that follows it. With the Java-specific settings no longer needing a home inside the toolchain, the legacy path and java_rpc_toolchain are no longer needed, and _path_ignoring_repository goes with them since proto_common.compile handles virtual imports itself. The toolchain attributes now declare the providers they require, so pointing one at the wrong kind of target fails during analysis rather than silently selecting different behavior. This removes java_rpc_toolchain, so callers setting java_plugins must migrate to proto_lang_toolchain plus java_rpc_java_config. --- compiler/BUILD.bazel | 11 ++++ java_grpc_library.bzl | 149 ++++++++++++++---------------------------- xds/BUILD.bazel | 6 +- 3 files changed, 65 insertions(+), 101 deletions(-) diff --git a/compiler/BUILD.bazel b/compiler/BUILD.bazel index ef73da11578..9aba56b7af2 100644 --- a/compiler/BUILD.bazel +++ b/compiler/BUILD.bazel @@ -2,6 +2,7 @@ load("@com_google_protobuf//bazel/toolchains:proto_lang_toolchain.bzl", "proto_l load("@rules_cc//cc:defs.bzl", "cc_binary") load("@rules_java//java:defs.bzl", "java_library") load("@rules_jvm_external//:defs.bzl", "artifact") +load("//:java_grpc_library.bzl", "java_rpc_java_config") # This should not generally be referenced. Users should use java_grpc_library cc_binary( @@ -61,3 +62,13 @@ proto_lang_toolchain( runtime = ":java_lite_grpc_library_deps__do_not_reference", visibility = ["//visibility:public"], ) + +java_rpc_java_config( + name = "java_grpc_library_java_config", + visibility = ["//visibility:public"], +) + +java_rpc_java_config( + name = "java_lite_grpc_library_java_config", + visibility = ["//visibility:public"], +) diff --git a/java_grpc_library.bzl b/java_grpc_library.bzl index cf40ff3ae2f..59dc13a32a0 100644 --- a/java_grpc_library.bzl +++ b/java_grpc_library.bzl @@ -5,81 +5,38 @@ load("@com_google_protobuf//bazel/common:proto_info.bzl", "ProtoInfo") load("@com_google_protobuf//bazel/common:proto_lang_toolchain_info.bzl", "ProtoLangToolchainInfo") load("@rules_java//java:defs.bzl", "JavaInfo", "JavaPluginInfo", "java_common") -_JavaRpcToolchainInfo = provider( - fields = [ - "java_toolchain", - "java_plugins", - "plugin", - "plugin_arg", - "protoc", - "runtime", - ], +# Building a java_grpc_library happens in two phases: protoc generates Java +# sources, then those sources are compiled. `proto_lang_toolchain` configures +# the first phase, but it is language-agnostic and so cannot express anything +# about the second. This provider carries that Java-specific configuration. +JavaRpcJavaConfigInfo = provider( + doc = "Java compilation settings for the sources protoc generates.", + fields = { + "java_plugins": "(list[Target]) JavaPluginInfo targets to run as " + + "annotation processors over the generated sources.", + }, ) -def _java_rpc_toolchain_impl(ctx): - return [ - _JavaRpcToolchainInfo( - java_toolchain = ctx.attr._java_toolchain, - java_plugins = ctx.attr.java_plugins, - plugin = ctx.attr.plugin, - plugin_arg = ctx.attr.plugin_arg, - protoc = ctx.attr._protoc, - runtime = ctx.attr.runtime, - ), - platform_common.ToolchainInfo(), # Magic for b/78647825 - ] +def _java_rpc_java_config_impl(ctx): + return [JavaRpcJavaConfigInfo(java_plugins = ctx.attr.java_plugins)] + +java_rpc_java_config = rule( + doc = """Java compilation settings to accompany a `proto_lang_toolchain`. -java_rpc_toolchain = rule( +A `java_grpc_library` runs protoc and then compiles the generated sources. +`proto_lang_toolchain` describes the protoc invocation; this rule describes the +Java compilation that follows it.""", attrs = { - # This attribute has a "magic" name recognized by the native DexArchiveAspect (b/78647825). - "runtime": attr.label_list( - cfg = "target", - providers = [JavaInfo], - ), - "plugin": attr.label( - cfg = "exec", - executable = True, - ), - "plugin_arg": attr.string(), - "_protoc": attr.label( - cfg = "exec", - default = Label("@com_google_protobuf//:protoc"), - executable = True, - ), "java_plugins": attr.label_list( default = [], providers = [JavaPluginInfo], - ), - "_java_toolchain": attr.label( - default = Label("@bazel_tools//tools/jdk:current_java_toolchain"), + doc = "Annotation processors to run over the generated sources.", ), }, - provides = [ - _JavaRpcToolchainInfo, - platform_common.ToolchainInfo, - ], - implementation = _java_rpc_toolchain_impl, + provides = [JavaRpcJavaConfigInfo], + implementation = _java_rpc_java_config_impl, ) -# "repository" here is for Bazel builds that span multiple WORKSPACES. -def _path_ignoring_repository(f): - # Bazel creates a _virtual_imports directory in case the .proto source files - # need to be accessed at a path that's different from their source path: - # https://github.com/bazelbuild/bazel/blob/0.27.1/src/main/java/com/google/devtools/build/lib/rules/proto/ProtoCommon.java#L289 - # - # In that case, the import path of the .proto file is the path relative to - # the virtual imports directory of the rule in question. - virtual_imports = "/_virtual_imports/" - if virtual_imports in f.path: - return f.path.split(virtual_imports)[1].split("/", 1)[1] - elif len(f.owner.workspace_root) == 0: - # |f| is in the main repository - return f.short_path - else: - # If |f| is a generated file, it will have "bazel-out/*/genfiles" prefix - # before "external/workspace", so we need to add the starting index of "external/workspace" - return f.path[f.path.find(f.owner.workspace_root) + len(f.owner.workspace_root) + 1:] - def _java_rpc_library_impl(ctx): if len(ctx.attr.srcs) != 1: fail("Exactly one src value supported", "srcs") @@ -87,52 +44,29 @@ def _java_rpc_library_impl(ctx): print(("in srcs attribute of {0}: Proto source with label {1} should be in " + "same package as consuming rule").format(ctx.label, ctx.attr.srcs[0].label)) + toolchain = ctx.attr._toolchain[ProtoLangToolchainInfo] srcjar = ctx.actions.declare_file("%s-proto-gensrc.jar" % ctx.label.name) - if ProtoLangToolchainInfo in ctx.attr._toolchain: - toolchain = ctx.attr._toolchain[ProtoLangToolchainInfo] - proto_common.compile( - actions = ctx.actions, - proto_info = ctx.attr.srcs[0][ProtoInfo], - proto_lang_toolchain_info = toolchain, - generated_files = [srcjar], - ) - java_toolchain = ctx.toolchains["@bazel_tools//tools/jdk:toolchain_type"].java - java_plugins = [] - runtime_deps = [toolchain.runtime[JavaInfo]] if toolchain.runtime else [] - else: - # Legacy support for java_rpc_toolchain - toolchain = ctx.attr._toolchain[_JavaRpcToolchainInfo] - srcs = ctx.attr.srcs[0][ProtoInfo].direct_sources - descriptor_set_in = ctx.attr.srcs[0][ProtoInfo].transitive_descriptor_sets - - args = ctx.actions.args() - args.add(toolchain.plugin[DefaultInfo].files_to_run.executable, format = "--plugin=protoc-gen-rpc-plugin=%s") - args.add("--rpc-plugin_out={0}:{1}".format(toolchain.plugin_arg, srcjar.path)) - args.add_joined("--descriptor_set_in", descriptor_set_in, join_with = ctx.configuration.host_path_separator) - args.add_all(srcs, map_each = _path_ignoring_repository) - - ctx.actions.run( - inputs = depset(srcs, transitive = [descriptor_set_in, toolchain.plugin[DefaultInfo].files]), - outputs = [srcjar], - executable = toolchain.protoc[DefaultInfo].files_to_run, - arguments = [args], - use_default_shell_env = True, - toolchain = None, - ) - java_toolchain = toolchain.java_toolchain[java_common.JavaToolchainInfo] - java_plugins = [plugin[JavaPluginInfo] for plugin in toolchain.java_plugins] - runtime_deps = [dep[JavaInfo] for dep in toolchain.runtime] + proto_common.compile( + actions = ctx.actions, + proto_info = ctx.attr.srcs[0][ProtoInfo], + proto_lang_toolchain_info = toolchain, + generated_files = [srcjar], + ) deps_java_info = java_common.merge([dep[JavaInfo] for dep in ctx.attr.deps]) + runtime_deps = [toolchain.runtime[JavaInfo]] if toolchain.runtime else [] java_info = java_common.compile( ctx, - java_toolchain = java_toolchain, + java_toolchain = ctx.toolchains["@bazel_tools//tools/jdk:toolchain_type"].java, source_jars = [srcjar], output = ctx.outputs.jar, output_source_jar = ctx.outputs.srcjar, - plugins = java_plugins, + plugins = [ + plugin[JavaPluginInfo] + for plugin in ctx.attr._java_config[JavaRpcJavaConfigInfo].java_plugins + ], deps = [ java_common.make_non_strict(deps_java_info), ] + runtime_deps, @@ -154,6 +88,11 @@ _java_grpc_library = rule( ), "_toolchain": attr.label( default = Label("//compiler:java_grpc_library_toolchain"), + providers = [ProtoLangToolchainInfo], + ), + "_java_config": attr.label( + default = Label("//compiler:java_grpc_library_java_config"), + providers = [JavaRpcJavaConfigInfo], ), }, toolchains = ["@bazel_tools//tools/jdk:toolchain_type"], @@ -181,6 +120,11 @@ INTERNAL_java_grpc_library_for_xds = rule( ), "_toolchain": attr.label( default = Label("//xds:java_grpc_library_toolchain"), + providers = [ProtoLangToolchainInfo], + ), + "_java_config": attr.label( + default = Label("//xds:java_grpc_library_java_config"), + providers = [JavaRpcJavaConfigInfo], ), }, toolchains = ["@bazel_tools//tools/jdk:toolchain_type"], @@ -208,6 +152,11 @@ _java_lite_grpc_library = rule( # This attribute has a "magic" name recognized by the native DexArchiveAspect (b/78647825). "_toolchain": attr.label( default = Label("//compiler:java_lite_grpc_library_toolchain"), + providers = [ProtoLangToolchainInfo], + ), + "_java_config": attr.label( + default = Label("//compiler:java_lite_grpc_library_java_config"), + providers = [JavaRpcJavaConfigInfo], ), }, toolchains = ["@bazel_tools//tools/jdk:toolchain_type"], diff --git a/xds/BUILD.bazel b/xds/BUILD.bazel index 9b1bc24b5a3..56fa5e345a9 100644 --- a/xds/BUILD.bazel +++ b/xds/BUILD.bazel @@ -4,7 +4,7 @@ load("@com_google_protobuf//bazel:proto_library.bzl", "proto_library") load("@com_google_protobuf//bazel/toolchains:proto_lang_toolchain.bzl", "proto_lang_toolchain") load("@rules_java//java:defs.bzl", "java_binary", "java_library", "java_test") load("@rules_jvm_external//:defs.bzl", "artifact") -load("//:java_grpc_library.bzl", "INTERNAL_java_grpc_library_for_xds", "java_grpc_library") +load("//:java_grpc_library.bzl", "INTERNAL_java_grpc_library_for_xds", "java_grpc_library", "java_rpc_java_config") # Mirrors the dependencies included in the artifact on Maven Central for usage # with maven_install's override_targets. Should only be used as a dep for @@ -329,6 +329,10 @@ proto_lang_toolchain( runtime = ":java_grpc_library_deps", ) +java_rpc_java_config( + name = "java_grpc_library_java_config", +) + java_library( name = "java_grpc_library_deps", neverlink = 1, From f7ba8e217d80e3a9235682efbb51a8147273f752 Mon Sep 17 00:00:00 2001 From: agrawalabhi Date: Wed, 16 Sep 2026 15:07:11 +0000 Subject: [PATCH 9/9] bazel: make the java config provider private and drop .bazelrc change The provider is only referenced within java_grpc_library.bzl, so there is no reason to export it. The provider it replaces, _JavaRpcToolchainInfo, was private for the same reason. Also revert the trailing newline added to .bazelrc, which is unrelated to this change. --- .bazelrc | 2 +- java_grpc_library.bzl | 14 +++++++------- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/.bazelrc b/.bazelrc index 88d4fc627ac..453acedb593 100644 --- a/.bazelrc +++ b/.bazelrc @@ -1,3 +1,3 @@ build --cxxopt=-std=c++17 --host_cxxopt=-std=c++17 -common:skip_android --deleted_packages=android,binder +common:skip_android --deleted_packages=android,binder \ No newline at end of file diff --git a/java_grpc_library.bzl b/java_grpc_library.bzl index 59dc13a32a0..c30f57aa8f6 100644 --- a/java_grpc_library.bzl +++ b/java_grpc_library.bzl @@ -9,7 +9,7 @@ load("@rules_java//java:defs.bzl", "JavaInfo", "JavaPluginInfo", "java_common") # sources, then those sources are compiled. `proto_lang_toolchain` configures # the first phase, but it is language-agnostic and so cannot express anything # about the second. This provider carries that Java-specific configuration. -JavaRpcJavaConfigInfo = provider( +_JavaRpcJavaConfigInfo = provider( doc = "Java compilation settings for the sources protoc generates.", fields = { "java_plugins": "(list[Target]) JavaPluginInfo targets to run as " + @@ -18,7 +18,7 @@ JavaRpcJavaConfigInfo = provider( ) def _java_rpc_java_config_impl(ctx): - return [JavaRpcJavaConfigInfo(java_plugins = ctx.attr.java_plugins)] + return [_JavaRpcJavaConfigInfo(java_plugins = ctx.attr.java_plugins)] java_rpc_java_config = rule( doc = """Java compilation settings to accompany a `proto_lang_toolchain`. @@ -33,7 +33,7 @@ Java compilation that follows it.""", doc = "Annotation processors to run over the generated sources.", ), }, - provides = [JavaRpcJavaConfigInfo], + provides = [_JavaRpcJavaConfigInfo], implementation = _java_rpc_java_config_impl, ) @@ -65,7 +65,7 @@ def _java_rpc_library_impl(ctx): output_source_jar = ctx.outputs.srcjar, plugins = [ plugin[JavaPluginInfo] - for plugin in ctx.attr._java_config[JavaRpcJavaConfigInfo].java_plugins + for plugin in ctx.attr._java_config[_JavaRpcJavaConfigInfo].java_plugins ], deps = [ java_common.make_non_strict(deps_java_info), @@ -92,7 +92,7 @@ _java_grpc_library = rule( ), "_java_config": attr.label( default = Label("//compiler:java_grpc_library_java_config"), - providers = [JavaRpcJavaConfigInfo], + providers = [_JavaRpcJavaConfigInfo], ), }, toolchains = ["@bazel_tools//tools/jdk:toolchain_type"], @@ -124,7 +124,7 @@ INTERNAL_java_grpc_library_for_xds = rule( ), "_java_config": attr.label( default = Label("//xds:java_grpc_library_java_config"), - providers = [JavaRpcJavaConfigInfo], + providers = [_JavaRpcJavaConfigInfo], ), }, toolchains = ["@bazel_tools//tools/jdk:toolchain_type"], @@ -156,7 +156,7 @@ _java_lite_grpc_library = rule( ), "_java_config": attr.label( default = Label("//compiler:java_lite_grpc_library_java_config"), - providers = [JavaRpcJavaConfigInfo], + providers = [_JavaRpcJavaConfigInfo], ), }, toolchains = ["@bazel_tools//tools/jdk:toolchain_type"],