rules_rust/test/unit/pipelined_compilation/wrap.bzl at 104a5013299ba02b117b00fe94f64e57bde74850 · hermeticbuild/rules_rust · GitHub

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
"""A custom rule that wraps a crate called to_wrap."""

load("@rules_cc//cc/common:cc_info.bzl", "CcInfo")

# buildifier: disable=bzl-visibility
load("//rust/private:providers.bzl", "BuildInfo", "CrateInfo", "DepInfo", "DepVariantInfo")

# buildifier: disable=bzl-visibility
load("//rust/private:rustc.bzl", "rustc_compile_action")

# buildifier: disable=bzl-visibility
load("//rust/private:utils.bzl", "can_use_metadata_for_pipelining")

_CONTENT = """\
// crate_name: {}
use to_wrap::to_wrap;

pub fn wrap() {{
    to_wrap();
}}
"""

def _wrap_impl(ctx):
    rs_file = ctx.actions.declare_file(ctx.label.name + "_wrapped.rs")
    crate_name = ctx.attr.crate_name if ctx.attr.crate_name else ctx.label.name
    ctx.actions.write(
        output = rs_file,
        content = _CONTENT.format(crate_name),
    )

    toolchain = ctx.toolchains[Label("//rust:toolchain")]

    # Determine unique hash for this rlib
    output_hash = repr(hash(rs_file.path))
    crate_type = "rlib"

    rust_lib_name = "{prefix}{name}-{lib_hash}{extension}".format(
        prefix = "lib",
        name = crate_name,
        lib_hash = output_hash,
        extension = ".rlib",
    )
    rust_metadata_name = "{prefix}{name}-{lib_hash}{extension}".format(
        prefix = "lib",
        name = crate_name,
        lib_hash = output_hash,
        extension = ".rmeta",
    )

    tgt = ctx.attr.target
    deps = [DepVariantInfo(
        crate_info = tgt[CrateInfo] if CrateInfo in tgt else None,
        dep_info = tgt[DepInfo] if DepInfo in tgt else None,
        build_info = tgt[BuildInfo] if BuildInfo in tgt else None,
        cc_info = tgt[CcInfo] if CcInfo in tgt else None,
    )]

    rust_lib = ctx.actions.declare_file(rust_lib_name)
    rust_metadata = None
    if ctx.attr.generate_metadata:
        rust_metadata = ctx.actions.declare_file(rust_metadata_name)
    return rustc_compile_action(
        ctx = ctx,
        attr = ctx.attr,
        toolchain = toolchain,
        crate_info_dict = dict(
            name = crate_name,
            type = crate_type,
            root = rs_file,
            srcs = depset([rs_file]),
            deps = deps,
            proc_macro_deps = [],
            aliases = {},
            output = rust_lib,
            metadata = rust_metadata,
            metadata_supports_pipelining = can_use_metadata_for_pipelining(toolchain, crate_type) and
                                           ctx.attr.generate_metadata,
            owner = ctx.label,
            edition = "2018",
            compile_data = depset([]),
            compile_data_targets = depset([]),
            rustc_env = {},
            is_test = False,
        ),
        output_hash = output_hash,
    )

wrap = rule(
    implementation = _wrap_impl,
    attrs = {
        "crate_name": attr.string(),
        "generate_metadata": attr.bool(default = False),
        "target": attr.label(),
        "_always_enable_metadata_output_groups": attr.label(
            default = Label("//rust/settings:always_enable_metadata_output_groups"),
        ),
        "_error_format": attr.label(
            default = Label("//rust/settings:error_format"),
        ),
        "_process_wrapper": attr.label(
            default = Label("//util/process_wrapper"),
            executable = True,
            allow_single_file = True,
            cfg = "exec",
        ),
    },
    toolchains = ["@rules_rust//rust:toolchain", "@bazel_tools//tools/cpp:toolchain_type"],
    fragments = ["cpp"],
)