fork/rules_rust

git clone https://git.julia.blue/fork/rules_rust

Paul FarielloFix data and compile_data for rust_doc (#1741)9803d303

rust-analyzer
14.2 KiB441 linesraw
1# Copyright 2018 The Bazel Authors. All rights reserved.
2#
3# Licensed under the Apache License, Version 2.0 (the "License");
4# you may not use this file except in compliance with the License.
5# You may obtain a copy of the License at
6#
7#    http://www.apache.org/licenses/LICENSE-2.0
8#
9# Unless required by applicable law or agreed to in writing, software
10# distributed under the License is distributed on an "AS IS" BASIS,
11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12# See the License for the specific language governing permissions and
13# limitations under the License.
14
15"""Rust Protobuf Rules
16
17These build rules are used for building [protobufs][protobuf]/[gRPC][grpc] in [Rust][rust] with Bazel.
18
19[rust]: http://www.rust-lang.org/
20[protobuf]: https://developers.google.com/protocol-buffers/
21[grpc]: https://grpc.io
22
23### Setup
24
25To use the Rust proto rules, add the following to your `WORKSPACE` file to add the
26external repositories for the Rust proto toolchain (in addition to the [rust rules setup](..)):
27
28```python
29load("//proto:repositories.bzl", "rust_proto_repositories")
30
31rust_proto_repositories()
32```
33"""
34
35load("@rules_proto//proto:defs.bzl", "ProtoInfo")
36load(
37    "//proto:toolchain.bzl",
38    _generate_proto = "rust_generate_proto",
39    _generated_file_stem = "generated_file_stem",
40)
41load("//rust:defs.bzl", "rust_common")
42
43# buildifier: disable=bzl-visibility
44load("//rust/private:rustc.bzl", "rustc_compile_action")
45
46# buildifier: disable=bzl-visibility
47load("//rust/private:utils.bzl", "can_build_metadata", "compute_crate_name", "determine_output_hash", "find_toolchain", "transform_deps")
48
49RustProtoInfo = provider(
50    doc = "Rust protobuf provider info",
51    fields = {
52        "proto_sources": "List[string]: list of source paths of protos",
53        "transitive_proto_sources": "depset[string]",
54    },
55)
56
57def _compute_proto_source_path(file, source_root_attr):
58    """Take the short path of file and make it suitable for protoc.
59
60    Args:
61        file (File): The target source file.
62        source_root_attr (str): The directory relative to which the `.proto` \
63            files defined in the proto_library are defined.
64
65    Returns:
66        str: The protoc suitible path of `file`
67    """
68
69    # Bazel creates symlinks to the .proto files under a directory called
70    # "_virtual_imports/<rule name>" if we do any sort of munging of import
71    # paths (e.g. using strip_import_prefix / import_prefix attributes)
72    virtual_imports = "/_virtual_imports/"
73    if virtual_imports in file.path:
74        return file.path.split(virtual_imports)[1].split("/", 1)[1]
75
76    # For proto, they need to be requested with their absolute name to be
77    # compatible with the descriptor_set passed by proto_library.
78    # I.e. if you compile a protobuf at @repo1//package:file.proto, the proto
79    # compiler would generate a file descriptor with the path
80    # `package/file.proto`. Since we compile from the proto descriptor, we need
81    # to pass the list of descriptors and the list of path to compile.
82    # For the precedent example, the file (noted `f`) would have
83    # `f.short_path` returns `external/repo1/package/file.proto`.
84    # In addition, proto_library can provide a proto_source_path to change the base
85    # path, which should a be a prefix.
86    path = file.short_path
87
88    # Strip external prefix.
89    path = path.split("/", 2)[2] if path.startswith("../") else path
90
91    # Strip source_root.
92    if path.startswith(source_root_attr):
93        return path[len(source_root_attr):]
94    else:
95        return path
96
97def _rust_proto_aspect_impl(target, ctx):
98    """The implementation of the `rust_proto_aspect` aspect
99
100    Args:
101        target (Target): The target to which the aspect is applied
102        ctx (ctx): The rule context which the targetis created from
103
104    Returns:
105        list: A list containg a `RustProtoInfo` provider
106    """
107    if ProtoInfo not in target:
108        return None
109
110    if hasattr(ctx.rule.attr, "proto_source_root"):
111        source_root = ctx.rule.attr.proto_source_root
112    else:
113        source_root = ""
114
115    if source_root and source_root[-1] != "/":
116        source_root += "/"
117
118    sources = [
119        _compute_proto_source_path(f, source_root)
120        for f in target[ProtoInfo].direct_sources
121    ]
122    transitive_sources = [
123        f[RustProtoInfo].transitive_proto_sources
124        for f in ctx.rule.attr.deps
125        if RustProtoInfo in f
126    ]
127    return [RustProtoInfo(
128        proto_sources = sources,
129        transitive_proto_sources = depset(transitive = transitive_sources, direct = sources),
130    )]
131
132_rust_proto_aspect = aspect(
133    doc = "An aspect that gathers rust proto direct and transitive sources",
134    implementation = _rust_proto_aspect_impl,
135    attr_aspects = ["deps"],
136)
137
138def _gen_lib(ctx, grpc, srcs, lib):
139    """Generate a lib.rs file for the crates.
140
141    Args:
142        ctx (ctx): The current rule's context object
143        grpc (bool): True if the current rule is a `gRPC` rule.
144        srcs (list): A list of protoc suitible file paths (str).
145        lib (File): The File object where the rust source file should be written
146    """
147    content = ["extern crate protobuf;"]
148    if grpc:
149        content.append("extern crate grpc;")
150        content.append("extern crate tls_api;")
151    for f in srcs.to_list():
152        content.append("pub mod %s;" % _generated_file_stem(f))
153        content.append("pub use %s::*;" % _generated_file_stem(f))
154        if grpc:
155            content.append("pub mod %s_grpc;" % _generated_file_stem(f))
156            content.append("pub use %s_grpc::*;" % _generated_file_stem(f))
157    ctx.actions.write(lib, "\n".join(content))
158
159def _expand_provider(lst, provider):
160    """Gathers a list of a specific provider from a list of targets.
161
162    Args:
163        lst (list): A list of Targets
164        provider (Provider): The target provider type to extract `lst`
165
166    Returns:
167        list: A list of providers of the type from `provider`.
168    """
169    return [el[provider] for el in lst if provider in el]
170
171def _rust_proto_compile(protos, descriptor_sets, imports, crate_name, ctx, is_grpc, compile_deps, toolchain):
172    """Create and run a rustc compile action based on the current rule's attributes
173
174    Args:
175        protos (depset): Paths of protos to compile.
176        descriptor_sets (depset): A set of transitive protobuf `FileDescriptorSet`s
177        imports (depset): A set of transitive protobuf Imports.
178        crate_name (str): The name of the Crate for the current target
179        ctx (ctx): The current rule's context object
180        is_grpc (bool): True if the current rule is a `gRPC` rule.
181        compile_deps (list): A list of Rust dependencies (`List[Target]`)
182        toolchain (rust_toolchain): the current `rust_toolchain`.
183
184    Returns:
185        list: A list of providers, see `rustc_compile_action`
186    """
187
188    # Create all the source in a specific folder
189    proto_toolchain = ctx.toolchains[Label("//proto:toolchain_type")]
190    output_dir = "%s.%s.rust" % (crate_name, "grpc" if is_grpc else "proto")
191
192    # Generate the proto stubs
193    srcs = _generate_proto(
194        ctx,
195        descriptor_sets,
196        protos = protos,
197        imports = imports,
198        output_dir = output_dir,
199        proto_toolchain = proto_toolchain,
200        is_grpc = is_grpc,
201    )
202
203    # and lib.rs
204    lib_rs = ctx.actions.declare_file("%s/lib.rs" % output_dir)
205    _gen_lib(ctx, is_grpc, protos, lib_rs)
206    srcs.append(lib_rs)
207
208    # And simulate rust_library behavior
209    output_hash = determine_output_hash(lib_rs, ctx.label)
210    rust_lib = ctx.actions.declare_file("%s/lib%s-%s.rlib" % (
211        output_dir,
212        crate_name,
213        output_hash,
214    ))
215    rust_metadata = None
216    if can_build_metadata(toolchain, ctx, "rlib"):
217        rust_metadata = ctx.actions.declare_file("%s/lib%s-%s.rmeta" % (
218            output_dir,
219            crate_name,
220            output_hash,
221        ))
222
223    # Gather all dependencies for compilation
224    compile_action_deps = depset(
225        transform_deps(
226            compile_deps +
227            proto_toolchain.grpc_compile_deps if is_grpc else proto_toolchain.proto_compile_deps,
228        ),
229    )
230
231    return rustc_compile_action(
232        ctx = ctx,
233        attr = ctx.attr,
234        toolchain = toolchain,
235        crate_info = rust_common.create_crate_info(
236            name = crate_name,
237            type = "rlib",
238            root = lib_rs,
239            srcs = depset(srcs),
240            deps = compile_action_deps,
241            proc_macro_deps = depset([]),
242            aliases = {},
243            output = rust_lib,
244            metadata = rust_metadata,
245            edition = proto_toolchain.edition,
246            rustc_env = {},
247            is_test = False,
248            compile_data = depset([target.files for target in getattr(ctx.attr, "compile_data", [])]),
249            compile_data_targets = depset(getattr(ctx.attr, "compile_data", [])),
250            wrapped_crate_type = None,
251            owner = ctx.label,
252        ),
253        output_hash = output_hash,
254    )
255
256def _rust_protogrpc_library_impl(ctx, is_grpc):
257    """Implementation of the rust_(proto|grpc)_library.
258
259    Args:
260        ctx (ctx): The current rule's context object
261        is_grpc (bool): True if the current rule is a `gRPC` rule.
262
263    Returns:
264        list: A list of providers, see `_rust_proto_compile`
265    """
266    proto = _expand_provider(ctx.attr.deps, ProtoInfo)
267    transitive_sources = [
268        f[RustProtoInfo].transitive_proto_sources
269        for f in ctx.attr.deps
270        if RustProtoInfo in f
271    ]
272
273    toolchain = find_toolchain(ctx)
274    crate_name = compute_crate_name(ctx.workspace_name, ctx.label, toolchain)
275
276    return _rust_proto_compile(
277        protos = depset(transitive = transitive_sources),
278        descriptor_sets = depset(transitive = [p.transitive_descriptor_sets for p in proto]),
279        imports = depset(transitive = [p.transitive_imports for p in proto]),
280        crate_name = crate_name,
281        ctx = ctx,
282        is_grpc = is_grpc,
283        compile_deps = ctx.attr.rust_deps,
284        toolchain = toolchain,
285    )
286
287def _rust_proto_library_impl(ctx):
288    """The implementation of the `rust_proto_library` rule
289
290    Args:
291        ctx (ctx): The rule's context object.
292
293    Returns:
294        list: A list of providers, see `_rust_protogrpc_library_impl`
295    """
296    return _rust_protogrpc_library_impl(ctx, False)
297
298rust_proto_library = rule(
299    implementation = _rust_proto_library_impl,
300    attrs = {
301        "deps": attr.label_list(
302            doc = (
303                "List of proto_library dependencies that will be built. " +
304                "One crate for each proto_library will be created with the corresponding stubs."
305            ),
306            mandatory = True,
307            providers = [ProtoInfo],
308            aspects = [_rust_proto_aspect],
309        ),
310        "rust_deps": attr.label_list(
311            doc = "The crates the generated library depends on.",
312        ),
313        "_cc_toolchain": attr.label(
314            default = Label("@bazel_tools//tools/cpp:current_cc_toolchain"),
315        ),
316        "_optional_output_wrapper": attr.label(
317            executable = True,
318            cfg = "exec",
319            default = Label("//proto:optional_output_wrapper"),
320        ),
321        "_process_wrapper": attr.label(
322            default = Label("//util/process_wrapper"),
323            executable = True,
324            allow_single_file = True,
325            cfg = "exec",
326        ),
327    },
328    fragments = ["cpp"],
329    host_fragments = ["cpp"],
330    toolchains = [
331        str(Label("//proto:toolchain_type")),
332        str(Label("//rust:toolchain_type")),
333        "@bazel_tools//tools/cpp:toolchain_type",
334    ],
335    # TODO: Remove once (bazelbuild/bazel#11584) is closed and the rules use
336    # the version of Bazel that issue was closed on as the min supported version
337    incompatible_use_toolchain_transition = True,
338    doc = """\
339Builds a Rust library crate from a set of `proto_library`s.
340
341Example:
342
343```python
344load("@rules_rust//proto:proto.bzl", "rust_proto_library")
345
346proto_library(
347    name = "my_proto",
348    srcs = ["my.proto"]
349)
350
351rust_proto_library(
352    name = "rust",
353    deps = [":my_proto"],
354)
355
356rust_binary(
357    name = "my_proto_binary",
358    srcs = ["my_proto_binary.rs"],
359    deps = [":rust"],
360)
361```
362""",
363)
364
365def _rust_grpc_library_impl(ctx):
366    """The implementation of the `rust_grpc_library` rule
367
368    Args:
369        ctx (ctx): The rule's context object
370
371    Returns:
372        list: A list of providers. See `_rust_protogrpc_library_impl`
373    """
374    return _rust_protogrpc_library_impl(ctx, True)
375
376rust_grpc_library = rule(
377    implementation = _rust_grpc_library_impl,
378    attrs = {
379        "deps": attr.label_list(
380            doc = (
381                "List of proto_library dependencies that will be built. " +
382                "One crate for each proto_library will be created with the corresponding gRPC stubs."
383            ),
384            mandatory = True,
385            providers = [ProtoInfo],
386            aspects = [_rust_proto_aspect],
387        ),
388        "rust_deps": attr.label_list(
389            doc = "The crates the generated library depends on.",
390        ),
391        "_cc_toolchain": attr.label(
392            default = "@bazel_tools//tools/cpp:current_cc_toolchain",
393        ),
394        "_optional_output_wrapper": attr.label(
395            executable = True,
396            cfg = "exec",
397            default = Label("//proto:optional_output_wrapper"),
398        ),
399        "_process_wrapper": attr.label(
400            default = Label("//util/process_wrapper"),
401            executable = True,
402            allow_single_file = True,
403            cfg = "exec",
404        ),
405    },
406    fragments = ["cpp"],
407    host_fragments = ["cpp"],
408    toolchains = [
409        str(Label("//proto:toolchain_type")),
410        str(Label("//rust:toolchain_type")),
411        "@bazel_tools//tools/cpp:toolchain_type",
412    ],
413    # TODO: Remove once (bazelbuild/bazel#11584) is closed and the rules use
414    # the version of Bazel that issue was closed on as the min supported version
415    incompatible_use_toolchain_transition = True,
416    doc = """\
417Builds a Rust library crate from a set of `proto_library`s suitable for gRPC.
418
419Example:
420
421```python
422load("//proto:proto.bzl", "rust_grpc_library")
423
424proto_library(
425    name = "my_proto",
426    srcs = ["my.proto"]
427)
428
429rust_grpc_library(
430    name = "rust",
431    deps = [":my_proto"],
432)
433
434rust_binary(
435    name = "my_service",
436    srcs = ["my_service.rs"],
437    deps = [":rust"],
438)
439```
440""",
441)