fork/rules_rust

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

UebelAndreAdded missing CI for prost (#3053)a33f9011

main
18.1 KiB485 linesraw
1"""Rules for building protos in Rust with Prost and Tonic."""
2
3load("@rules_proto//proto:defs.bzl", "ProtoInfo", "proto_common")
4load("@rules_proto//proto:proto_common.bzl", proto_toolchains = "toolchains")
5load("@rules_rust//rust:defs.bzl", "rust_common")
6
7# buildifier: disable=bzl-visibility
8load("@rules_rust//rust/private:providers.bzl", "RustAnalyzerGroupInfo", "RustAnalyzerInfo")
9
10# buildifier: disable=bzl-visibility
11load("@rules_rust//rust/private:rust.bzl", "RUSTC_ATTRS")
12
13# buildifier: disable=bzl-visibility
14load("@rules_rust//rust/private:rust_analyzer.bzl", "write_rust_analyzer_spec_file")
15
16# buildifier: disable=bzl-visibility
17load("@rules_rust//rust/private:rustc.bzl", "rustc_compile_action")
18
19# buildifier: disable=bzl-visibility
20load("@rules_rust//rust/private:utils.bzl", "can_build_metadata")
21load("//:providers.bzl", "ProstProtoInfo")
22
23RUST_EDITION = "2021"
24
25TOOLCHAIN_TYPE = "@rules_rust_prost//:toolchain_type"
26
27def _create_proto_lang_toolchain(ctx, prost_toolchain):
28    proto_lang_toolchain = proto_common.ProtoLangToolchainInfo(
29        out_replacement_format_flag = "--prost_out=%s",
30        plugin_format_flag = prost_toolchain.prost_plugin_flag,
31        plugin = prost_toolchain.prost_plugin[DefaultInfo].files_to_run,
32        runtime = prost_toolchain.prost_runtime,
33        provided_proto_sources = depset(),
34        proto_compiler = ctx.attr._prost_process_wrapper[DefaultInfo].files_to_run,
35        protoc_opts = prost_toolchain.protoc_opts,
36        progress_message = "ProstGenProto %{label}",
37        mnemonic = "ProstGenProto",
38    )
39
40    return proto_lang_toolchain
41
42def _compile_proto(ctx, crate_name, proto_info, deps, prost_toolchain, rustfmt_toolchain = None):
43    deps_info_file = ctx.actions.declare_file(ctx.label.name + ".prost_deps_info")
44    dep_package_infos = [dep[ProstProtoInfo].package_info for dep in deps]
45    ctx.actions.write(
46        output = deps_info_file,
47        content = "\n".join([file.path for file in dep_package_infos]),
48    )
49
50    package_info_file = ctx.actions.declare_file(ctx.label.name + ".prost_package_info")
51    lib_rs = ctx.actions.declare_file("{}.lib.rs".format(ctx.label.name))
52
53    proto_compiler = prost_toolchain.proto_compiler
54    tools = depset([proto_compiler.executable])
55
56    direct_crate_names = [dep[ProstProtoInfo].dep_variant_info.crate_info.name for dep in deps]
57    additional_args = ctx.actions.args()
58
59    # Prost process wrapper specific args
60    additional_args.add("--protoc={}".format(proto_compiler.executable.path))
61    additional_args.add("--label={}".format(ctx.label))
62    additional_args.add("--out_librs={}".format(lib_rs.path))
63    additional_args.add("--package_info_output={}".format("{}={}".format(crate_name, package_info_file.path)))
64    additional_args.add("--deps_info={}".format(deps_info_file.path))
65    additional_args.add("--direct_dep_crate_names={}".format(",".join(direct_crate_names)))
66    additional_args.add("--prost_opt=compile_well_known_types")
67    additional_args.add("--descriptor_set={}".format(proto_info.direct_descriptor_set.path))
68    additional_args.add_all(prost_toolchain.prost_opts, format_each = "--prost_opt=%s")
69
70    if prost_toolchain.tonic_plugin:
71        tonic_plugin = prost_toolchain.tonic_plugin[DefaultInfo].files_to_run
72        additional_args.add(prost_toolchain.tonic_plugin_flag % tonic_plugin.executable.path)
73        additional_args.add("--tonic_opt=no_include")
74        additional_args.add("--tonic_opt=compile_well_known_types")
75        additional_args.add("--is_tonic")
76        additional_args.add_all(prost_toolchain.tonic_opts, format_each = "--tonic_opt=%s")
77        tools = depset([tonic_plugin.executable], transitive = [tools])
78
79    if rustfmt_toolchain:
80        additional_args.add("--rustfmt={}".format(rustfmt_toolchain.rustfmt.path))
81        tools = depset(transitive = [tools, rustfmt_toolchain.all_files])
82
83    additional_inputs = depset([deps_info_file, proto_info.direct_descriptor_set] + [dep[ProstProtoInfo].package_info for dep in deps])
84
85    proto_common.compile(
86        actions = ctx.actions,
87        proto_info = proto_info,
88        additional_tools = tools.to_list(),
89        additional_inputs = additional_inputs,
90        additional_args = additional_args,
91        generated_files = [lib_rs, package_info_file],
92        proto_lang_toolchain_info = _create_proto_lang_toolchain(ctx, prost_toolchain),
93        plugin_output = ctx.bin_dir.path,
94    )
95
96    return lib_rs, package_info_file
97
98def _get_crate_info(providers):
99    """Finds the CrateInfo provider in the list of providers."""
100    for provider in providers:
101        if hasattr(provider, "name"):
102            return provider
103    fail("Couldn't find a CrateInfo in the list of providers")
104
105def _get_dep_info(providers):
106    """Finds the DepInfo provider in the list of providers."""
107    for provider in providers:
108        if hasattr(provider, "direct_crates"):
109            return provider
110    fail("Couldn't find a DepInfo in the list of providers")
111
112def _get_cc_info(providers):
113    """Finds the CcInfo provider in the list of providers."""
114    for provider in providers:
115        if hasattr(provider, "linking_context"):
116            return provider
117    fail("Couldn't find a CcInfo in the list of providers")
118
119def _compile_rust(ctx, attr, crate_name, src, deps, edition):
120    """Compiles a Rust source file.
121
122    Args:
123      ctx (RuleContext): The rule context.
124      attr (Attrs): The current rule's attributes (`ctx.attr` for rules, `ctx.rule.attr` for aspects)
125      crate_name (str): The crate module name to use.
126      src (File): The crate root source file to be compiled.
127      deps (List of DepVariantInfo): A list of dependencies needed.
128      edition (str): The Rust edition to use.
129
130    Returns:
131      A DepVariantInfo provider.
132    """
133    toolchain = ctx.toolchains["@rules_rust//rust:toolchain_type"]
134    output_hash = repr(hash(src.path + ".prost"))
135
136    lib_name = "{prefix}{name}-{lib_hash}{extension}".format(
137        prefix = "lib",
138        name = crate_name,
139        lib_hash = output_hash,
140        extension = ".rlib",
141    )
142
143    rmeta_name = "{prefix}{name}-{lib_hash}{extension}".format(
144        prefix = "lib",
145        name = crate_name,
146        lib_hash = output_hash,
147        extension = ".rmeta",
148    )
149
150    lib = ctx.actions.declare_file(lib_name)
151    rmeta = None
152
153    if can_build_metadata(toolchain, ctx, "rlib"):
154        rmeta_name = "{prefix}{name}-{lib_hash}{extension}".format(
155            prefix = "lib",
156            name = crate_name,
157            lib_hash = output_hash,
158            extension = ".rmeta",
159        )
160        rmeta = ctx.actions.declare_file(rmeta_name)
161
162    providers = rustc_compile_action(
163        ctx = ctx,
164        attr = attr,
165        toolchain = toolchain,
166        crate_info_dict = dict(
167            name = crate_name,
168            type = "rlib",
169            root = src,
170            srcs = depset([src]),
171            deps = depset(deps),
172            proc_macro_deps = depset([]),
173            aliases = {},
174            output = lib,
175            metadata = rmeta,
176            edition = edition,
177            is_test = False,
178            rustc_env = {},
179            compile_data = depset([]),
180            compile_data_targets = depset([]),
181            owner = ctx.label,
182        ),
183        output_hash = output_hash,
184    )
185
186    crate_info = _get_crate_info(providers)
187    dep_info = _get_dep_info(providers)
188    cc_info = _get_cc_info(providers)
189
190    return rust_common.dep_variant_info(
191        crate_info = crate_info,
192        dep_info = dep_info,
193        cc_info = cc_info,
194        build_info = None,
195    )
196
197def _rust_prost_aspect_impl(target, ctx):
198    if ProstProtoInfo in target:
199        return []
200
201    runtime_deps = []
202
203    rustfmt_toolchain = ctx.toolchains["@rules_rust//rust/rustfmt:toolchain_type"]
204    prost_toolchain = ctx.toolchains[TOOLCHAIN_TYPE]
205    for prost_runtime in [prost_toolchain.prost_runtime, prost_toolchain.tonic_runtime]:
206        if not prost_runtime:
207            continue
208        if rust_common.crate_group_info in prost_runtime:
209            crate_group_info = prost_runtime[rust_common.crate_group_info]
210            runtime_deps.extend(crate_group_info.dep_variant_infos.to_list())
211        else:
212            runtime_deps.append(rust_common.dep_variant_info(
213                crate_info = prost_runtime[rust_common.crate_info] if rust_common.crate_info in prost_runtime else None,
214                dep_info = prost_runtime[rust_common.dep_info] if rust_common.dep_info in prost_runtime else None,
215                cc_info = prost_runtime[CcInfo] if CcInfo in prost_runtime else None,
216                build_info = None,
217            ))
218
219    proto_deps = getattr(ctx.rule.attr, "deps", [])
220
221    direct_deps = []
222    transitive_deps = [depset(runtime_deps)]
223    rust_analyzer_deps = []
224    for proto_dep in proto_deps:
225        proto_info = proto_dep[ProstProtoInfo]
226
227        direct_deps.append(proto_info.dep_variant_info)
228        transitive_deps.append(depset(
229            [proto_info.dep_variant_info],
230            transitive = [proto_info.transitive_dep_infos],
231        ))
232
233        if RustAnalyzerInfo in proto_dep:
234            rust_analyzer_deps.append(proto_dep[RustAnalyzerInfo])
235
236    deps = runtime_deps + direct_deps
237
238    crate_name = ctx.label.name.replace("-", "_").replace("/", "_")
239
240    proto_info = target[ProtoInfo]
241
242    lib_rs, package_info_file = _compile_proto(
243        ctx = ctx,
244        crate_name = crate_name,
245        proto_info = proto_info,
246        deps = proto_deps,
247        prost_toolchain = prost_toolchain,
248        rustfmt_toolchain = rustfmt_toolchain,
249    )
250
251    dep_variant_info = _compile_rust(
252        ctx = ctx,
253        attr = ctx.rule.attr,
254        crate_name = crate_name,
255        src = lib_rs,
256        deps = deps,
257        edition = RUST_EDITION,
258    )
259
260    # Always add `test` & `debug_assertions`. See rust-analyzer source code:
261    # https://github.com/rust-analyzer/rust-analyzer/blob/2021-11-15/crates/project_model/src/workspace.rs#L529-L531
262    cfgs = ["test", "debug_assertions"]
263
264    crate_id = "prost-" + dep_variant_info.crate_info.root.path
265
266    rust_analyzer_info = write_rust_analyzer_spec_file(ctx, ctx.rule.attr, ctx.label, RustAnalyzerInfo(
267        id = crate_id,
268        aliases = {},
269        crate = dep_variant_info.crate_info,
270        cfgs = cfgs,
271        env = dep_variant_info.crate_info.rustc_env,
272        deps = depset([dep.id for dep in rust_analyzer_deps]).to_list(),
273        crate_specs = depset(transitive = [dep.crate_specs for dep in rust_analyzer_deps]),
274        proc_macro_dylib_path = None,
275        build_info = dep_variant_info.build_info,
276    ))
277
278    return [
279        ProstProtoInfo(
280            dep_variant_info = dep_variant_info,
281            transitive_dep_infos = depset(transitive = transitive_deps),
282            package_info = package_info_file,
283        ),
284        rust_analyzer_info,
285        OutputGroupInfo(rust_generated_srcs = [lib_rs]),
286    ]
287
288rust_prost_aspect = aspect(
289    doc = "An aspect used to generate and compile proto files with Prost.",
290    implementation = _rust_prost_aspect_impl,
291    attr_aspects = ["deps"],
292    attrs = {
293        "_collect_cc_coverage": attr.label(
294            default = Label("@rules_rust//util:collect_coverage"),
295            executable = True,
296            cfg = "exec",
297        ),
298        "_grep_includes": attr.label(
299            allow_single_file = True,
300            default = Label("@bazel_tools//tools/cpp:grep-includes"),
301            cfg = "exec",
302        ),
303        "_prost_process_wrapper": attr.label(
304            doc = "The wrapper script for the Prost protoc plugin.",
305            cfg = "exec",
306            executable = True,
307            default = Label("//private:protoc_wrapper"),
308        ),
309    } | RUSTC_ATTRS,
310    fragments = ["cpp"],
311    toolchains = [
312        TOOLCHAIN_TYPE,
313        "@bazel_tools//tools/cpp:toolchain_type",
314        "@rules_rust//rust:toolchain_type",
315        "@rules_rust//rust/rustfmt:toolchain_type",
316    ],
317)
318
319def _rust_prost_library_impl(ctx):
320    proto_dep = ctx.attr.proto
321    rust_proto_info = proto_dep[ProstProtoInfo]
322    dep_variant_info = rust_proto_info.dep_variant_info
323
324    prost_toolchain = ctx.toolchains[TOOLCHAIN_TYPE]
325
326    transitive = []
327    if prost_toolchain.include_transitive_deps:
328        transitive = [rust_proto_info.transitive_dep_infos]
329
330    return [
331        DefaultInfo(files = depset([dep_variant_info.crate_info.output])),
332        rust_common.crate_group_info(
333            dep_variant_infos = depset(
334                [dep_variant_info],
335                transitive = transitive,
336            ),
337        ),
338        RustAnalyzerGroupInfo(
339            crate_specs = proto_dep[RustAnalyzerInfo].crate_specs,
340            deps = proto_dep[RustAnalyzerInfo].deps,
341        ),
342    ]
343
344rust_prost_library = rule(
345    doc = "A rule for generating a Rust library using Prost.",
346    implementation = _rust_prost_library_impl,
347    attrs = {
348        "proto": attr.label(
349            doc = "A `proto_library` target for which to generate Rust gencode.",
350            providers = [ProtoInfo],
351            aspects = [rust_prost_aspect],
352            mandatory = True,
353        ),
354        "_collect_cc_coverage": attr.label(
355            default = Label("@rules_rust//util:collect_coverage"),
356            executable = True,
357            cfg = "exec",
358        ),
359    },
360    toolchains = [
361        TOOLCHAIN_TYPE,
362    ],
363)
364
365def _rust_prost_toolchain_impl(ctx):
366    tonic_attrs = [ctx.attr.tonic_plugin_flag, ctx.attr.tonic_plugin, ctx.attr.tonic_runtime]
367    if any(tonic_attrs) and not all(tonic_attrs):
368        fail("When one tonic attribute is added, all must be added")
369
370    proto_toolchain = proto_toolchains.find_toolchain(
371        ctx,
372        legacy_attr = "_legacy_proto_toolchain",
373        toolchain_type = "@rules_proto//proto:toolchain_type",
374    )
375
376    if ctx.attr.proto_compiler:
377        # buildifier: disable=print
378        print("WARN: rust_prost_toolchain's proto_compiler attribute is deprecated. Make sure your rules_proto dependency is at least version 6.0.0 and stop setting proto_compiler")
379        proto_compiler = ctx.attr.proto_compiler[DefaultInfo].files_to_run
380    else:
381        proto_compiler = proto_toolchain.proto_compiler
382
383    return [platform_common.ToolchainInfo(
384        prost_opts = ctx.attr.prost_opts,
385        prost_plugin = ctx.attr.prost_plugin,
386        prost_plugin_flag = ctx.attr.prost_plugin_flag,
387        prost_runtime = ctx.attr.prost_runtime,
388        prost_types = ctx.attr.prost_types,
389        proto_compiler = proto_compiler,
390        protoc_opts = ctx.fragments.proto.experimental_protoc_opts,
391        tonic_opts = ctx.attr.tonic_opts,
392        tonic_plugin = ctx.attr.tonic_plugin,
393        tonic_plugin_flag = ctx.attr.tonic_plugin_flag,
394        tonic_runtime = ctx.attr.tonic_runtime,
395        include_transitive_deps = ctx.attr.include_transitive_deps,
396    )]
397
398rust_prost_toolchain = rule(
399    implementation = _rust_prost_toolchain_impl,
400    doc = "Rust Prost toolchain rule.",
401    fragments = ["proto"],
402    attrs = dict({
403        "include_transitive_deps": attr.bool(
404            doc = "Whether to include transitive dependencies. If set to True, all transitive dependencies will directly accessible by the dependent crate.",
405            default = False,
406        ),
407        "prost_opts": attr.string_list(
408            doc = "Additional options to add to Prost.",
409        ),
410        "prost_plugin": attr.label(
411            doc = "Additional plugins to add to Prost.",
412            cfg = "exec",
413            executable = True,
414            mandatory = True,
415        ),
416        "prost_plugin_flag": attr.string(
417            doc = "Prost plugin flag format. (e.g. `--plugin=protoc-gen-prost=%s`)",
418            default = "--plugin=protoc-gen-prost=%s",
419        ),
420        "prost_runtime": attr.label(
421            doc = "The Prost runtime crates to use.",
422            providers = [[rust_common.crate_info], [rust_common.crate_group_info]],
423            mandatory = True,
424        ),
425        "prost_types": attr.label(
426            doc = "The Prost types crates to use.",
427            providers = [[rust_common.crate_info], [rust_common.crate_group_info]],
428            mandatory = True,
429        ),
430        "proto_compiler": attr.label(
431            doc = "The protoc compiler to use. Note that this attribute is deprecated - prefer to use --incompatible_enable_proto_toolchain_resolution.",
432            cfg = "exec",
433            executable = True,
434        ),
435        "tonic_opts": attr.string_list(
436            doc = "Additional options to add to Tonic.",
437        ),
438        "tonic_plugin": attr.label(
439            doc = "Additional plugins to add to Tonic.",
440            cfg = "exec",
441            executable = True,
442        ),
443        "tonic_plugin_flag": attr.string(
444            doc = "Tonic plugin flag format. (e.g. `--plugin=protoc-gen-tonic=%s`))",
445            default = "--plugin=protoc-gen-tonic=%s",
446        ),
447        "tonic_runtime": attr.label(
448            doc = "The Tonic runtime crates to use.",
449            providers = [[rust_common.crate_info], [rust_common.crate_group_info]],
450        ),
451    }, **proto_toolchains.if_legacy_toolchain({
452        "_legacy_proto_toolchain": attr.label(
453            default = Label("//private:legacy_proto_toolchain"),
454        ),
455    })),
456    toolchains = proto_toolchains.use_toolchain("@rules_proto//proto:toolchain_type"),
457)
458
459def _current_prost_runtime_impl(ctx):
460    toolchain = ctx.toolchains[TOOLCHAIN_TYPE]
461
462    runtime_deps = []
463
464    for target in [toolchain.prost_runtime, toolchain.prost_types]:
465        if rust_common.crate_group_info in target:
466            crate_group_info = target[rust_common.crate_group_info]
467            runtime_deps.extend(crate_group_info.dep_variant_infos.to_list())
468        else:
469            runtime_deps.append(rust_common.dep_variant_info(
470                crate_info = target[rust_common.crate_info] if rust_common.crate_info in target else None,
471                dep_info = target[rust_common.dep_info] if rust_common.dep_info in target else None,
472                cc_info = target[CcInfo] if CcInfo in target else None,
473                build_info = None,
474            ))
475
476    return [rust_common.crate_group_info(
477        dep_variant_infos = depset(runtime_deps),
478    )]
479
480current_prost_runtime = rule(
481    doc = "A rule for accessing the current Prost toolchain components needed by the process wrapper",
482    provides = [rust_common.crate_group_info],
483    implementation = _current_prost_runtime_impl,
484    toolchains = [TOOLCHAIN_TYPE],
485)