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