fork/rules_rust

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

scentiniHave rust_test put its compilation outputs in a subdirectory (#1434)26344d4c

0.7.0
42.6 KiB1278 linesraw
1# Copyright 2015 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# buildifier: disable=module-docstring
16load("//rust/private:common.bzl", "rust_common")
17load("//rust/private:rustc.bzl", "rustc_compile_action")
18load(
19    "//rust/private:utils.bzl",
20    "compute_crate_name",
21    "dedent",
22    "determine_output_hash",
23    "expand_dict_value_locations",
24    "find_toolchain",
25    "get_import_macro_deps",
26    "transform_deps",
27)
28
29# TODO(marco): Separate each rule into its own file.
30
31def _assert_no_deprecated_attributes(_ctx):
32    """Forces a failure if any deprecated attributes were specified
33
34    Args:
35        _ctx (ctx): The current rule's context object
36    """
37    pass
38
39def _assert_correct_dep_mapping(ctx):
40    """Forces a failure if proc_macro_deps and deps are mixed inappropriately
41
42    Args:
43        ctx (ctx): The current rule's context object
44    """
45    for dep in ctx.attr.deps:
46        if rust_common.crate_info in dep:
47            if dep[rust_common.crate_info].type == "proc-macro":
48                fail(
49                    "{} listed {} in its deps, but it is a proc-macro. It should instead be in the bazel property proc_macro_deps.".format(
50                        ctx.label,
51                        dep.label,
52                    ),
53                )
54    for dep in ctx.attr.proc_macro_deps:
55        type = dep[rust_common.crate_info].type
56        if type != "proc-macro":
57            fail(
58                "{} listed {} in its proc_macro_deps, but it is not proc-macro, it is a {}. It should probably instead be listed in deps.".format(
59                    ctx.label,
60                    dep.label,
61                    type,
62                ),
63            )
64
65def _determine_lib_name(name, crate_type, toolchain, lib_hash = None):
66    """See https://github.com/bazelbuild/rules_rust/issues/405
67
68    Args:
69        name (str): The name of the current target
70        crate_type (str): The `crate_type`
71        toolchain (rust_toolchain): The current `rust_toolchain`
72        lib_hash (str, optional): The hashed crate root path
73
74    Returns:
75        str: A unique library name
76    """
77    extension = None
78    prefix = ""
79    if crate_type in ("dylib", "cdylib", "proc-macro"):
80        extension = toolchain.dylib_ext
81    elif crate_type == "staticlib":
82        extension = toolchain.staticlib_ext
83    elif crate_type in ("lib", "rlib"):
84        # All platforms produce 'rlib' here
85        extension = ".rlib"
86        prefix = "lib"
87    elif crate_type == "bin":
88        fail("crate_type of 'bin' was detected in a rust_library. Please compile " +
89             "this crate as a rust_binary instead.")
90
91    if not extension:
92        fail(("Unknown crate_type: {}. If this is a cargo-supported crate type, " +
93              "please file an issue!").format(crate_type))
94
95    prefix = "lib"
96    if (toolchain.target_triple.find("windows") != -1) and crate_type not in ("lib", "rlib"):
97        prefix = ""
98    if toolchain.target_arch == "wasm32" and crate_type == "cdylib":
99        prefix = ""
100
101    return "{prefix}{name}{lib_hash}{extension}".format(
102        prefix = prefix,
103        name = name,
104        lib_hash = "-" + lib_hash if lib_hash else "",
105        extension = extension,
106    )
107
108def get_edition(attr, toolchain, label):
109    """Returns the Rust edition from either the current rule's attirbutes or the current `rust_toolchain`
110
111    Args:
112        attr (struct): The current rule's attributes
113        toolchain (rust_toolchain): The `rust_toolchain` for the current target
114        label (Label): The label of the target being built
115
116    Returns:
117        str: The target Rust edition
118    """
119    if getattr(attr, "edition"):
120        return attr.edition
121    elif not toolchain.default_edition:
122        fail("Attribute `edition` is required for {}.".format(label))
123    else:
124        return toolchain.default_edition
125
126def _transform_sources(ctx, srcs, crate_root):
127    """Creates symlinks of the source files if needed.
128
129    Rustc assumes that the source files are located next to the crate root.
130    In case of a mix between generated and non-generated source files, this
131    we violate this assumption, as part of the sources will be located under
132    bazel-out/... . In order to allow for targets that contain both generated
133    and non-generated source files, we generate symlinks for all non-generated
134    files.
135
136    Args:
137        ctx (struct): The current rule's context.
138        srcs (List[File]): The sources listed in the `srcs` attribute
139        crate_root (File): The file specified in the `crate_root` attribute,
140                           if it exists, otherwise None
141
142    Returns:
143        Tuple(List[File], File): The transformed srcs and crate_root
144    """
145    has_generated_sources = len([src for src in srcs if not src.is_source]) > 0
146
147    if not has_generated_sources:
148        return srcs, crate_root
149
150    generated_sources = []
151
152    generated_root = crate_root
153
154    if crate_root and (crate_root.is_source or crate_root.root.path != ctx.bin_dir.path):
155        generated_root = ctx.actions.declare_file(crate_root.basename)
156        ctx.actions.symlink(
157            output = generated_root,
158            target_file = crate_root,
159            progress_message = "Creating symlink to source file: {}".format(crate_root.path),
160        )
161    if generated_root:
162        generated_sources.append(generated_root)
163
164    for src in srcs:
165        # We took care of the crate root above.
166        if src == crate_root:
167            continue
168        if src.is_source or src.root.path != ctx.bin_dir.path:
169            src_symlink = ctx.actions.declare_file(src.basename)
170            ctx.actions.symlink(
171                output = src_symlink,
172                target_file = src,
173                progress_message = "Creating symlink to source file: {}".format(src.path),
174            )
175            generated_sources.append(src_symlink)
176        else:
177            generated_sources.append(src)
178
179    return generated_sources, generated_root
180
181def crate_root_src(name, srcs, crate_type):
182    """Determines the source file for the crate root, should it not be specified in `attr.crate_root`.
183
184    Args:
185        name (str): The name of the target.
186        srcs (list): A list of all sources for the target Crate.
187        crate_type (str): The type of this crate ("bin", "lib", "rlib", "cdylib", etc).
188
189    Returns:
190        File: The root File object for a given crate. See the following links for more details:
191            - https://doc.rust-lang.org/cargo/reference/cargo-targets.html#library
192            - https://doc.rust-lang.org/cargo/reference/cargo-targets.html#binaries
193    """
194    default_crate_root_filename = "main.rs" if crate_type == "bin" else "lib.rs"
195
196    crate_root = (
197        (srcs[0] if len(srcs) == 1 else None) or
198        _shortest_src_with_basename(srcs, default_crate_root_filename) or
199        _shortest_src_with_basename(srcs, name + ".rs")
200    )
201    if not crate_root:
202        file_names = [default_crate_root_filename, name + ".rs"]
203        fail("No {} source file found.".format(" or ".join(file_names)), "srcs")
204    return crate_root
205
206def _shortest_src_with_basename(srcs, basename):
207    """Finds the shortest among the paths in srcs that match the desired basename.
208
209    Args:
210        srcs (list): A list of File objects
211        basename (str): The target basename to match against.
212
213    Returns:
214        File: The File object with the shortest path that matches `basename`
215    """
216    shortest = None
217    for f in srcs:
218        if f.basename == basename:
219            if not shortest or len(f.dirname) < len(shortest.dirname):
220                shortest = f
221    return shortest
222
223def _rust_library_impl(ctx):
224    """The implementation of the `rust_library` rule.
225
226    This rule provides CcInfo, so it can be used everywhere Bazel
227    expects rules_cc, but care must be taken to have the correct
228    dependencies on an allocator and std implemetation as needed.
229
230    Args:
231        ctx (ctx): The rule's context object
232
233    Returns:
234        list: A list of providers.
235    """
236    return _rust_library_common(ctx, "rlib")
237
238def _rust_static_library_impl(ctx):
239    """The implementation of the `rust_static_library` rule.
240
241    This rule provides CcInfo, so it can be used everywhere Bazel
242    expects rules_cc.
243
244    Args:
245        ctx (ctx): The rule's context object
246
247    Returns:
248        list: A list of providers.
249    """
250    return _rust_library_common(ctx, "staticlib")
251
252def _rust_shared_library_impl(ctx):
253    """The implementation of the `rust_shared_library` rule.
254
255    This rule provides CcInfo, so it can be used everywhere Bazel
256    expects rules_cc.
257
258    On Windows, a PDB file containing debugging information is available under
259    the key `pdb_file` in `OutputGroupInfo`. Similarly on macOS, a dSYM folder
260    is available under the key `dsym_folder` in `OutputGroupInfo`.
261
262    Args:
263        ctx (ctx): The rule's context object
264
265    Returns:
266        list: A list of providers.
267    """
268    return _rust_library_common(ctx, "cdylib")
269
270def _rust_proc_macro_impl(ctx):
271    """The implementation of the `rust_proc_macro` rule.
272
273    Args:
274        ctx (ctx): The rule's context object
275
276    Returns:
277        list: A list of providers.
278    """
279    return _rust_library_common(ctx, "proc-macro")
280
281def _rust_library_common(ctx, crate_type):
282    """The common implementation of the library-like rules.
283
284    Args:
285        ctx (ctx): The rule's context object
286        crate_type (String): one of lib|rlib|dylib|staticlib|cdylib|proc-macro
287
288    Returns:
289        list: A list of providers. See `rustc_compile_action`
290    """
291
292    srcs, crate_root = _transform_sources(ctx, ctx.files.srcs, getattr(ctx.file, "crate_root", None))
293    if not crate_root:
294        crate_root = crate_root_src(ctx.attr.name, srcs, "lib")
295    _assert_no_deprecated_attributes(ctx)
296    _assert_correct_dep_mapping(ctx)
297
298    toolchain = find_toolchain(ctx)
299
300    # Determine unique hash for this rlib.
301    # Note that we don't include a hash for `cdylib` and `staticlib` since they are meant to be consumed externally
302    # and having a deterministic name is important since it ends up embedded in the executable. This is problematic
303    # when one needs to include the library with a specific filename into a larger application.
304    # (see https://github.com/bazelbuild/rules_rust/issues/405#issuecomment-993089889 for more details)
305    if crate_type in ["cdylib", "staticlib"]:
306        output_hash = None
307    else:
308        output_hash = determine_output_hash(crate_root, ctx.label)
309
310    crate_name = compute_crate_name(ctx.workspace_name, ctx.label, toolchain, ctx.attr.crate_name)
311    rust_lib_name = _determine_lib_name(
312        crate_name,
313        crate_type,
314        toolchain,
315        output_hash,
316    )
317    rust_lib = ctx.actions.declare_file(rust_lib_name)
318
319    deps = transform_deps(ctx.attr.deps)
320    proc_macro_deps = transform_deps(ctx.attr.proc_macro_deps + get_import_macro_deps(ctx))
321
322    return rustc_compile_action(
323        ctx = ctx,
324        attr = ctx.attr,
325        toolchain = toolchain,
326        crate_info = rust_common.create_crate_info(
327            name = crate_name,
328            type = crate_type,
329            root = crate_root,
330            srcs = depset(srcs),
331            deps = depset(deps),
332            proc_macro_deps = depset(proc_macro_deps),
333            aliases = ctx.attr.aliases,
334            output = rust_lib,
335            edition = get_edition(ctx.attr, toolchain, ctx.label),
336            rustc_env = ctx.attr.rustc_env,
337            is_test = False,
338            compile_data = depset(ctx.files.compile_data),
339            owner = ctx.label,
340        ),
341        output_hash = output_hash,
342    )
343
344def _rust_binary_impl(ctx):
345    """The implementation of the `rust_binary` rule
346
347    Args:
348        ctx (ctx): The rule's context object
349
350    Returns:
351        list: A list of providers. See `rustc_compile_action`
352    """
353    toolchain = find_toolchain(ctx)
354    crate_name = compute_crate_name(ctx.workspace_name, ctx.label, toolchain, ctx.attr.crate_name)
355    _assert_correct_dep_mapping(ctx)
356
357    output = ctx.actions.declare_file(ctx.label.name + toolchain.binary_ext)
358
359    deps = transform_deps(ctx.attr.deps)
360    proc_macro_deps = transform_deps(ctx.attr.proc_macro_deps + get_import_macro_deps(ctx))
361
362    srcs, crate_root = _transform_sources(ctx, ctx.files.srcs, getattr(ctx.file, "crate_root", None))
363    if not crate_root:
364        crate_root = crate_root_src(ctx.attr.name, srcs, ctx.attr.crate_type)
365
366    return rustc_compile_action(
367        ctx = ctx,
368        attr = ctx.attr,
369        toolchain = toolchain,
370        crate_info = rust_common.create_crate_info(
371            name = crate_name,
372            type = ctx.attr.crate_type,
373            root = crate_root,
374            srcs = depset(srcs),
375            deps = depset(deps),
376            proc_macro_deps = depset(proc_macro_deps),
377            aliases = ctx.attr.aliases,
378            output = output,
379            edition = get_edition(ctx.attr, toolchain, ctx.label),
380            rustc_env = ctx.attr.rustc_env,
381            is_test = False,
382            compile_data = depset(ctx.files.compile_data),
383            owner = ctx.label,
384        ),
385    )
386
387def _rust_test_impl(ctx):
388    """The implementation of the `rust_test` rule.
389
390    Args:
391        ctx (ctx): The ctx object for the current target.
392
393    Returns:
394        list: The list of providers. See `rustc_compile_action`
395    """
396    _assert_no_deprecated_attributes(ctx)
397    _assert_correct_dep_mapping(ctx)
398
399    toolchain = find_toolchain(ctx)
400
401    srcs, crate_root = _transform_sources(ctx, ctx.files.srcs, getattr(ctx.file, "crate_root", None))
402    crate_type = "bin"
403
404    deps = transform_deps(ctx.attr.deps)
405    proc_macro_deps = transform_deps(ctx.attr.proc_macro_deps + get_import_macro_deps(ctx))
406
407    if ctx.attr.crate:
408        # Target is building the crate in `test` config
409        crate = ctx.attr.crate[rust_common.crate_info] if rust_common.crate_info in ctx.attr.crate else ctx.attr.crate[rust_common.test_crate_info].crate
410
411        output_hash = determine_output_hash(crate.root, ctx.label)
412        output = ctx.actions.declare_file(
413            "test-%s/%s%s" % (
414                output_hash,
415                ctx.label.name,
416                toolchain.binary_ext,
417            ),
418        )
419
420        # Optionally join compile data
421        if crate.compile_data:
422            compile_data = depset(ctx.files.compile_data, transitive = [crate.compile_data])
423        else:
424            compile_data = depset(ctx.files.compile_data)
425
426        # Build the test binary using the dependency's srcs.
427        crate_info = rust_common.create_crate_info(
428            name = crate.name,
429            type = crate_type,
430            root = crate.root,
431            srcs = depset(srcs, transitive = [crate.srcs]),
432            deps = depset(deps, transitive = [crate.deps]),
433            proc_macro_deps = depset(proc_macro_deps, transitive = [crate.proc_macro_deps]),
434            aliases = ctx.attr.aliases,
435            output = output,
436            edition = crate.edition,
437            rustc_env = ctx.attr.rustc_env,
438            is_test = True,
439            compile_data = compile_data,
440            wrapped_crate_type = crate.type,
441            owner = ctx.label,
442        )
443    else:
444        if not crate_root:
445            crate_root = crate_root_src(ctx.attr.name, ctx.files.srcs, "lib")
446
447        output_hash = determine_output_hash(crate_root, ctx.label)
448        output = ctx.actions.declare_file(
449            "test-%s/%s%s" % (
450                output_hash,
451                ctx.label.name,
452                toolchain.binary_ext,
453            ),
454        )
455
456        # Target is a standalone crate. Build the test binary as its own crate.
457        crate_info = rust_common.create_crate_info(
458            name = compute_crate_name(ctx.workspace_name, ctx.label, toolchain, ctx.attr.crate_name),
459            type = crate_type,
460            root = crate_root,
461            srcs = depset(srcs),
462            deps = depset(deps),
463            proc_macro_deps = depset(proc_macro_deps),
464            aliases = ctx.attr.aliases,
465            output = output,
466            edition = get_edition(ctx.attr, toolchain, ctx.label),
467            rustc_env = ctx.attr.rustc_env,
468            is_test = True,
469            compile_data = depset(ctx.files.compile_data),
470            owner = ctx.label,
471        )
472
473    providers = rustc_compile_action(
474        ctx = ctx,
475        attr = ctx.attr,
476        toolchain = toolchain,
477        crate_info = crate_info,
478        rust_flags = ["--test"] if ctx.attr.use_libtest_harness else ["--cfg", "test"],
479    )
480    data = getattr(ctx.attr, "data", [])
481
482    env = expand_dict_value_locations(
483        ctx,
484        getattr(ctx.attr, "env", {}),
485        data,
486    )
487    if toolchain.llvm_cov and ctx.configuration.coverage_enabled:
488        if not toolchain.llvm_profdata:
489            fail("toolchain.llvm_profdata is required if toolchain.llvm_cov is set.")
490
491        env["RUST_LLVM_COV"] = toolchain.llvm_cov.path
492        env["RUST_LLVM_PROFDATA"] = toolchain.llvm_profdata.path
493    providers.append(testing.TestEnvironment(env))
494
495    return providers
496
497_common_attrs = {
498    "aliases": attr.label_keyed_string_dict(
499        doc = dedent("""\
500            Remap crates to a new name or moniker for linkage to this target
501
502            These are other `rust_library` targets and will be presented as the new name given.
503        """),
504    ),
505    "compile_data": attr.label_list(
506        doc = dedent("""\
507            List of files used by this rule at compile time.
508
509            This attribute can be used to specify any data files that are embedded into
510            the library, such as via the
511            [`include_str!`](https://doc.rust-lang.org/std/macro.include_str!.html)
512            macro.
513        """),
514        allow_files = True,
515    ),
516    "crate_features": attr.string_list(
517        doc = dedent("""\
518            List of features to enable for this crate.
519
520            Features are defined in the code using the `#[cfg(feature = "foo")]`
521            configuration option. The features listed here will be passed to `rustc`
522            with `--cfg feature="${feature_name}"` flags.
523        """),
524    ),
525    "crate_name": attr.string(
526        doc = dedent("""\
527            Crate name to use for this target.
528
529            This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores.
530            Defaults to the target name, with any hyphens replaced by underscores.
531        """),
532    ),
533    "crate_root": attr.label(
534        doc = dedent("""\
535            The file that will be passed to `rustc` to be used for building this crate.
536
537            If `crate_root` is not set, then this rule will look for a `lib.rs` file (or `main.rs` for rust_binary)
538            or the single file in `srcs` if `srcs` contains only one file.
539        """),
540        allow_single_file = [".rs"],
541    ),
542    "data": attr.label_list(
543        doc = dedent("""\
544            List of files used by this rule at compile time and runtime.
545
546            If including data at compile time with include_str!() and similar,
547            prefer `compile_data` over `data`, to prevent the data also being included
548            in the runfiles.
549        """),
550        allow_files = True,
551    ),
552    "deps": attr.label_list(
553        doc = dedent("""\
554            List of other libraries to be linked to this library target.
555
556            These can be either other `rust_library` targets or `cc_library` targets if
557            linking a native library.
558        """),
559    ),
560    "edition": attr.string(
561        doc = "The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain.",
562    ),
563    # Previously `proc_macro_deps` were a part of `deps`, and then proc_macro_host_transition was
564    # used into cfg="host" using `@local_config_platform//:host`.
565    # This fails for remote execution, which needs cfg="exec", and there isn't anything like
566    # `@local_config_platform//:exec` exposed.
567    "proc_macro_deps": attr.label_list(
568        doc = dedent("""\
569            List of `rust_library` targets with kind `proc-macro` used to help build this library target.
570        """),
571        cfg = "exec",
572        providers = [rust_common.crate_info],
573    ),
574    "rustc_env": attr.string_dict(
575        doc = dedent("""\
576            Dictionary of additional `"key": "value"` environment variables to set for rustc.
577
578            rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the
579            location of a generated file or external tool. Cargo build scripts that wish to
580            expand locations should use cargo_build_script()'s build_script_env argument instead,
581            as build scripts are run in a different environment - see cargo_build_script()'s
582            documentation for more.
583        """),
584    ),
585    "rustc_env_files": attr.label_list(
586        doc = dedent("""\
587            Files containing additional environment variables to set for rustc.
588
589            These files should  contain a single variable per line, of format
590            `NAME=value`, and newlines may be included in a value by ending a
591            line with a trailing back-slash (`\\\\`).
592
593            The order that these files will be processed is unspecified, so
594            multiple definitions of a particular variable are discouraged.
595
596            Note that the variables here are subject to 
597            [workspace status](https://docs.bazel.build/versions/main/user-manual.html#workspace_status)
598            stamping should the `stamp` attribute be enabled. Stamp variables
599            should be wrapped in brackets in order to be resolved. E.g.
600            `NAME={WORKSPACE_STATUS_VARIABLE}`.
601        """),
602        allow_files = True,
603    ),
604    "rustc_flags": attr.string_list(
605        doc = dedent("""\
606            List of compiler flags passed to `rustc`.
607
608            These strings are subject to Make variable expansion for predefined
609            source/output path variables like `$location`, `$execpath`, and 
610            `$rootpath`. This expansion is useful if you wish to pass a generated
611            file of arguments to rustc: `@$(location //package:target)`.
612        """),
613    ),
614    # TODO(stardoc): How do we provide additional documentation to an inherited attribute?
615    # "name": attr.string(
616    #     doc = "This name will also be used as the name of the crate built by this rule.",
617    # `),
618    "srcs": attr.label_list(
619        doc = dedent("""\
620            List of Rust `.rs` source files used to build the library.
621
622            If `srcs` contains more than one file, then there must be a file either
623            named `lib.rs`. Otherwise, `crate_root` must be set to the source file that
624            is the root of the crate to be passed to rustc to build this crate.
625        """),
626        allow_files = [".rs"],
627    ),
628    "stamp": attr.int(
629        doc = dedent("""\
630            Whether to encode build information into the `Rustc` action. Possible values:
631
632            - `stamp = 1`: Always stamp the build information into the `Rustc` action, even in \
633            [--nostamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) builds. \
634            This setting should be avoided, since it potentially kills remote caching for the target and \
635            any downstream actions that depend on it.
636
637            - `stamp = 0`: Always replace build information by constant values. This gives good build result caching.
638
639            - `stamp = -1`: Embedding of build information is controlled by the \
640            [--[no]stamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) flag.
641
642            Stamped targets are not rebuilt unless their dependencies change.
643
644            For example if a `rust_library` is stamped, and a `rust_binary` depends on that library, the stamped
645            library won't be rebuilt when we change sources of the `rust_binary`. This is different from how
646            [`cc_library.linkstamps`](https://docs.bazel.build/versions/main/be/c-cpp.html#cc_library.linkstamp)
647            behaves.
648        """),
649        default = -1,
650        values = [1, 0, -1],
651    ),
652    "version": attr.string(
653        doc = "A version to inject in the cargo environment variable.",
654        default = "0.0.0",
655    ),
656    "_cc_toolchain": attr.label(
657        doc = (
658            "In order to use find_cc_toolchain, your rule has to depend " +
659            "on C++ toolchain. See `@rules_cc//cc:find_cc_toolchain.bzl` " +
660            "docs for details."
661        ),
662        default = Label("@bazel_tools//tools/cpp:current_cc_toolchain"),
663    ),
664    "_collect_cc_coverage": attr.label(
665        default = Label("//util:collect_coverage"),
666        executable = True,
667        cfg = "exec",
668    ),
669    "_error_format": attr.label(
670        default = Label("//:error_format"),
671    ),
672    "_extra_exec_rustc_flags": attr.label(
673        default = Label("//:extra_exec_rustc_flags"),
674    ),
675    "_extra_rustc_flags": attr.label(
676        default = Label("//:extra_rustc_flags"),
677    ),
678    "_import_macro_dep": attr.label(
679        default = Label("//util/import"),
680        cfg = "exec",
681    ),
682    "_process_wrapper": attr.label(
683        doc = "A process wrapper for running rustc on all platforms.",
684        default = Label("//util/process_wrapper"),
685        executable = True,
686        allow_single_file = True,
687        cfg = "exec",
688    ),
689    "_stamp_flag": attr.label(
690        doc = "A setting used to determine whether or not the `--stamp` flag is enabled",
691        default = Label("//rust/private:stamp"),
692    ),
693}
694
695_rust_test_attrs = {
696    "crate": attr.label(
697        mandatory = False,
698        doc = dedent("""\
699            Target inline tests declared in the given crate
700
701            These tests are typically those that would be held out under
702            `#[cfg(test)]` declarations.
703        """),
704    ),
705    "env": attr.string_dict(
706        mandatory = False,
707        doc = dedent("""\
708            Specifies additional environment variables to set when the test is executed by bazel test.
709            Values are subject to `$(rootpath)`, `$(execpath)`, location, and
710            ["Make variable"](https://docs.bazel.build/versions/master/be/make-variables.html) substitution.
711
712            Execpath returns absolute path, and in order to be able to construct the absolute path we
713            need to wrap the test binary in a launcher. Using a launcher comes with complications, such as
714            more complicated debugger attachment.
715        """),
716    ),
717    "use_libtest_harness": attr.bool(
718        mandatory = False,
719        default = True,
720        doc = dedent("""\
721            Whether to use `libtest`. For targets using this flag, individual tests can be run by using the 
722            [--test_arg](https://docs.bazel.build/versions/4.0.0/command-line-reference.html#flag--test_arg) flag.
723            E.g. `bazel test //src:rust_test --test_arg=foo::test::test_fn`.
724        """),
725    ),
726    "_grep_includes": attr.label(
727        allow_single_file = True,
728        cfg = "exec",
729        default = Label("@bazel_tools//tools/cpp:grep-includes"),
730        executable = True,
731    ),
732}
733
734_common_providers = [
735    rust_common.crate_info,
736    rust_common.dep_info,
737    DefaultInfo,
738]
739
740rust_library = rule(
741    implementation = _rust_library_impl,
742    provides = _common_providers,
743    attrs = dict(_common_attrs.items()),
744    fragments = ["cpp"],
745    host_fragments = ["cpp"],
746    toolchains = [
747        str(Label("//rust:toolchain")),
748        "@bazel_tools//tools/cpp:toolchain_type",
749    ],
750    incompatible_use_toolchain_transition = True,
751    doc = dedent("""\
752        Builds a Rust library crate.
753
754        Example:
755
756        Suppose you have the following directory structure for a simple Rust library crate:
757
758        ```output
759        [workspace]/
760            WORKSPACE
761            hello_lib/
762                BUILD
763                src/
764                    greeter.rs
765                    lib.rs
766        ```
767
768        `hello_lib/src/greeter.rs`:
769        ```rust
770        pub struct Greeter {
771            greeting: String,
772        }
773
774        impl Greeter {
775            pub fn new(greeting: &str) -> Greeter {
776                Greeter { greeting: greeting.to_string(), }
777            }
778
779            pub fn greet(&self, thing: &str) {
780                println!("{} {}", &self.greeting, thing);
781            }
782        }
783        ```
784
785        `hello_lib/src/lib.rs`:
786
787        ```rust
788        pub mod greeter;
789        ```
790
791        `hello_lib/BUILD`:
792        ```python
793        package(default_visibility = ["//visibility:public"])
794
795        load("@rules_rust//rust:defs.bzl", "rust_library")
796
797        rust_library(
798            name = "hello_lib",
799            srcs = [
800                "src/greeter.rs",
801                "src/lib.rs",
802            ],
803        )
804        ```
805
806        Build the library:
807        ```output
808        $ bazel build //hello_lib
809        INFO: Found 1 target...
810        Target //examples/rust/hello_lib:hello_lib up-to-date:
811        bazel-bin/examples/rust/hello_lib/libhello_lib.rlib
812        INFO: Elapsed time: 1.245s, Critical Path: 1.01s
813        ```
814        """),
815)
816
817rust_static_library = rule(
818    implementation = _rust_static_library_impl,
819    attrs = dict(_common_attrs.items()),
820    fragments = ["cpp"],
821    host_fragments = ["cpp"],
822    toolchains = [
823        str(Label("//rust:toolchain")),
824        "@bazel_tools//tools/cpp:toolchain_type",
825    ],
826    incompatible_use_toolchain_transition = True,
827    doc = dedent("""\
828        Builds a Rust static library.
829
830        This static library will contain all transitively reachable crates and native objects.
831        It is meant to be used when producing an artifact that is then consumed by some other build system
832        (for example to produce an archive that Python program links against).
833
834        This rule provides CcInfo, so it can be used everywhere Bazel expects `rules_cc`.
835
836        When building the whole binary in Bazel, use `rust_library` instead.
837        """),
838)
839
840rust_shared_library = rule(
841    implementation = _rust_shared_library_impl,
842    attrs = dict(_common_attrs.items()),
843    fragments = ["cpp"],
844    host_fragments = ["cpp"],
845    toolchains = [
846        str(Label("//rust:toolchain")),
847        "@bazel_tools//tools/cpp:toolchain_type",
848    ],
849    incompatible_use_toolchain_transition = True,
850    doc = dedent("""\
851        Builds a Rust shared library.
852
853        This shared library will contain all transitively reachable crates and native objects.
854        It is meant to be used when producing an artifact that is then consumed by some other build system
855        (for example to produce a shared library that Python program links against).
856
857        This rule provides CcInfo, so it can be used everywhere Bazel expects `rules_cc`.
858
859        When building the whole binary in Bazel, use `rust_library` instead.
860        """),
861)
862
863rust_proc_macro = rule(
864    implementation = _rust_proc_macro_impl,
865    provides = _common_providers,
866    attrs = dict(_common_attrs.items()),
867    fragments = ["cpp"],
868    host_fragments = ["cpp"],
869    toolchains = [
870        str(Label("//rust:toolchain")),
871        "@bazel_tools//tools/cpp:toolchain_type",
872    ],
873    incompatible_use_toolchain_transition = True,
874    doc = dedent("""\
875        Builds a Rust proc-macro crate.
876        """),
877)
878
879_rust_binary_attrs = {
880    "crate_type": attr.string(
881        doc = dedent("""\
882            Crate type that will be passed to `rustc` to be used for building this crate.
883
884            This option is a temporary workaround and should be used only when building
885            for WebAssembly targets (//rust/platform:wasi and //rust/platform:wasm).
886        """),
887        default = "bin",
888    ),
889    "linker_script": attr.label(
890        doc = dedent("""\
891            Link script to forward into linker via rustc options.
892        """),
893        cfg = "exec",
894        allow_single_file = True,
895    ),
896    "out_binary": attr.bool(
897        doc = (
898            "Force a target, regardless of it's `crate_type`, to always mark the " +
899            "file as executable. This attribute is only used to support wasm targets but is " +
900            "expected to be removed following a resolution to https://github.com/bazelbuild/rules_rust/issues/771."
901        ),
902        default = False,
903    ),
904    "_grep_includes": attr.label(
905        allow_single_file = True,
906        cfg = "exec",
907        default = Label("@bazel_tools//tools/cpp:grep-includes"),
908        executable = True,
909    ),
910}
911
912rust_binary = rule(
913    implementation = _rust_binary_impl,
914    provides = _common_providers,
915    attrs = dict(_common_attrs.items() + _rust_binary_attrs.items()),
916    executable = True,
917    fragments = ["cpp"],
918    host_fragments = ["cpp"],
919    toolchains = [
920        str(Label("//rust:toolchain")),
921        "@bazel_tools//tools/cpp:toolchain_type",
922    ],
923    incompatible_use_toolchain_transition = True,
924    doc = dedent("""\
925        Builds a Rust binary crate.
926
927        Example:
928
929        Suppose you have the following directory structure for a Rust project with a
930        library crate, `hello_lib`, and a binary crate, `hello_world` that uses the
931        `hello_lib` library:
932
933        ```output
934        [workspace]/
935            WORKSPACE
936            hello_lib/
937                BUILD
938                src/
939                    lib.rs
940            hello_world/
941                BUILD
942                src/
943                    main.rs
944        ```
945
946        `hello_lib/src/lib.rs`:
947        ```rust
948        pub struct Greeter {
949            greeting: String,
950        }
951
952        impl Greeter {
953            pub fn new(greeting: &str) -> Greeter {
954                Greeter { greeting: greeting.to_string(), }
955            }
956
957            pub fn greet(&self, thing: &str) {
958                println!("{} {}", &self.greeting, thing);
959            }
960        }
961        ```
962
963        `hello_lib/BUILD`:
964        ```python
965        package(default_visibility = ["//visibility:public"])
966
967        load("@rules_rust//rust:defs.bzl", "rust_library")
968
969        rust_library(
970            name = "hello_lib",
971            srcs = ["src/lib.rs"],
972        )
973        ```
974
975        `hello_world/src/main.rs`:
976        ```rust
977        extern crate hello_lib;
978
979        fn main() {
980            let hello = hello_lib::Greeter::new("Hello");
981            hello.greet("world");
982        }
983        ```
984
985        `hello_world/BUILD`:
986        ```python
987        load("@rules_rust//rust:defs.bzl", "rust_binary")
988
989        rust_binary(
990            name = "hello_world",
991            srcs = ["src/main.rs"],
992            deps = ["//hello_lib"],
993        )
994        ```
995
996        Build and run `hello_world`:
997        ```
998        $ bazel run //hello_world
999        INFO: Found 1 target...
1000        Target //examples/rust/hello_world:hello_world up-to-date:
1001        bazel-bin/examples/rust/hello_world/hello_world
1002        INFO: Elapsed time: 1.308s, Critical Path: 1.22s
1003
1004        INFO: Running command line: bazel-bin/examples/rust/hello_world/hello_world
1005        Hello world
1006        ```
1007
1008        On Windows, a PDB file containing debugging information is available under
1009        the key `pdb_file` in `OutputGroupInfo`. Similarly on macOS, a dSYM folder
1010        is available under the key `dsym_folder` in `OutputGroupInfo`.
1011"""),
1012)
1013
1014def _common_attrs_for_binary_without_process_wrapper(attrs):
1015    new_attr = dict(attrs.items())
1016
1017    # use a fake process wrapper
1018    new_attr["_process_wrapper"] = attr.label(
1019        default = None,
1020        executable = True,
1021        allow_single_file = True,
1022        cfg = "exec",
1023    )
1024
1025    # fix stamp = 0
1026    new_attr["stamp"] = attr.int(
1027        doc = dedent("""\
1028            Fix `stamp = 0` as stamping is not supported when building without process_wrapper:
1029            https://github.com/bazelbuild/rules_rust/blob/8df4517d370b0c543a01ba38b63e1d5a4104b035/rust/private/rustc.bzl#L955
1030        """),
1031        default = 0,
1032        values = [0],
1033    )
1034
1035    return new_attr
1036
1037# Provides an internal rust_{binary,library} to use that we can use to build the process
1038# wrapper, this breaks the dependency of rust_* on the process wrapper by
1039# setting it to None, which the functions in rustc detect and build accordingly.
1040rust_binary_without_process_wrapper = rule(
1041    implementation = _rust_binary_impl,
1042    provides = _common_providers,
1043    attrs = dict(_common_attrs_for_binary_without_process_wrapper(_common_attrs).items() + _rust_binary_attrs.items()),
1044    executable = True,
1045    fragments = ["cpp"],
1046    host_fragments = ["cpp"],
1047    toolchains = [
1048        str(Label("//rust:toolchain")),
1049        "@bazel_tools//tools/cpp:toolchain_type",
1050    ],
1051    incompatible_use_toolchain_transition = True,
1052)
1053
1054rust_library_without_process_wrapper = rule(
1055    implementation = _rust_library_impl,
1056    provides = _common_providers,
1057    attrs = dict(_common_attrs_for_binary_without_process_wrapper(_common_attrs).items()),
1058    fragments = ["cpp"],
1059    host_fragments = ["cpp"],
1060    toolchains = [
1061        str(Label("//rust:toolchain")),
1062        "@bazel_tools//tools/cpp:toolchain_type",
1063    ],
1064    incompatible_use_toolchain_transition = True,
1065)
1066
1067rust_test = rule(
1068    implementation = _rust_test_impl,
1069    provides = _common_providers,
1070    attrs = dict(_common_attrs.items() +
1071                 _rust_test_attrs.items()),
1072    executable = True,
1073    fragments = ["cpp"],
1074    host_fragments = ["cpp"],
1075    test = True,
1076    toolchains = [
1077        str(Label("//rust:toolchain")),
1078        "@bazel_tools//tools/cpp:toolchain_type",
1079    ],
1080    incompatible_use_toolchain_transition = True,
1081    doc = dedent("""\
1082        Builds a Rust test crate.
1083
1084        Examples:
1085
1086        Suppose you have the following directory structure for a Rust library crate \
1087        with unit test code in the library sources:
1088
1089        ```output
1090        [workspace]/
1091            WORKSPACE
1092            hello_lib/
1093                BUILD
1094                src/
1095                    lib.rs
1096        ```
1097
1098        `hello_lib/src/lib.rs`:
1099        ```rust
1100        pub struct Greeter {
1101            greeting: String,
1102        }
1103
1104        impl Greeter {
1105            pub fn new(greeting: &str) -> Greeter {
1106                Greeter { greeting: greeting.to_string(), }
1107            }
1108
1109            pub fn greet(&self, thing: &str) -> String {
1110                format!("{} {}", &self.greeting, thing)
1111            }
1112        }
1113
1114        #[cfg(test)]
1115        mod test {
1116            use super::Greeter;
1117
1118            #[test]
1119            fn test_greeting() {
1120                let hello = Greeter::new("Hi");
1121                assert_eq!("Hi Rust", hello.greet("Rust"));
1122            }
1123        }
1124        ```
1125
1126        To build and run the tests, simply add a `rust_test` rule with no `srcs`
1127        and only depends on the `hello_lib` `rust_library` target via the
1128        `crate` attribute:
1129
1130        `hello_lib/BUILD`:
1131        ```python
1132        load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
1133
1134        rust_library(
1135            name = "hello_lib",
1136            srcs = ["src/lib.rs"],
1137        )
1138
1139        rust_test(
1140            name = "hello_lib_test",
1141            crate = ":hello_lib",
1142            # You may add other deps that are specific to the test configuration
1143            deps = ["//some/dev/dep"],
1144        ```
1145
1146        Run the test with `bazel test //hello_lib:hello_lib_test`. The crate
1147        will be built using the same crate name as the underlying ":hello_lib"
1148        crate.
1149
1150        ### Example: `test` directory
1151
1152        Integration tests that live in the [`tests` directory][int-tests], they are \
1153        essentially built as separate crates. Suppose you have the following directory \
1154        structure where `greeting.rs` is an integration test for the `hello_lib` \
1155        library crate:
1156
1157        [int-tests]: http://doc.rust-lang.org/book/testing.html#the-tests-directory
1158
1159        ```output
1160        [workspace]/
1161            WORKSPACE
1162            hello_lib/
1163                BUILD
1164                src/
1165                    lib.rs
1166                tests/
1167                    greeting.rs
1168        ```
1169
1170        `hello_lib/tests/greeting.rs`:
1171        ```rust
1172        extern crate hello_lib;
1173
1174        use hello_lib;
1175
1176        #[test]
1177        fn test_greeting() {
1178            let hello = greeter::Greeter::new("Hello");
1179            assert_eq!("Hello world", hello.greeting("world"));
1180        }
1181        ```
1182
1183        To build the `greeting.rs` integration test, simply add a `rust_test` target
1184        with `greeting.rs` in `srcs` and a dependency on the `hello_lib` target:
1185
1186        `hello_lib/BUILD`:
1187        ```python
1188        load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
1189
1190        rust_library(
1191            name = "hello_lib",
1192            srcs = ["src/lib.rs"],
1193        )
1194
1195        rust_test(
1196            name = "greeting_test",
1197            srcs = ["tests/greeting.rs"],
1198            deps = [":hello_lib"],
1199        )
1200        ```
1201
1202        Run the test with `bazel test //hello_lib:greeting_test`.
1203"""),
1204)
1205
1206def rust_test_suite(name, srcs, **kwargs):
1207    """A rule for creating a test suite for a set of `rust_test` targets.
1208
1209    This rule can be used for setting up typical rust [integration tests][it]. Given the following
1210    directory structure:
1211
1212    ```text
1213    [crate]/
1214        BUILD.bazel
1215        src/
1216            lib.rs
1217            main.rs
1218        tests/
1219            integrated_test_a.rs
1220            integrated_test_b.rs
1221            integrated_test_c.rs
1222            patterns/
1223                fibonacci_test.rs
1224    ```
1225
1226    The rule can be used to generate [rust_test](#rust_test) targets for each source file under `tests`
1227    and a [test_suite][ts] which encapsulates all tests.
1228
1229    ```python
1230    load("//rust:defs.bzl", "rust_binary", "rust_library", "rust_test_suite")
1231
1232    rust_library(
1233        name = "math_lib",
1234        srcs = ["src/lib.rs"],
1235    )
1236
1237    rust_binary(
1238        name = "math_bin",
1239        srcs = ["src/main.rs"],
1240    )
1241
1242    rust_test_suite(
1243        name = "integrated_tests_suite",
1244        srcs = glob(["tests/**"]),
1245        deps = [":math_lib"],
1246    )
1247    ```
1248
1249    [it]: https://doc.rust-lang.org/rust-by-example/testing/integration_testing.html
1250    [ts]: https://docs.bazel.build/versions/master/be/general.html#test_suite
1251
1252    Args:
1253        name (str): The name of the `test_suite`.
1254        srcs (list): All test sources, typically `glob(["tests/**/*.rs"])`.
1255        **kwargs (dict): Additional keyword arguments for the underyling [rust_test](#rust_test) targets. The
1256            `tags` argument is also passed to the generated `test_suite` target.
1257    """
1258    tests = []
1259
1260    for src in srcs:
1261        if not src.endswith(".rs"):
1262            fail("srcs should have `.rs` extensions")
1263
1264        # Prefixed with `name` to allow parameterization with macros
1265        # The test name should not end with `.rs`
1266        test_name = name + "_" + src[:-3]
1267        rust_test(
1268            name = test_name,
1269            srcs = [src],
1270            **kwargs
1271        )
1272        tests.append(test_name)
1273
1274    native.test_suite(
1275        name = name,
1276        tests = tests,
1277        tags = kwargs.get("tags", None),
1278    )