/
BUILD
150 lines (136 loc) · 4.54 KB
/
BUILD
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
# Protobuf Rust runtime packages.
load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
load("@bazel_skylib//rules:common_settings.bzl", "string_flag")
load("@rules_proto//proto:defs.bzl", "proto_lang_toolchain")
package(
default_visibility = ["//src/google/protobuf:__subpackages__"],
)
licenses(["notice"])
# The current Rust Protobuf runtime for the build. Depending on the value of
# `:rust_proto_library_kernel` build setting it forwards to the cpp or upb kernels. This is the
# target that users are expected to depend on.
#
# Rust gencode (via `rust_upb_proto_library` and `rust_cc_proto_library`) doesn't depend on this
# target, instead, it depends on the kernel-specific libraries directly. The reason is that we need
# to be able to use both kernels in the same build. That allows us to have one TAP config for both
# kernels, and to run tests using a single Blaze invocation.
#
# WARNING: It's critical that users do not end up using Rust Protobufs with multiple kernels in
# their binaries. Currently this is achieved by using bzl visibility on kernel-specific rules.
# TODO(b/149440343): Hide the kernel-specific targets once we can restrict a target visibility to a
# rule.
rust_library(
name = "protobuf",
srcs = ["protobuf.rs"],
rustc_flags = select({
":use_upb_kernel": ["--cfg=upb_kernel"],
"//conditions:default": ["--cfg=cpp_kernel"],
}),
deps = select({
":use_upb_kernel": [":protobuf_upb"],
"//conditions:default": [":protobuf_cpp"],
}),
)
# The Rust Protobuf runtime using the upb kernel.
#
# `rust_upb_proto_library` implicitly depends on this target. This target cannot depend on
# `:rust_proto_library_kernel` build setting; it has to be fully functional under any value of that
# setting.
#
# `shared.rs` contains kernel-agnostic logic and simple kernel-specific logic controlled by
# `#[cfg(...)]` attributes. That forces us to compile this file twice, once for each kernel. As a
# result this file is included in both `:protobuf_upb` and `:protobuf_cpp`. This is in principle
# identical to how we compile regular Rust source files twice (once for production, and once for
# unittesting).
rust_library(
name = "protobuf_upb",
srcs = [
"internal.rs",
"optional.rs",
"proxied.rs",
"shared.rs",
"string.rs",
"upb.rs",
"vtable.rs",
],
crate_root = "shared.rs",
rustc_flags = ["--cfg=upb_kernel"],
visibility = [
"//src/google/protobuf:__subpackages__",
"//rust:__subpackages__",
],
deps = [
":utf8",
"//rust/upb_kernel:upb_c_api",
],
)
rust_test(
name = "protobuf_upb_test",
crate = ":protobuf_upb",
rustc_flags = ["--cfg=upb_kernel"],
)
# The Rust Protobuf runtime using the cpp kernel.
#
# `rust_cpp_proto_library` implicitly depends on this target. This target cannot depend on
# `:rust_proto_library_kernel` build setting; it has to be fully functional under any value of that
# setting.
#
# See the comment for `:protobuf_upb` for discussion of the `shared.rs` file.
rust_library(
name = "protobuf_cpp",
srcs = [
"cpp.rs",
"internal.rs",
"optional.rs",
"proxied.rs",
"shared.rs",
"string.rs",
"vtable.rs",
],
crate_root = "shared.rs",
rustc_flags = ["--cfg=cpp_kernel"],
visibility = [
"//src/google/protobuf:__subpackages__",
"//rust:__subpackages__",
],
deps = [":utf8"],
)
rust_test(
name = "protobuf_cpp_test",
crate = ":protobuf_cpp",
rustc_flags = ["--cfg=cpp_kernel"],
)
rust_library(
name = "utf8",
srcs = ["utf8.rs"],
visibility = ["//visibility:private"],
)
proto_lang_toolchain(
name = "proto_rust_upb_toolchain",
command_line = "--rust_out=experimental-codegen=enabled,kernel=upb:$(OUT)",
progress_message = "Generating Rust proto_library %{label}",
runtime = ":protobuf_upb",
visibility = ["//visibility:public"],
)
proto_lang_toolchain(
name = "proto_rust_cpp_toolchain",
command_line = "--rust_out=experimental-codegen=enabled,kernel=cpp:$(OUT)",
progress_message = "Generating Rust proto_library %{label}",
runtime = ":protobuf_cpp",
visibility = ["//visibility:public"],
)
# This flag controls what kernel all Rust Protobufs are using in the current build.
string_flag(
name = "rust_proto_library_kernel",
build_setting_default = "cpp",
values = [
"upb",
"cpp",
],
)
config_setting(
name = "use_upb_kernel",
flag_values = {
":rust_proto_library_kernel": "upb",
},
)