If using Bazel, please load the rule from -https://github.com/bazelbuild/rules_proto. - -
Use proto_library to define libraries of protocol buffers which
-may be used from multiple languages. A proto_library may be listed
-in the deps clause of supported rules, such as
-java_proto_library.
-
-
When compiled on the command-line, a proto_library creates a file
-named foo-descriptor-set.proto.bin, which is the descriptor set for
-the messages the rule srcs. The file is a serialized
-FileDescriptorSet, which is described in
-
-https://developers.google.com/protocol-buffers/docs/techniques#self-description.
-
-
It only contains information about the .proto files directly
-mentioned by a proto_library rule; the collection of transitive
-descriptor sets is available through the
-[ProtoInfo].transitive_descriptor_sets Starlark provider.
-See documentation in proto_info.bzl.
-
-
Recommended code organization: -
proto_library rule per .proto file.
-foo.proto will be in a rule named foo_proto,
- which is located in the same package.
-[language]_proto_library that wraps a proto_library
- named foo_proto should be called foo_[language]_proto,
- and be located in the same package.
-.proto and .protodevel files that are
-processed to create the target. This is usually a non empty list. One usecase
-where srcs can be empty is an alias-library. This is a
-proto_library rule having one or more other proto_library in deps.
-This pattern can be used to e.g. export a public api under a persistent name.""",
- ),
- "deps": attr.label_list(
- providers = [ProtoInfo],
- doc = """
-The list of other proto_library rules that the target depends upon.
-A proto_library may only depend on other proto_library
-targets. It may not depend on language-specific libraries.""",
- ),
- "exports": attr.label_list(
- providers = [ProtoInfo],
- doc = """
-List of proto_library targets that can be referenced via "import public" in the
-proto source.
-It's an error if you use "import public" but do not list the corresponding library
-in the exports attribute.
-Note that you have list the library both in deps and exports since not all
-lang_proto_library implementations have been changed yet.""",
- ),
- "strip_import_prefix": attr.string(
- default = "/",
- doc = """
-The prefix to strip from the paths of the .proto files in this rule.
-
-When set, .proto source files in the srcs attribute of this rule are
-accessible at their path with this prefix cut off.
-
-
If it's a relative path (not starting with a slash), it's taken as a package-relative -one. If it's an absolute one, it's understood as a repository-relative path. - -
The prefix in the import_prefix attribute is added after this prefix is
-stripped.""",
- ),
- "import_prefix": attr.string(
- doc = """
-The prefix to add to the paths of the .proto files in this rule.
-
-
When set, the .proto source files in the srcs attribute of this rule are
-accessible at is the value of this attribute prepended to their repository-relative path.
-
-
The prefix in the strip_import_prefix attribute is removed before this
-prefix is added.""",
- ),
- "allow_exports": attr.label(
- cfg = "exec",
- providers = [bazel_features.globals.PackageSpecificationInfo] if bazel_features.globals.PackageSpecificationInfo else [],
- doc = """
-An optional allowlist that prevents proto library to be reexported or used in
-lang_proto_library that is not in one of the listed packages.""",
- ),
- "data": attr.label_list(
- allow_files = True,
- flags = ["SKIP_CONSTRAINTS_OVERRIDE"],
- ),
- # buildifier: disable=attr-license (calling attr.license())
- "licenses": attr.license() if hasattr(attr, "license") else attr.string_list(),
- "_experimental_proto_descriptor_sets_include_source_info": attr.label(
- default = "//bazel/private:experimental_proto_descriptor_sets_include_source_info",
- ),
- "_strict_proto_deps": attr.label(
- default =
- "//bazel/private:strict_proto_deps",
- ),
- "_strict_public_imports": attr.label(
- default = "//bazel/private:strict_public_imports",
- ),
- } | toolchains.if_legacy_toolchain({
- "_proto_compiler": attr.label(
- cfg = "exec",
- executable = True,
- allow_files = True,
- default = configuration_field("proto", "proto_compiler"),
- ),
- }), # buildifier: disable=attr-licenses (attribute called licenses)
- fragments = ["proto"],
- provides = [ProtoInfo],
- toolchains = toolchains.use_toolchain(toolchains.PROTO_TOOLCHAIN),
-)
diff --git a/bazel/private/native_bool_flag.bzl b/bazel/private/native_bool_flag.bzl
deleted file mode 100644
index 960fbed5128e7..0000000000000
--- a/bazel/private/native_bool_flag.bzl
+++ /dev/null
@@ -1,35 +0,0 @@
-# Protocol Buffers - Google's data interchange format
-# Copyright 2008 Google Inc. All rights reserved.
-#
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file or at
-# https://developers.google.com/open-source/licenses/bsd
-"""
-A helper rule that reads a native boolean flag.
-"""
-
-load("@bazel_skylib//rules:common_settings.bzl", "BuildSettingInfo")
-
-def _impl(ctx):
- return [BuildSettingInfo(value = ctx.attr.value)]
-
-_native_bool_flag_rule = rule(
- implementation = _impl,
- attrs = {"value": attr.bool()},
-)
-
-def native_bool_flag(*, name, flag, match_value = "true", result = True, **kwargs):
- _native_bool_flag_rule(
- name = name,
- value = select({
- name + "_setting": result,
- "//conditions:default": not result,
- }),
- **kwargs
- )
-
- native.config_setting(
- name = name + "_setting",
- values = {flag: match_value},
- visibility = ["//visibility:private"],
- )
diff --git a/bazel/private/proto_bazel_features.bzl b/bazel/private/proto_bazel_features.bzl
deleted file mode 100644
index 80f36eb4b0103..0000000000000
--- a/bazel/private/proto_bazel_features.bzl
+++ /dev/null
@@ -1,50 +0,0 @@
-# Protocol Buffers - Google's data interchange format
-# Copyright 2024 Google Inc. All rights reserved.
-#
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file or at
-# https://developers.google.com/open-source/licenses/bsd
-#
-"""Vendored version of bazel_features for protobuf, to keep a one-step setup"""
-
-_PROTO_BAZEL_FEATURES = """bazel_features = struct(
- proto = struct(
- starlark_proto_info = {starlark_proto_info},
- ),
- globals = struct(
- PackageSpecificationInfo = {PackageSpecificationInfo},
- ),
-)
-"""
-
-def _proto_bazel_features_impl(rctx):
- # An empty string is treated as a "dev version", which is greater than anything.
- bazel_version = native.bazel_version or "999999.999999.999999"
- version_parts = bazel_version.split("-")[0].split(".")
- if len(version_parts) != 3:
- fail("invalid Bazel version '{}': got {} dot-separated segments, want 3".format(bazel_version, len(version_parts)))
- major_version_int = int(version_parts[0])
- minor_version_int = int(version_parts[1])
-
- starlark_proto_info = major_version_int >= 7
- PackageSpecificationInfo = major_version_int > 6 or (major_version_int == 6 and minor_version_int >= 4)
-
- rctx.file("BUILD.bazel", """
-load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
-bzl_library(
- name = "features",
- srcs = ["features.bzl"],
- visibility = ["//visibility:public"],
-)
-exports_files(["features.bzl"])
-""")
- rctx.file("features.bzl", _PROTO_BAZEL_FEATURES.format(
- starlark_proto_info = repr(starlark_proto_info),
- PackageSpecificationInfo = "PackageSpecificationInfo" if PackageSpecificationInfo else "None",
- ))
-
-proto_bazel_features = repository_rule(
- implementation = _proto_bazel_features_impl,
- # Force reruns on server restarts to keep native.bazel_version up-to-date.
- local = True,
-)
diff --git a/bazel/private/proto_lang_toolchain_rule.bzl b/bazel/private/proto_lang_toolchain_rule.bzl
deleted file mode 100644
index d99b58c9dcb80..0000000000000
--- a/bazel/private/proto_lang_toolchain_rule.bzl
+++ /dev/null
@@ -1,155 +0,0 @@
-# Protocol Buffers - Google's data interchange format
-# Copyright 2024 Google Inc. All rights reserved.
-#
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file or at
-# https://developers.google.com/open-source/licenses/bsd
-#
-"""Implementation of the proto_lang_toolchain rule."""
-
-load("@proto_bazel_features//:features.bzl", "bazel_features")
-load("//bazel/common:proto_common.bzl", "proto_common")
-load("//bazel/common:proto_info.bzl", "ProtoInfo")
-load("//bazel/common:proto_lang_toolchain_info.bzl", "ProtoLangToolchainInfo")
-load("//bazel/private:toolchain_helpers.bzl", "toolchains")
-
-def _rule_impl(ctx):
- provided_proto_sources = depset(transitive = [bp[ProtoInfo]._transitive_proto_sources for bp in ctx.attr.blacklisted_protos]).to_list()
-
- flag = ctx.attr.command_line
- if flag.find("$(PLUGIN_OUT)") > -1:
- fail("in attribute 'command_line': Placeholder '$(PLUGIN_OUT)' is not supported.")
- flag = flag.replace("$(OUT)", "%s")
-
- plugin = None
- if ctx.attr.plugin != None:
- plugin = ctx.attr.plugin[DefaultInfo].files_to_run
-
- if proto_common.INCOMPATIBLE_ENABLE_PROTO_TOOLCHAIN_RESOLUTION:
- proto_compiler = ctx.toolchains[toolchains.PROTO_TOOLCHAIN].proto.proto_compiler
- protoc_opts = ctx.toolchains[toolchains.PROTO_TOOLCHAIN].proto.protoc_opts
- else:
- proto_compiler = ctx.attr._proto_compiler.files_to_run
- protoc_opts = ctx.fragments.proto.experimental_protoc_opts
-
- if ctx.attr.protoc_minimal_do_not_use:
- proto_compiler = ctx.attr.protoc_minimal_do_not_use.files_to_run
-
- proto_lang_toolchain_info = ProtoLangToolchainInfo(
- out_replacement_format_flag = flag,
- output_files = ctx.attr.output_files,
- plugin_format_flag = ctx.attr.plugin_format_flag,
- plugin = plugin,
- runtime = ctx.attr.runtime,
- provided_proto_sources = provided_proto_sources,
- proto_compiler = proto_compiler,
- protoc_opts = protoc_opts,
- progress_message = ctx.attr.progress_message,
- mnemonic = ctx.attr.mnemonic,
- allowlist_different_package = ctx.attr.allowlist_different_package,
- toolchain_type = ctx.attr.toolchain_type.label if ctx.attr.toolchain_type else None,
- )
- return [
- DefaultInfo(files = depset(), runfiles = ctx.runfiles()),
- platform_common.ToolchainInfo(proto = proto_lang_toolchain_info),
- # TODO: remove when --incompatible_enable_proto_toolchains is flipped and removed
- proto_lang_toolchain_info,
- ]
-
-proto_lang_toolchain = rule(
- _rule_impl,
- doc = """
-
If using Bazel, please load the rule from -https://github.com/bazelbuild/rules_proto. - -
Specifies how a LANG_proto_library rule (e.g., java_proto_library) should invoke the
-proto-compiler.
-Some LANG_proto_library rules allow specifying which toolchain to use using command-line flags;
-consult their documentation.
-
-
Normally you should not write those kind of rules unless you want to -tune your Java compiler. - -
There's no compiler. The proto-compiler is taken from the proto_library rule we attach to. It is
-passed as a command-line flag to Blaze.
-Several features require a proto-compiler to be invoked on the proto_library rule itself.
-It's beneficial to enforce the compiler that LANG_proto_library uses is the same as the one
-proto_library does.
-
-
A simple example would be: -
-proto_lang_toolchain(
- name = "javalite_toolchain",
- command_line = "--javalite_out=shared,immutable:$(OUT)",
- plugin = ":javalite_plugin",
- runtime = ":protobuf_lite",
-)
-$(OUT) is LANG_proto_library-specific. The rules are expected to define
- how they interpret this variable. For Java, for example, $(OUT) will be replaced with
- the src-jar filename to create.$(OUT) in command_line is formatted, either by
-a path to a single file or output directory in case of multiple files.
-Possible values are: "single", "multiple"."""),
- "plugin_format_flag": attr.string(doc = """
-If provided, this value will be passed to proto-compiler to use the plugin.
-The value must contain a single %s which is replaced with plugin executable.
---plugin=protoc-gen-PLUGIN=<executable>."""),
- "plugin": attr.label(
- executable = True,
- cfg = "exec",
- doc = """
-If provided, will be made available to the action that calls the proto-compiler, and will be
-passed to the proto-compiler:
---plugin=protoc-gen-PLUGIN=<executable>.""",
- ),
- "runtime": attr.label(doc = """
-A language-specific library that the generated code is compiled against.
-The exact behavior is LANG_proto_library-specific.
-Java, for example, should compile against the runtime."""),
- "blacklisted_protos": attr.label_list(
- providers = [ProtoInfo],
- doc = """
-No code will be generated for files in the srcs attribute of
-blacklisted_protos.
-This is used for .proto files that are already linked into proto runtimes, such as
-any.proto.""",
- ),
- # TODO: add doc
- "allowlist_different_package": attr.label(
- cfg = "exec",
- providers = [bazel_features.globals.PackageSpecificationInfo] if bazel_features.globals.PackageSpecificationInfo else [],
- ),
- # TODO: add doc
- "toolchain_type": attr.label(),
- # DO NOT USE. For Protobuf incremental changes only: b/305068148.
- "protoc_minimal_do_not_use": attr.label(
- cfg = "exec",
- executable = True,
- ),
- } | ({} if proto_common.INCOMPATIBLE_ENABLE_PROTO_TOOLCHAIN_RESOLUTION else {
- "_proto_compiler": attr.label(
- cfg = "exec",
- executable = True,
- allow_files = True,
- default = configuration_field("proto", "proto_compiler"),
- ),
- }),
- provides = [ProtoLangToolchainInfo],
- fragments = ["proto"],
- toolchains = toolchains.use_toolchain(toolchains.PROTO_TOOLCHAIN), # Used to obtain protoc
-)
diff --git a/bazel/private/proto_toolchain_rule.bzl b/bazel/private/proto_toolchain_rule.bzl
index 3a4ee72a7c067..9487a06026dec 100644
--- a/bazel/private/proto_toolchain_rule.bzl
+++ b/bazel/private/proto_toolchain_rule.bzl
@@ -1,16 +1,13 @@
-# Protocol Buffers - Google's data interchange format
-# Copyright 2024 Google Inc. All rights reserved.
-#
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file or at
-# https://developers.google.com/open-source/licenses/bsd
-#
"""A Starlark implementation of the proto_toolchain rule."""
+load("//bazel/common:proto_common.bzl", "proto_common")
load("//bazel/common:proto_lang_toolchain_info.bzl", "ProtoLangToolchainInfo")
-load("//bazel/private:toolchain_helpers.bzl", "toolchains")
def _impl(ctx):
+ kwargs = {}
+ if getattr(proto_common, "INCOMPATIBLE_PASS_TOOLCHAIN_TYPE", False):
+ kwargs["toolchain_type"] = "@rules_proto//proto:toolchain_type"
+
return [
DefaultInfo(
files = depset(),
@@ -26,7 +23,7 @@ def _impl(ctx):
protoc_opts = ctx.fragments.proto.experimental_protoc_opts,
progress_message = ctx.attr.progress_message,
mnemonic = ctx.attr.mnemonic,
- toolchain_type = toolchains.PROTO_TOOLCHAIN,
+ **kwargs
),
),
]
diff --git a/bazel/private/toolchain_helpers.bzl b/bazel/private/toolchain_helpers.bzl
deleted file mode 100644
index aa49eb8cf4c88..0000000000000
--- a/bazel/private/toolchain_helpers.bzl
+++ /dev/null
@@ -1,49 +0,0 @@
-# Protocol Buffers - Google's data interchange format
-# Copyright 2024 Google Inc. All rights reserved.
-#
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file or at
-# https://developers.google.com/open-source/licenses/bsd
-#
-"""
-Toolchain helpers.
-
-The helpers here should be used for a migration to toolchain in proto rules.
-
-Anybody that needs them in another repository should copy them, because after
-the migration is finished, the helpers can be removed.
-"""
-
-load("//bazel/common:proto_lang_toolchain_info.bzl", "ProtoLangToolchainInfo")
-load("//bazel/private:native.bzl", "native_proto_common")
-
-_incompatible_toolchain_resolution = getattr(native_proto_common, "INCOMPATIBLE_ENABLE_PROTO_TOOLCHAIN_RESOLUTION", False)
-
-def _find_toolchain(ctx, legacy_attr, toolchain_type):
- if _incompatible_toolchain_resolution:
- toolchain = ctx.toolchains[toolchain_type]
- if not toolchain:
- fail("No toolchains registered for '%s'." % toolchain_type)
- return toolchain.proto
- else:
- return getattr(ctx.attr, legacy_attr)[ProtoLangToolchainInfo]
-
-def _use_toolchain(toolchain_type):
- if _incompatible_toolchain_resolution:
- return [config_common.toolchain_type(toolchain_type, mandatory = False)]
- else:
- return []
-
-def _if_legacy_toolchain(legacy_attr_dict):
- if _incompatible_toolchain_resolution:
- return {}
- else:
- return legacy_attr_dict
-
-toolchains = struct(
- use_toolchain = _use_toolchain,
- find_toolchain = _find_toolchain,
- if_legacy_toolchain = _if_legacy_toolchain,
- INCOMPATIBLE_ENABLE_PROTO_TOOLCHAIN_RESOLUTION = _incompatible_toolchain_resolution,
- PROTO_TOOLCHAIN = "//bazel/private:proto_toolchain_type",
-)
diff --git a/bazel/proto_library.bzl b/bazel/proto_library.bzl
index 336623067d4e6..3006e3c0c29d0 100644
--- a/bazel/proto_library.bzl
+++ b/bazel/proto_library.bzl
@@ -1,20 +1,3 @@
-# Protocol Buffers - Google's data interchange format
-# Copyright 2008 Google Inc. All rights reserved.
-#
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file or at
-# https://developers.google.com/open-source/licenses/bsd
-"""
-Macro of proto_library rule.
-"""
+"""proto_library rule"""
-load("@proto_bazel_features//:features.bzl", "bazel_features")
-load("//bazel/private:bazel_proto_library_rule.bzl", _proto_library = "proto_library")
-
-def proto_library(**kwattrs):
- # This condition causes Starlark rules to be used only on Bazel >=7.0.0
- if bazel_features.proto.starlark_proto_info:
- _proto_library(**kwattrs)
- else:
- # On older Bazel versions keep using native rules, so that mismatch in ProtoInfo doesn't happen
- native.proto_library(**kwattrs)
+proto_library = native.proto_library
diff --git a/bazel/py_proto_library.bzl b/bazel/py_proto_library.bzl
index 1c40598422282..86af999502375 100644
--- a/bazel/py_proto_library.bzl
+++ b/bazel/py_proto_library.bzl
@@ -3,9 +3,8 @@
load("@rules_python//python:py_info.bzl", "PyInfo")
load("//bazel/common:proto_common.bzl", "proto_common")
load("//bazel/common:proto_info.bzl", "ProtoInfo")
-load("//bazel/private:toolchain_helpers.bzl", "toolchains")
-_PY_PROTO_TOOLCHAIN = Label("//bazel/private:python_toolchain_type")
+PY_PROTO_TOOLCHAIN = "@rules_python//python/proto:toolchain_type"
_PyProtoInfo = provider(
doc = "Encapsulates information needed by the Python proto rules.",
@@ -23,6 +22,9 @@ _PyProtoInfo = provider(
def _filter_provider(provider, *attrs):
return [dep[provider] for attr in attrs for dep in attr if provider in dep]
+def _incompatible_toolchains_enabled():
+ return getattr(proto_common, "INCOMPATIBLE_ENABLE_PROTO_TOOLCHAIN_RESOLUTION", False)
+
def _py_proto_aspect_impl(target, ctx):
"""Generates and compiles Python code for a proto_library.
@@ -49,10 +51,10 @@ def _py_proto_aspect_impl(target, ctx):
proto.path,
))
- if proto_common.INCOMPATIBLE_ENABLE_PROTO_TOOLCHAIN_RESOLUTION:
- toolchain = ctx.toolchains[_PY_PROTO_TOOLCHAIN]
+ if _incompatible_toolchains_enabled():
+ toolchain = ctx.toolchains[PY_PROTO_TOOLCHAIN]
if not toolchain:
- fail("No toolchains registered for '%s'." % _PY_PROTO_TOOLCHAIN)
+ fail("No toolchains registered for '%s'." % PY_PROTO_TOOLCHAIN)
proto_lang_toolchain_info = toolchain.proto
else:
proto_lang_toolchain_info = getattr(ctx.attr, "_aspect_proto_toolchain")[proto_common.ProtoLangToolchainInfo]
@@ -118,15 +120,15 @@ def _py_proto_aspect_impl(target, ctx):
_py_proto_aspect = aspect(
implementation = _py_proto_aspect_impl,
- attrs = toolchains.if_legacy_toolchain({
+ attrs = {} if _incompatible_toolchains_enabled() else {
"_aspect_proto_toolchain": attr.label(
default = "//python:python_toolchain",
),
- }),
+ },
attr_aspects = ["deps"],
required_providers = [ProtoInfo],
provides = [_PyProtoInfo],
- toolchains = toolchains.use_toolchain(_PY_PROTO_TOOLCHAIN),
+ toolchains = [PY_PROTO_TOOLCHAIN] if _incompatible_toolchains_enabled() else [],
)
def _py_proto_library_rule(ctx):
diff --git a/bazel/tests/BUILD b/bazel/tests/BUILD
deleted file mode 100644
index 54cc42150ea1f..0000000000000
--- a/bazel/tests/BUILD
+++ /dev/null
@@ -1,3 +0,0 @@
-load(":proto_common_compile_tests.bzl", "proto_common_compile_test_suite")
-
-proto_common_compile_test_suite(name = "proto_common_compile_test_suite")
diff --git a/bazel/tests/proto_common_compile_tests.bzl b/bazel/tests/proto_common_compile_tests.bzl
deleted file mode 100644
index f0d0110f1b1bc..0000000000000
--- a/bazel/tests/proto_common_compile_tests.bzl
+++ /dev/null
@@ -1,368 +0,0 @@
-# Protocol Buffers - Google's data interchange format
-# Copyright 2024 Google Inc. All rights reserved.
-#
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file or at
-# https://developers.google.com/open-source/licenses/bsd
-#
-"""Tests for `proto_common.compile` function."""
-
-load("@rules_testing//lib:analysis_test.bzl", "analysis_test", "test_suite")
-load("@rules_testing//lib:truth.bzl", "matching")
-load("@rules_testing//lib:util.bzl", "util")
-load("//bazel:proto_library.bzl", "proto_library")
-load("//bazel/tests/testdata:compile_rule.bzl", "compile_rule")
-
-protocol_compiler = "/protoc"
-
-def proto_common_compile_test_suite(name):
- util.helper_target(
- proto_library,
- name = "simple_proto",
- srcs = ["A.proto"],
- )
- test_suite(
- name = name,
- tests = [
- _test_compile_basic,
- _test_compile_noplugin,
- _test_compile_with_plugin_output,
- _test_compile_with_directory_plugin_output,
- _test_compile_additional_args,
- _test_compile_additional_tools,
- _test_compile_additional_tools_no_plugin,
- _test_compile_additional_inputs,
- _test_compile_resource_set,
- _test_compile_protoc_opts,
- _test_compile_direct_generated_protos,
- _test_compile_indirect_generated_protos,
- ],
- )
-
-# Verifies basic usage of `proto_common.compile`.
-def _test_compile_basic(name):
- util.helper_target(
- compile_rule,
- name = name + "_compile",
- proto_dep = ":simple_proto",
- )
-
- analysis_test(
- name = name,
- target = name + "_compile",
- impl = _test_compile_basic_impl,
- )
-
-def _test_compile_basic_impl(env, target):
- action = env.expect.that_target(target).action_named("MyMnemonic")
- action.argv().contains_exactly_predicates(
- [
- matching.str_endswith(protocol_compiler),
- matching.str_matches("--plugin=b*-out/*-exec-*/bin/*/testdata/plugin"),
- matching.equals_wrapper("-I."),
- matching.str_endswith("/A.proto"),
- ],
- )
- action.mnemonic().equals("MyMnemonic")
-
-# Verifies usage of proto_common.generate_code with no plugin specified by toolchain.
-def _test_compile_noplugin(name):
- util.helper_target(
- compile_rule,
- name = name + "_compile",
- proto_dep = ":simple_proto",
- toolchain = "//bazel/tests/testdata:toolchain_noplugin",
- )
-
- analysis_test(
- name = name,
- target = name + "_compile",
- impl = _test_compile_noplugin_impl,
- )
-
-def _test_compile_noplugin_impl(env, target):
- action = env.expect.that_target(target).action_named("MyMnemonic")
- action.argv().contains_exactly_predicates(
- [
- matching.str_endswith(protocol_compiler),
- matching.equals_wrapper("-I."),
- matching.str_endswith("/A.proto"),
- ],
- )
-
-# Verifies usage of `proto_common.compile` with `plugin_output` parameter set to file.
-def _test_compile_with_plugin_output(name):
- util.helper_target(
- compile_rule,
- name = name + "_compile",
- proto_dep = ":simple_proto",
- plugin_output = "single",
- )
-
- analysis_test(
- name = name,
- target = name + "_compile",
- impl = _test_compile_with_plugin_output_impl,
- )
-
-def _test_compile_with_plugin_output_impl(env, target):
- action = env.expect.that_target(target).action_named("MyMnemonic")
- action.argv().contains_exactly_predicates(
- [
- matching.str_endswith(protocol_compiler),
- matching.str_matches("--java_out=param1,param2:b*-out/*/test_compile_with_plugin_output_compile"),
- matching.str_matches("--plugin=b*-out/*-exec-*/bin/*/testdata/plugin"),
- matching.equals_wrapper("-I."),
- matching.str_endswith("/A.proto"),
- ],
- )
-
-# Verifies usage of `proto_common.compile` with `plugin_output` parameter set to file.
-def _test_compile_with_directory_plugin_output(name):
- util.helper_target(
- compile_rule,
- name = name + "_compile",
- proto_dep = ":simple_proto",
- plugin_output = "multiple",
- )
-
- analysis_test(
- name = name,
- target = name + "_compile",
- impl = _test_compile_with_directory_plugin_output_impl,
- )
-
-def _test_compile_with_directory_plugin_output_impl(env, target):
- action = env.expect.that_target(target).action_named("MyMnemonic")
- action.argv().contains_exactly_predicates(
- [
- matching.str_endswith(protocol_compiler),
- matching.str_matches("--java_out=param1,param2:b*-out/*/bin"),
- matching.str_matches("--plugin=b*-out/*-exec-*/bin/*/testdata/plugin"),
- matching.equals_wrapper("-I."),
- matching.str_endswith("/A.proto"),
- ],
- )
-
-# Verifies usage of `proto_common.compile` with `additional_args` parameter
-def _test_compile_additional_args(name):
- util.helper_target(
- compile_rule,
- name = name + "_compile",
- proto_dep = ":simple_proto",
- additional_args = ["--a", "--b"],
- )
-
- analysis_test(
- name = name,
- target = name + "_compile",
- impl = _test_compile_additional_args_impl,
- )
-
-def _test_compile_additional_args_impl(env, target):
- action = env.expect.that_target(target).action_named("MyMnemonic")
- action.argv().contains_exactly_predicates(
- [
- matching.str_endswith(protocol_compiler),
- matching.equals_wrapper("--a"),
- matching.equals_wrapper("--b"),
- matching.str_matches("--plugin=b*-out/*-exec-*/bin/*/testdata/plugin"),
- matching.equals_wrapper("-I."),
- matching.str_endswith("/A.proto"),
- ],
- )
-
-# Verifies usage of `proto_common.compile` with `additional_tools` parameter
-def _test_compile_additional_tools(name):
- util.helper_target(
- compile_rule,
- name = name + "_compile",
- proto_dep = ":simple_proto",
- additional_tools = [
- "//bazel/tests/testdata:_tool1",
- "//bazel/tests/testdata:_tool2",
- ],
- )
-
- analysis_test(
- name = name,
- target = name + "_compile",
- impl = _test_compile_additional_tools_impl,
- )
-
-def _test_compile_additional_tools_impl(env, target):
- action = env.expect.that_target(target).action_named("MyMnemonic")
- action.inputs().contains_at_least_predicates(
- [
- matching.file_basename_equals("_tool1"),
- matching.file_basename_equals("_tool2"),
- matching.file_basename_equals("plugin"),
- ],
- )
-
-# Verifies usage of `proto_common.compile` with `additional_tools` parameter and no plugin on the toolchain.
-def _test_compile_additional_tools_no_plugin(name):
- util.helper_target(
- compile_rule,
- name = name + "_compile",
- proto_dep = ":simple_proto",
- additional_tools = [
- "//bazel/tests/testdata:_tool1",
- "//bazel/tests/testdata:_tool2",
- ],
- toolchain = "//bazel/tests/testdata:toolchain_noplugin",
- )
-
- analysis_test(
- name = name,
- target = name + "_compile",
- impl = _test_compile_additional_tools_no_plugin_impl,
- )
-
-def _test_compile_additional_tools_no_plugin_impl(env, target):
- action = env.expect.that_target(target).action_named("MyMnemonic")
- action.inputs().contains_at_least_predicates(
- [
- matching.file_basename_equals("_tool1"),
- matching.file_basename_equals("_tool2"),
- ],
- )
- action.inputs().not_contains_predicate(matching.file_basename_equals("plugin"))
-
-# Verifies usage of `proto_common.compile` with `additional_inputs` parameter.
-def _test_compile_additional_inputs(name):
- util.helper_target(
- compile_rule,
- name = name + "_compile",
- proto_dep = ":simple_proto",
- additional_inputs = ["input1.txt", "input2.txt"],
- )
-
- analysis_test(
- name = name,
- target = name + "_compile",
- impl = _test_compile_additional_inputs_impl,
- )
-
-def _test_compile_additional_inputs_impl(env, target):
- action = env.expect.that_target(target).action_named("MyMnemonic")
- action.inputs().contains_at_least_predicates(
- [
- matching.file_basename_equals("input1.txt"),
- matching.file_basename_equals("input2.txt"),
- ],
- )
-
-# Verifies usage of `proto_common.compile` with `additional_tools` parameter and no plugin on the toolchain.
-def _test_compile_resource_set(name):
- util.helper_target(
- compile_rule,
- name = name + "_compile",
- proto_dep = ":simple_proto",
- use_resource_set = True,
- )
-
- analysis_test(
- name = name,
- target = name + "_compile",
- impl = _test_compile_resource_set_impl,
- )
-
-def _test_compile_resource_set_impl(env, target):
- action = env.expect.that_target(target).action_named("MyMnemonic") # @unused
- # We can't check the specification of the resource set, but we at least verify analysis passes
-
-# Verifies `--protocopts` are passed to command line.
-def _test_compile_protoc_opts(name):
- util.helper_target(
- compile_rule,
- name = name + "_compile",
- proto_dep = ":simple_proto",
- )
-
- analysis_test(
- name = name,
- target = name + "_compile",
- config_settings = {"//command_line_option:protocopt": ["--foo", "--bar"]},
- impl = _test_compile_protoc_opts_impl,
- )
-
-def _test_compile_protoc_opts_impl(env, target):
- action = env.expect.that_target(target).action_named("MyMnemonic")
- action.argv().contains_exactly_predicates(
- [
- matching.str_endswith(protocol_compiler),
- matching.equals_wrapper("--foo"),
- matching.equals_wrapper("--bar"),
- matching.str_matches("--plugin=b*-out/*-exec-*/bin/*/testdata/plugin"),
- matching.equals_wrapper("-I."),
- matching.str_endswith("/A.proto"),
- ],
- )
-
-# Verifies `proto_common.compile`> correctly handles direct generated `.proto` files.
-def _test_compile_direct_generated_protos(name):
- util.helper_target(native.genrule, name = name + "_generate_G", cmd = "", outs = ["G.proto"])
- util.helper_target(
- proto_library,
- name = name + "_directly_generated_proto",
- srcs = ["A.proto", "G.proto"],
- )
- util.helper_target(
- compile_rule,
- name = name + "_compile",
- proto_dep = name + "_directly_generated_proto",
- )
-
- analysis_test(
- name = name,
- target = name + "_compile",
- impl = _test_compile_direct_generated_protos_impl,
- )
-
-def _test_compile_direct_generated_protos_impl(env, target):
- action = env.expect.that_target(target).action_named("MyMnemonic")
- action.argv().contains_exactly_predicates(
- [
- matching.str_endswith(protocol_compiler),
- matching.str_matches("--plugin=b*-out/*-exec-*/bin/*/testdata/plugin"),
- matching.str_matches("-Ib*-out/*/*"),
- matching.equals_wrapper("-I."),
- matching.str_endswith("/A.proto"),
- matching.str_matches("*-out/*/*/*/G.proto"),
- ],
- )
-
-# Verifies usage of `proto_common.compile` with `plugin_output` parameter
-def _test_compile_indirect_generated_protos(name):
- util.helper_target(native.genrule, name = "_generate_h", srcs = ["A.txt"], cmd = "", outs = ["H.proto"])
- util.helper_target(proto_library, name = "_generated_proto", srcs = ["H.proto"])
- util.helper_target(
- proto_library,
- name = name + "_indirectly_generated_proto",
- srcs = ["A.proto"],
- deps = [":_generated_proto"],
- )
- util.helper_target(
- compile_rule,
- name = name + "_compile",
- proto_dep = name + "_indirectly_generated_proto",
- )
-
- analysis_test(
- name = name,
- target = name + "_compile",
- impl = _test_compile_indirect_generated_protos_impl,
- )
-
-def _test_compile_indirect_generated_protos_impl(env, target):
- action = env.expect.that_target(target).action_named("MyMnemonic")
- action.argv().contains_exactly_predicates(
- [
- matching.str_endswith(protocol_compiler),
- matching.str_matches("--plugin=b*-out/*-exec-*/bin/*/testdata/plugin"),
- matching.str_matches("-Ib*-out/*/*"),
- matching.equals_wrapper("-I."),
- matching.str_endswith("/A.proto"),
- ],
- )
diff --git a/bazel/tests/testdata/BUILD b/bazel/tests/testdata/BUILD
deleted file mode 100644
index 6ae81e08c211e..0000000000000
--- a/bazel/tests/testdata/BUILD
+++ /dev/null
@@ -1,130 +0,0 @@
-package(default_visibility = ["//visibility:public"])
-
-proto_lang_toolchain(
- name = "toolchain",
- blacklisted_protos = [":denied"],
- command_line = "--java_out=param1,param2:$(OUT)",
- mnemonic = "MyMnemonic",
- plugin = ":plugin",
- plugin_format_flag = "--plugin=%s",
- progress_message = "Progress Message %{label}",
- runtime = ":runtime",
- tags = [
- "manual",
- "nobuilder",
- "notap",
- ],
-)
-
-proto_lang_toolchain(
- name = "toolchain_noplugin",
- blacklisted_protos = [":denied"],
- command_line = "--java_out=param1,param2:$(OUT)",
- mnemonic = "MyMnemonic",
- progress_message = "Progress Message %{label}",
- runtime = ":runtime",
- tags = [
- "manual",
- "nobuilder",
- "notap",
- ],
-)
-
-cc_binary(
- name = "plugin",
- srcs = ["plugin.cc"],
- tags = [
- "manual",
- "nobuilder",
- "notap",
- ],
-)
-
-cc_library(
- name = "runtime",
- srcs = ["runtime.cc"],
- tags = [
- "manual",
- "nobuilder",
- "notap",
- ],
-)
-
-filegroup(
- name = "descriptors",
- srcs = [
- "descriptor.proto",
- "metadata.proto",
- ],
- tags = [
- "manual",
- "nobuilder",
- "notap",
- ],
-)
-
-filegroup(
- name = "any",
- srcs = ["any.proto"],
- tags = [
- "manual",
- "nobuilder",
- "notap",
- ],
-)
-
-filegroup(
- name = "something",
- srcs = ["something.proto"],
- tags = [
- "manual",
- "nobuilder",
- "notap",
- ],
-)
-
-proto_library(
- name = "mixed",
- srcs = [
- ":descriptors",
- ":something",
- ],
- tags = [
- "manual",
- "nobuilder",
- "notap",
- ],
-)
-
-proto_library(
- name = "denied",
- srcs = [
- ":any",
- ":descriptors",
- ],
- tags = [
- "manual",
- "nobuilder",
- "notap",
- ],
-)
-
-cc_binary(
- name = "_tool1",
- srcs = ["tool1.cc"],
- tags = [
- "manual",
- "nobuilder",
- "notap",
- ],
-)
-
-cc_binary(
- name = "_tool2",
- srcs = ["tool2.cc"],
- tags = [
- "manual",
- "nobuilder",
- "notap",
- ],
-)
diff --git a/bazel/tests/testdata/compile_rule.bzl b/bazel/tests/testdata/compile_rule.bzl
deleted file mode 100644
index 8aec0a8209c3f..0000000000000
--- a/bazel/tests/testdata/compile_rule.bzl
+++ /dev/null
@@ -1,57 +0,0 @@
-# Protocol Buffers - Google's data interchange format
-# Copyright 2024 Google Inc. All rights reserved.
-#
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file or at
-# https://developers.google.com/open-source/licenses/bsd
-#
-"""Testing function for proto_common module"""
-
-load("//bazel/common:proto_common.bzl", "proto_common")
-
-def _resource_set_callback(_os, inputs_size):
- return {"memory": 25 + 0.15 * inputs_size, "cpu": 1}
-
-def _impl(ctx):
- outfile = ctx.actions.declare_file(ctx.attr.name)
- kwargs = {}
- if ctx.attr.plugin_output == "single":
- kwargs["plugin_output"] = outfile.path
- elif ctx.attr.plugin_output == "multiple":
- kwargs["plugin_output"] = ctx.bin_dir.path
- elif ctx.attr.plugin_output == "wrong":
- kwargs["plugin_output"] = ctx.bin_dir.path + "///"
- if ctx.attr.additional_args:
- additional_args = ctx.actions.args()
- additional_args.add_all(ctx.attr.additional_args)
- kwargs["additional_args"] = additional_args
- if ctx.files.additional_tools:
- kwargs["additional_tools"] = ctx.files.additional_tools
- if ctx.files.additional_inputs:
- kwargs["additional_inputs"] = depset(ctx.files.additional_inputs)
- if ctx.attr.use_resource_set:
- kwargs["resource_set"] = _resource_set_callback
- if ctx.attr.progress_message:
- kwargs["experimental_progress_message"] = ctx.attr.progress_message
- proto_common.compile(
- ctx.actions,
- ctx.attr.proto_dep[ProtoInfo],
- ctx.attr.toolchain[proto_common.ProtoLangToolchainInfo],
- [outfile],
- **kwargs
- )
- return [DefaultInfo(files = depset([outfile]))]
-
-compile_rule = rule(
- _impl,
- attrs = {
- "proto_dep": attr.label(),
- "plugin_output": attr.string(),
- "toolchain": attr.label(default = ":toolchain"),
- "additional_args": attr.string_list(),
- "additional_tools": attr.label_list(cfg = "exec"),
- "additional_inputs": attr.label_list(allow_files = True),
- "use_resource_set": attr.bool(),
- "progress_message": attr.string(),
- },
-)
diff --git a/bazel/toolchains/BUILD b/bazel/toolchains/BUILD.bazel
similarity index 64%
rename from bazel/toolchains/BUILD
rename to bazel/toolchains/BUILD.bazel
index d5aa113f384a9..34a45d5bbd833 100644
--- a/bazel/toolchains/BUILD
+++ b/bazel/toolchains/BUILD.bazel
@@ -8,7 +8,6 @@ bzl_library(
visibility = ["//visibility:public"],
deps = [
"//bazel/private:proto_toolchain_rule_bzl",
- "//bazel/private:toolchain_helpers_bzl",
],
)
@@ -20,15 +19,5 @@ bzl_library(
visibility = ["//visibility:public"],
deps = [
"//bazel/common:proto_common_bzl",
- "//bazel/private:proto_lang_toolchain_rule_bzl",
- "@proto_bazel_features//:features",
- ],
-)
-
-filegroup(
- name = "bazel_osx_p4deps",
- srcs = glob(["**"]),
- visibility = [
- "//bazel:__pkg__",
],
)
diff --git a/bazel/toolchains/proto_lang_toolchain.bzl b/bazel/toolchains/proto_lang_toolchain.bzl
index 4c1666530ebbd..7af6537e4df5a 100644
--- a/bazel/toolchains/proto_lang_toolchain.bzl
+++ b/bazel/toolchains/proto_lang_toolchain.bzl
@@ -1,15 +1,6 @@
-# Protocol Buffers - Google's data interchange format
-# Copyright 2024 Google Inc. All rights reserved.
-#
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file or at
-# https://developers.google.com/open-source/licenses/bsd
-#
"""proto_lang_toolchain rule"""
-load("@proto_bazel_features//:features.bzl", "bazel_features")
load("//bazel/common:proto_common.bzl", "proto_common")
-load("//bazel/private:proto_lang_toolchain_rule.bzl", _proto_lang_toolchain_rule = "proto_lang_toolchain")
def proto_lang_toolchain(*, name, toolchain_type = None, exec_compatible_with = [], target_compatible_with = [], **attrs):
"""Creates a proto_lang_toolchain and corresponding toolchain target.
@@ -30,12 +21,8 @@ def proto_lang_toolchain(*, name, toolchain_type = None, exec_compatible_with =
if getattr(proto_common, "INCOMPATIBLE_PASS_TOOLCHAIN_TYPE", False):
attrs["toolchain_type"] = toolchain_type
- # This condition causes Starlark rules to be used only on Bazel >=7.0.0
- if bazel_features.proto.starlark_proto_info:
- _proto_lang_toolchain_rule(name = name, **attrs)
- else:
- # On older Bazel versions keep using native rules, so that mismatch in ProtoInfo doesn't happen
- native.proto_lang_toolchain(name = name, **attrs)
+ # buildifier: disable=native-proto
+ native.proto_lang_toolchain(name = name, **attrs)
if toolchain_type:
native.toolchain(
diff --git a/bazel/toolchains/proto_toolchain.bzl b/bazel/toolchains/proto_toolchain.bzl
index dba256b05ea74..171e08cad5aca 100644
--- a/bazel/toolchains/proto_toolchain.bzl
+++ b/bazel/toolchains/proto_toolchain.bzl
@@ -1,17 +1,9 @@
-# Protocol Buffers - Google's data interchange format
-# Copyright 2024 Google Inc. All rights reserved.
-#
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file or at
-# https://developers.google.com/open-source/licenses/bsd
-#
"""Macro wrapping the proto_toolchain implementation.
The macro additionally creates toolchain target when toolchain_type is given.
"""
load("//bazel/private:proto_toolchain_rule.bzl", _proto_toolchain_rule = "proto_toolchain")
-load("//bazel/private:toolchain_helpers.bzl", "toolchains")
def proto_toolchain(*, name, proto_compiler, exec_compatible_with = []):
"""Creates a proto_toolchain and toolchain target for proto_library.
@@ -27,7 +19,7 @@ def proto_toolchain(*, name, proto_compiler, exec_compatible_with = []):
native.toolchain(
name = name + "_toolchain",
- toolchain_type = toolchains.PROTO_TOOLCHAIN,
+ toolchain_type = "@rules_proto//proto:toolchain_type",
exec_compatible_with = exec_compatible_with,
target_compatible_with = [],
toolchain = name,
diff --git a/protobuf_deps.bzl b/protobuf_deps.bzl
index 8b552b2f465a9..ae2aa5e7284cd 100644
--- a/protobuf_deps.bzl
+++ b/protobuf_deps.bzl
@@ -1,24 +1,6 @@
-"""Load dependencies needed to compile the protobuf library as a 3rd-party consumer.
-
-The consumers should use the following WORKSPACE snippet, which loads dependencies
-and sets up the repositories protobuf needs:
-
-```
-http_archive(
- name = "protobuf",
- strip_prefix = "protobuf-VERSION",
- sha256 = ...,
- url = ...,
-)
-
-load("@protobuf//:protobuf_deps.bzl", "protobuf_deps")
-
-protobuf_deps()
-```
-"""
+"""Load dependencies needed to compile the protobuf library as a 3rd-party consumer."""
load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
-load("//bazel/private:proto_bazel_features.bzl", "proto_bazel_features") # buildifier: disable=bzl-visibility
load("//python/dist:python_downloads.bzl", "python_nuget_package", "python_source_archive")
load("//python/dist:system_python.bzl", "system_python")
@@ -51,11 +33,11 @@ def protobuf_deps():
if not native.existing_rule("bazel_skylib"):
http_archive(
name = "bazel_skylib",
- sha256 = "d00f1389ee20b60018e92644e0948e16e350a7707219e7a390fb0a99b6ec9262",
urls = [
- "https://mirror.bazel.build/github.com/bazelbuild/bazel-skylib/releases/download/1.7.0/bazel-skylib-1.7.0.tar.gz",
- "https://github.com/bazelbuild/bazel-skylib/releases/download/1.7.0/bazel-skylib-1.7.0.tar.gz",
+ "https://mirror.bazel.build/github.com/bazelbuild/bazel-skylib/releases/download/1.3.0/bazel-skylib-1.3.0.tar.gz",
+ "https://github.com/bazelbuild/bazel-skylib/releases/download/1.3.0/bazel-skylib-1.3.0.tar.gz",
],
+ sha256 = "74d544d96f4a5bb630d465ca8bbcfe231e3594e5aae57e1edbf17a6eb3ca2506",
)
if not native.existing_rule("com_google_absl"):
@@ -104,8 +86,16 @@ def protobuf_deps():
sha256 = "469b7f3b580b4fcf8112f4d6d0d5a4ce8e1ad5e21fee67d8e8335d5f8b3debab",
)
- if not native.existing_rule("proto_bazel_features"):
- proto_bazel_features(name = "proto_bazel_features")
+ # TODO: remove after toolchain types are moved to protobuf
+ if not native.existing_rule("rules_proto"):
+ http_archive(
+ name = "rules_proto",
+ sha256 = "dc3fb206a2cb3441b485eb1e423165b231235a1ea9b031b4433cf7bc1fa460dd",
+ strip_prefix = "rules_proto-5.3.0-21.7",
+ urls = [
+ "https://github.com/bazelbuild/rules_proto/archive/refs/tags/5.3.0-21.7.tar.gz",
+ ],
+ )
if not native.existing_rule("rules_python"):
http_archive(