fork/rules_rust
git clone https://git.julia.blue/fork/rules_rust
9a8e878d
0.8.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_impl ( ctx ): 388"""The implementation of the `rust_test` rule. 389 390Args: 391ctx (ctx): The ctx object for the current target. 392 393Returns: 394list: The list of providers. See `rustc_compile_action` 395""" 396_assert_no_deprecated_attributes ( ctx ) 397_assert_correct_dep_mapping ( ctx ) 398 399toolchain = find_toolchain ( 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 411output_hash = determine_output_hash ( crate . root , ctx . label ) 412output = ctx . actions . declare_file ( 413"test-%s/%s%s" % ( 414output_hash , 415ctx . label . name , 416toolchain . binary_ext , 417), 418) 419 420# Optionally join compile data 421if crate . compile_data : 422compile_data = depset ( ctx . files . compile_data , transitive = [ crate . compile_data ]) 423else : 424compile_data = depset ( ctx . files . compile_data ) 425 426# Build the test binary using the dependency's srcs. 427crate_info = rust_common . create_crate_info ( 428name = crate . name , 429type = crate_type , 430root = crate . root , 431srcs = depset ( srcs , transitive = [ crate . srcs ]), 432deps = depset ( deps , transitive = [ crate . deps ]), 433proc_macro_deps = depset ( proc_macro_deps , transitive = [ crate . proc_macro_deps ]), 434aliases = ctx . attr . aliases , 435output = output , 436edition = crate . edition , 437rustc_env = ctx . attr . rustc_env , 438is_test = True , 439compile_data = compile_data , 440wrapped_crate_type = crate . type , 441owner = ctx . label , 442) 443else : 444if not crate_root : 445crate_root = crate_root_src ( ctx . attr . name , ctx . files . srcs , "lib" ) 446 447output_hash = determine_output_hash ( crate_root , ctx . label ) 448output = ctx . actions . declare_file ( 449"test-%s/%s%s" % ( 450output_hash , 451ctx . label . name , 452toolchain . binary_ext , 453), 454) 455 456# Target is a standalone crate. Build the test binary as its own crate. 457crate_info = rust_common . create_crate_info ( 458name = compute_crate_name ( ctx . workspace_name , ctx . label , toolchain , ctx . attr . crate_name ), 459type = crate_type , 460root = crate_root , 461srcs = depset ( srcs ), 462deps = depset ( deps ), 463proc_macro_deps = depset ( proc_macro_deps ), 464aliases = ctx . attr . aliases , 465output = output , 466edition = get_edition ( ctx . attr , toolchain , ctx . label ), 467rustc_env = ctx . attr . rustc_env , 468is_test = True , 469compile_data = depset ( ctx . files . compile_data ), 470owner = ctx . label , 471) 472 473providers = rustc_compile_action ( 474ctx = ctx , 475attr = ctx . attr , 476toolchain = toolchain , 477crate_info = crate_info , 478rust_flags = [ "--test" ] if ctx . attr . use_libtest_harness else [ "--cfg" , "test" ], 479) 480data = getattr ( ctx . attr , "data" , []) 481 482env = expand_dict_value_locations ( 483ctx , 484getattr ( ctx . attr , "env" , {}), 485data , 486) 487if toolchain . llvm_cov and ctx . configuration . coverage_enabled : 488if not toolchain . llvm_profdata : 489fail ( "toolchain.llvm_profdata is required if toolchain.llvm_cov is set." ) 490 491env [ "RUST_LLVM_COV" ] = toolchain . llvm_cov . path 492env [ "RUST_LLVM_PROFDATA" ] = toolchain . llvm_profdata . path 493providers . append ( testing . TestEnvironment ( env )) 494 495return providers 496 497def _stamp_attribute ( default_value ): 498return attr . int ( 499doc = dedent ( """\ 500Whether to encode build information into the `Rustc` action. Possible values: 501 502- `stamp = 1`: Always stamp the build information into the `Rustc` action, even in \ 503[--nostamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) builds. \ 504This setting should be avoided, since it potentially kills remote caching for the target and \ 505any downstream actions that depend on it. 506 507- `stamp = 0`: Always replace build information by constant values. This gives good build result caching. 508 509- `stamp = -1`: Embedding of build information is controlled by the \ 510[--[no]stamp](https://docs.bazel.build/versions/main/user-manual.html#flag--stamp) flag. 511 512Stamped targets are not rebuilt unless their dependencies change. 513 514For example if a `rust_library` is stamped, and a `rust_binary` depends on that library, the stamped 515library won't be rebuilt when we change sources of the `rust_binary`. This is different from how 516[`cc_library.linkstamps`](https://docs.bazel.build/versions/main/be/c-cpp.html#cc_library.linkstamp) 517behaves. 518""" ), 519default = default_value , 520values = [ 1 , 0 , - 1 ], 521) 522 523_common_attrs = { 524"aliases" : attr . label_keyed_string_dict ( 525doc = dedent ( """\ 526Remap crates to a new name or moniker for linkage to this target 527 528These are other `rust_library` targets and will be presented as the new name given. 529""" ), 530), 531"compile_data" : attr . label_list ( 532doc = dedent ( """\ 533List of files used by this rule at compile time. 534 535This attribute can be used to specify any data files that are embedded into 536the library, such as via the 537[`include_str!`](https://doc.rust-lang.org/std/macro.include_str!.html) 538macro. 539""" ), 540allow_files = True , 541), 542"crate_features" : attr . string_list ( 543doc = dedent ( """\ 544List of features to enable for this crate. 545 546Features are defined in the code using the `#[cfg(feature = "foo")]` 547configuration option. The features listed here will be passed to `rustc` 548with `--cfg feature="${feature_name}"` flags. 549""" ), 550), 551"crate_name" : attr . string ( 552doc = dedent ( """\ 553Crate name to use for this target. 554 555This must be a valid Rust identifier, i.e. it may contain only alphanumeric characters and underscores. 556Defaults to the target name, with any hyphens replaced by underscores. 557""" ), 558), 559"crate_root" : attr . label ( 560doc = dedent ( """\ 561The file that will be passed to `rustc` to be used for building this crate. 562 563If `crate_root` is not set, then this rule will look for a `lib.rs` file (or `main.rs` for rust_binary) 564or the single file in `srcs` if `srcs` contains only one file. 565""" ), 566allow_single_file = [ ".rs" ], 567), 568"data" : attr . label_list ( 569doc = dedent ( """\ 570List of files used by this rule at compile time and runtime. 571 572If including data at compile time with include_str!() and similar, 573prefer `compile_data` over `data`, to prevent the data also being included 574in the runfiles. 575""" ), 576allow_files = True , 577), 578"deps" : attr . label_list ( 579doc = dedent ( """\ 580List of other libraries to be linked to this library target. 581 582These can be either other `rust_library` targets or `cc_library` targets if 583linking a native library. 584""" ), 585), 586"edition" : attr . string ( 587doc = "The rust edition to use for this crate. Defaults to the edition specified in the rust_toolchain." , 588), 589# Previously `proc_macro_deps` were a part of `deps`, and then proc_macro_host_transition was 590# used into cfg="host" using `@local_config_platform//:host`. 591# This fails for remote execution, which needs cfg="exec", and there isn't anything like 592# `@local_config_platform//:exec` exposed. 593"proc_macro_deps" : attr . label_list ( 594doc = dedent ( """\ 595List of `rust_library` targets with kind `proc-macro` used to help build this library target. 596""" ), 597cfg = "exec" , 598providers = [ rust_common . crate_info ], 599), 600"rustc_env" : attr . string_dict ( 601doc = dedent ( """\ 602Dictionary of additional `"key": "value"` environment variables to set for rustc. 603 604rust_test()/rust_binary() rules can use $(rootpath //package:target) to pass in the 605location of a generated file or external tool. Cargo build scripts that wish to 606expand locations should use cargo_build_script()'s build_script_env argument instead, 607as build scripts are run in a different environment - see cargo_build_script()'s 608documentation for more. 609""" ), 610), 611"rustc_env_files" : attr . label_list ( 612doc = dedent ( """\ 613 Files containing additional environment variables to set for rustc. 614 615 These files should contain a single variable per line, of format 616 `NAME=value`, and newlines may be included in a value by ending a 617 line with a trailing back-slash (`\\\\`). 618 619The order that these files will be processed is unspecified , so 620multiple definitions of a particular variable are discouraged . 621 622Note that the variables here are subject to 623[ workspace status ]( https : // docs . bazel . build / versions / main / user - manual . html #workspace_status) 624stamping should the `stamp` attribute be enabled . Stamp variables 625should be wrapped in brackets in order to be resolved . E . g . 626`NAME={WORKSPACE_STATUS_VARIABLE}` . 627"""), 628allow_files = True, 629), 630"rustc_flags": attr.string_list( 631doc = dedent(""" \ 632List of compiler flags passed to `rustc` . 633 634These strings are subject to Make variable expansion for predefined 635source / output path variables like `$location` , `$execpath` , and 636`$rootpath` . This expansion is useful if you wish to passa generated 637file of arguments to rustc : `@$(location //package:target)` . 638"""), 639), 640# TODO(stardoc): How do we provide additional documentation to an inherited attribute? 641# "name": attr.string( 642# doc = "This name will also be used as the name of the crate built by this rule.", 643# `), 644"srcs": attr.label_list( 645doc = dedent(""" \ 646List of Rust `.rs` source files used to build the library . 647 648If `srcs` contains more than one file , then there must be a file either 649named `lib.rs` . Otherwise , `crate_root` must be set to the source file that 650is the root of the crate to be passed to rustc to build this crate . 651"""), 652allow_files = [".rs"], 653), 654"stamp": _stamp_attribute(default_value = 0), 655"version": attr.string( 656doc = "A version to inject in the cargo environment variable.", 657default = "0.0.0", 658), 659"_cc_toolchain": attr.label( 660doc = ( 661"In order to use find_cc_toolchain, your rule has to depend " + 662"on C++ toolchain. See `@rules_cc//cc:find_cc_toolchain.bzl` " + 663"docs for details." 664), 665default = Label("@bazel_tools//tools/cpp:current_cc_toolchain"), 666), 667"_collect_cc_coverage": attr.label( 668default = Label("//util:collect_coverage"), 669executable = True, 670cfg = "exec", 671), 672"_error_format": attr.label( 673default = Label("//:error_format"), 674), 675"_extra_exec_rustc_flag": attr.label( 676default = Label("//:extra_exec_rustc_flag"), 677), 678"_extra_exec_rustc_flags": attr.label( 679default = Label("//:extra_exec_rustc_flags"), 680), 681"_extra_rustc_flag": attr.label( 682default = Label("//:extra_rustc_flag"), 683), 684"_extra_rustc_flags": attr.label( 685default = Label("//:extra_rustc_flags"), 686), 687"_import_macro_dep": attr.label( 688default = Label("//util/import"), 689cfg = "exec", 690), 691"_is_proc_macro_dep": attr.label( 692default = Label("//:is_proc_macro_dep"), 693), 694"_is_proc_macro_dep_enabled": attr.label( 695default = Label("//:is_proc_macro_dep_enabled"), 696), 697"_process_wrapper": attr.label( 698doc = "A process wrapper for running rustc on all platforms.", 699default = Label("//util/process_wrapper"), 700executable = True, 701allow_single_file = True, 702cfg = "exec", 703), 704"_stamp_flag": attr.label( 705doc = "A setting used to determine whether or not the `--stamp` flag is enabled", 706default = Label("//rust/private:stamp"), 707), 708} 709 710_rust_test_attrs = { 711"crate": attr.label( 712mandatory = False, 713doc = dedent(""" \ 714Target inline tests declared in the given crate 715 716These tests are typically those that would be held out under 717 `#[cfg(test)]` declarations. 718"""), 719), 720"env": attr.string_dict( 721mandatory = False, 722doc = dedent(""" \ 723Specifies additional environment variables to set when the test is executed by bazel test . 724Values are subject to `$(rootpath)` , `$(execpath)` , location , and 725[ "Make variable" ]( https : // docs . bazel . build / versions / master / be / make - variables . html ) substitution . 726 727Execpath returns absolute path , and in order to be able to construct the absolute path we 728need to wrap the test binary in a launcher . Using a launcher comes with complications , such as 729more complicated debugger attachment . 730"""), 731), 732"use_libtest_harness": attr.bool( 733mandatory = False, 734default = True, 735doc = dedent(""" \ 736Whether to use `libtest` . For targets using this flag , individual tests can be run by using the 737[ -- test_arg ]( https : // docs . bazel . build / versions / 4.0 . 0 / command - line - reference . html #flag--test_arg) flag. 738E . g . `bazel test //src:rust_test --test_arg=foo::test::test_fn` . 739"""), 740), 741"_grep_includes": attr.label( 742allow_single_file = True, 743cfg = "exec", 744default = Label("@bazel_tools//tools/cpp:grep-includes"), 745executable = True, 746), 747} 748 749_common_providers = [ 750rust_common.crate_info, 751rust_common.dep_info, 752DefaultInfo, 753] 754 755rust_library = rule( 756implementation = _rust_library_impl, 757provides = _common_providers, 758attrs = dict(_common_attrs.items()), 759fragments = ["cpp"], 760host_fragments = ["cpp"], 761toolchains = [ 762str(Label("//rust:toolchain")), 763"@bazel_tools//tools/cpp:toolchain_type", 764], 765incompatible_use_toolchain_transition = True, 766doc = dedent(""" \ 767Builds a Rust library crate . 768 769Example : 770 771Suppose you have the following directory structure for a simple Rust library crate : 772 773`` `output 774[ workspace ] / 775WORKSPACE 776hello_lib / 777BUILD 778src / 779greeter . rs 780lib . rs 781`` ` 782 783`hello_lib/src/greeter.rs` : 784`` `rust 785pub struct Greeter { 786greeting : String , 787} 788 789impl Greeter { 790pub fn new ( greeting : & str ) -> Greeter { 791Greeter { greeting : greeting . to_string (), } 792} 793 794pub fn greet ( & self , thing : & str ) { 795println !( "{} {}" , & self . greeting , thing ) ; 796} 797} 798`` ` 799 800`hello_lib/src/lib.rs` : 801 802`` `rust 803pub mod greeter ; 804`` ` 805 806`hello_lib/BUILD` : 807`` `python 808package ( default_visibility = [ "//visibility:public" ]) 809 810load ( "@rules_rust//rust:defs.bzl" , "rust_library" ) 811 812rust_library ( 813name = "hello_lib" , 814srcs = [ 815"src/greeter.rs" , 816"src/lib.rs" , 817], 818) 819`` ` 820 821Build the library : 822`` `output 823 $bazel build // hello_lib 824INFO : Found 1 target ... 825Target // examples / rust / hello_lib : hello_lib up - to - date : 826bazel - bin / examples / rust / hello_lib / libhello_lib . rlib 827INFO : Elapsed time : 1.245 s , Critical Path : 1.01 s 828`` ` 829"""), 830) 831 832rust_static_library = rule( 833implementation = _rust_static_library_impl, 834attrs = dict(_common_attrs.items()), 835fragments = ["cpp"], 836host_fragments = ["cpp"], 837toolchains = [ 838str(Label("//rust:toolchain")), 839"@bazel_tools//tools/cpp:toolchain_type", 840], 841incompatible_use_toolchain_transition = True, 842doc = dedent(""" \ 843Builds a Rust static library . 844 845This static library will contain all transitively reachable crates and native objects . 846It is meant to be used when producing an artifact that is then consumed by some other build system 847( for example to produce an archive that Python program links against ). 848 849This rule provides CcInfo , so it can be used everywhere Bazel expects `rules_cc` . 850 851When building the whole binary in Bazel , use `rust_library` instead . 852"""), 853) 854 855rust_shared_library = rule( 856implementation = _rust_shared_library_impl, 857attrs = dict(_common_attrs.items()), 858fragments = ["cpp"], 859host_fragments = ["cpp"], 860toolchains = [ 861str(Label("//rust:toolchain")), 862"@bazel_tools//tools/cpp:toolchain_type", 863], 864incompatible_use_toolchain_transition = True, 865doc = dedent(""" \ 866Builds a Rust shared library . 867 868This shared library will contain all transitively reachable crates and native objects . 869It is meant to be used when producing an artifact that is then consumed by some other build system 870( for example to produce a shared library that Python program links against ). 871 872This rule provides CcInfo , so it can be used everywhere Bazel expects `rules_cc` . 873 874When building the whole binary in Bazel , use `rust_library` instead . 875"""), 876) 877 878def _proc_macro_dep_transition_impl(settings, _attr): 879if settings["//:is_proc_macro_dep_enabled"]: 880return {"//:is_proc_macro_dep": True} 881else: 882return [] 883 884_proc_macro_dep_transition = transition( 885inputs = ["//:is_proc_macro_dep_enabled"], 886outputs = ["//:is_proc_macro_dep"], 887implementation = _proc_macro_dep_transition_impl, 888) 889 890rust_proc_macro = rule( 891implementation = _rust_proc_macro_impl, 892provides = _common_providers, 893# Start by copying the common attributes, then override the `deps` attribute 894# to apply `_proc_macro_dep_transition`. To add this transition we additionally 895# need to declare `_allowlist_function_transition`, see 896# https://docs.bazel.build/versions/main/skylark/config.html#user-defined-transitions. 897attrs = dict( 898_common_attrs.items(), 899_allowlist_function_transition = attr.label(default = Label("//tools/allowlists/function_transition_allowlist")), 900deps = attr.label_list( 901doc = dedent(""" \ 902List of other libraries to be linked to this library target . 903 904These can be either other `rust_library` targets or `cc_library` targets if 905linking a native library . 906"""), 907cfg = _proc_macro_dep_transition, 908), 909), 910fragments = ["cpp"], 911host_fragments = ["cpp"], 912toolchains = [ 913str(Label("//rust:toolchain")), 914"@bazel_tools//tools/cpp:toolchain_type", 915], 916incompatible_use_toolchain_transition = True, 917doc = dedent(""" \ 918Builds a Rust proc - macro crate . 919"""), 920) 921 922_rust_binary_attrs = { 923"crate_type": attr.string( 924doc = dedent(""" \ 925Crate type that will be passed to `rustc` to be used for building this crate . 926 927This option is a temporary workaround and should be used only when building 928for WebAssembly targets ( // rust / platform : wasi and // rust / platform : wasm ). 929"""), 930default = "bin", 931), 932"linker_script": attr.label( 933doc = dedent(""" \ 934Link script to forward into linker via rustc options . 935"""), 936cfg = "exec", 937allow_single_file = True, 938), 939"out_binary": attr.bool( 940doc = ( 941"Force a target, regardless of it's `crate_type`, to always mark the " + 942"file as executable. This attribute is only used to support wasm targets but is " + 943"expected to be removed following a resolution to https://github.com/bazelbuild/rules_rust/issues/771." 944), 945default = False, 946), 947"stamp": _stamp_attribute(default_value = -1), 948"_grep_includes": attr.label( 949allow_single_file = True, 950cfg = "exec", 951default = Label("@bazel_tools//tools/cpp:grep-includes"), 952executable = True, 953), 954} 955 956rust_binary = rule( 957implementation = _rust_binary_impl, 958provides = _common_providers, 959attrs = dict(_common_attrs.items() + _rust_binary_attrs.items()), 960executable = True, 961fragments = ["cpp"], 962host_fragments = ["cpp"], 963toolchains = [ 964str(Label("//rust:toolchain")), 965"@bazel_tools//tools/cpp:toolchain_type", 966], 967incompatible_use_toolchain_transition = True, 968doc = dedent(""" \ 969Builds a Rust binary crate . 970 971Example : 972 973Suppose you have the following directory structure for a Rust project with a 974library crate , `hello_lib` , and a binary crate , `hello_world` that uses the 975`hello_lib` library : 976 977`` `output 978[ workspace ] / 979WORKSPACE 980hello_lib / 981BUILD 982src / 983lib . rs 984hello_world / 985BUILD 986src / 987main . rs 988`` ` 989 990`hello_lib/src/lib.rs` : 991`` `rust 992pub struct Greeter { 993greeting : String , 994} 995 996impl Greeter { 997pub fn new ( greeting : & str ) -> Greeter { 998Greeter { greeting : greeting . to_string (), } 999} 1000 1001pub fn greet ( & self , thing : & str ) { 1002println !( "{} {}" , & self . greeting , thing ) ; 1003} 1004} 1005`` ` 1006 1007`hello_lib/BUILD` : 1008`` `python 1009package ( default_visibility = [ "//visibility:public" ]) 1010 1011load ( "@rules_rust//rust:defs.bzl" , "rust_library" ) 1012 1013rust_library ( 1014name = "hello_lib" , 1015srcs = [ "src/lib.rs" ], 1016) 1017`` ` 1018 1019`hello_world/src/main.rs` : 1020`` `rust 1021extern crate hello_lib ; 1022 1023fn main () { 1024let hello = hello_lib :: Greeter :: new ( "Hello" ) ; 1025hello . greet ( "world" ) ; 1026} 1027`` ` 1028 1029`hello_world/BUILD` : 1030`` `python 1031load ( "@rules_rust//rust:defs.bzl" , "rust_binary" ) 1032 1033rust_binary ( 1034name = "hello_world" , 1035srcs = [ "src/main.rs" ], 1036deps = [ "//hello_lib" ], 1037) 1038`` ` 1039 1040Build and run `hello_world` : 1041`` ` 1042 $bazel run // hello_world 1043INFO : Found 1 target ... 1044Target // examples / rust / hello_world : hello_world up - to - date : 1045bazel - bin / examples / rust / hello_world / hello_world 1046INFO : Elapsed time : 1.308 s , Critical Path : 1.22 s 1047 1048INFO : Running command line : bazel - bin / examples / rust / hello_world / hello_world 1049Hello world 1050`` ` 1051 1052On Windows , a PDB file containing debugging information is available under 1053the key `pdb_file` in `OutputGroupInfo` . Similarly on macOS , a dSYM folder 1054is available under the key `dsym_folder` in `OutputGroupInfo` . 1055"""), 1056) 1057 1058def _common_attrs_for_binary_without_process_wrapper(attrs): 1059new_attr = dict(attrs) 1060 1061# use a fake process wrapper 1062new_attr["_process_wrapper"] = attr.label( 1063default = None, 1064executable = True, 1065allow_single_file = True, 1066cfg = "exec", 1067) 1068 1069# fix stamp = 0 1070new_attr["stamp"] = attr.int( 1071doc = dedent(""" \ 1072Fix `stamp = 0` as stamping is not supported when building without process_wrapper : 1073https : // github . com / bazelbuild / rules_rust / blob / 8 df4517d370b0c543a01ba38b63e1d5a4104b035 / rust / private / rustc . bzl #L955 1074"""), 1075default = 0, 1076values = [0], 1077) 1078 1079return new_attr 1080 1081# Provides an internal rust_{binary,library} to use that we can use to build the process 1082# wrapper, this breaks the dependency of rust_* on the process wrapper by 1083# setting it to None, which the functions in rustc detect and build accordingly. 1084rust_binary_without_process_wrapper = rule( 1085implementation = _rust_binary_impl, 1086provides = _common_providers, 1087attrs = _common_attrs_for_binary_without_process_wrapper(_common_attrs.items() + _rust_binary_attrs.items()), 1088executable = True, 1089fragments = ["cpp"], 1090host_fragments = ["cpp"], 1091toolchains = [ 1092str(Label("//rust:toolchain")), 1093"@bazel_tools//tools/cpp:toolchain_type", 1094], 1095incompatible_use_toolchain_transition = True, 1096) 1097 1098rust_library_without_process_wrapper = rule( 1099implementation = _rust_library_impl, 1100provides = _common_providers, 1101attrs = dict(_common_attrs_for_binary_without_process_wrapper(_common_attrs).items()), 1102fragments = ["cpp"], 1103host_fragments = ["cpp"], 1104toolchains = [ 1105str(Label("//rust:toolchain")), 1106"@bazel_tools//tools/cpp:toolchain_type", 1107], 1108incompatible_use_toolchain_transition = True, 1109) 1110 1111rust_test = rule( 1112implementation = _rust_test_impl, 1113provides = _common_providers, 1114attrs = dict(_common_attrs.items() + 1115_rust_test_attrs.items()), 1116executable = True, 1117fragments = ["cpp"], 1118host_fragments = ["cpp"], 1119test = True, 1120toolchains = [ 1121str(Label("//rust:toolchain")), 1122"@bazel_tools//tools/cpp:toolchain_type", 1123], 1124incompatible_use_toolchain_transition = True, 1125doc = dedent(""" \ 1126Builds a Rust test crate . 1127 1128Examples : 1129 1130Suppose you have the following directory structure for a Rust library crate \ 1131with unit test code in the library sources : 1132 1133`` `output 1134[ workspace ] / 1135WORKSPACE 1136hello_lib / 1137BUILD 1138src / 1139lib . rs 1140`` ` 1141 1142`hello_lib/src/lib.rs` : 1143`` `rust 1144pub struct Greeter { 1145greeting : String , 1146} 1147 1148impl Greeter { 1149pub fn new ( greeting : & str ) -> Greeter { 1150Greeter { greeting : greeting . to_string (), } 1151} 1152 1153pub fn greet ( & self , thing : & str ) -> String { 1154format !( "{} {}" , & self . greeting , thing ) 1155} 1156} 1157 1158#[cfg(test)] 1159mod test { 1160use super :: Greeter ; 1161 1162#[test] 1163fn test_greeting () { 1164let hello = Greeter :: new ( "Hi" ) ; 1165assert_eq !( "Hi Rust" , hello . greet ( "Rust" )) ; 1166} 1167} 1168`` ` 1169 1170To build and run the tests , simply add a `rust_test` rule with no `srcs` 1171and only depends on the `hello_lib` `rust_library` target via the 1172`crate` attribute : 1173 1174`hello_lib/BUILD` : 1175`` `python 1176load ( "@rules_rust//rust:defs.bzl" , "rust_library" , "rust_test" ) 1177 1178rust_library ( 1179name = "hello_lib" , 1180srcs = [ "src/lib.rs" ], 1181) 1182 1183rust_test ( 1184name = "hello_lib_test" , 1185crate = ":hello_lib" , 1186# You may add other deps that are specific to the test configuration 1187deps = [ "//some/dev/dep" ], 1188`` ` 1189 1190Run the test with `bazel test //hello_lib:hello_lib_test` . The crate 1191will be built using the same crate name as the underlying ":hello_lib" 1192crate . 1193 1194### Example: `test` directory 1195 1196Integration tests that live in the [ `tests` directory ][ int - tests ], they are \ 1197essentially built as separate crates . Suppose you have the following directory \ 1198structure where `greeting.rs` is an integration test for the `hello_lib` \ 1199library crate : 1200 1201[ int - tests ]: http : // doc . rust - lang . org / book / testing . html #the-tests-directory 1202 1203`` `output 1204[ workspace ] / 1205WORKSPACE 1206hello_lib / 1207BUILD 1208src / 1209lib . rs 1210tests / 1211greeting . rs 1212`` ` 1213 1214`hello_lib/tests/greeting.rs` : 1215`` `rust 1216extern crate hello_lib ; 1217 1218use hello_lib ; 1219 1220#[test] 1221fn test_greeting () { 1222let hello = greeter :: Greeter :: new ( "Hello" ) ; 1223assert_eq !( "Hello world" , hello . greeting ( "world" )) ; 1224} 1225`` ` 1226 1227To build the `greeting.rs` integration test , simply add a `rust_test` target 1228with `greeting.rs` in `srcs` and a dependency on the `hello_lib` target : 1229 1230`hello_lib/BUILD` : 1231`` `python 1232load ( "@rules_rust//rust:defs.bzl" , "rust_library" , "rust_test" ) 1233 1234rust_library ( 1235name = "hello_lib" , 1236srcs = [ "src/lib.rs" ], 1237) 1238 1239rust_test ( 1240name = "greeting_test" , 1241srcs = [ "tests/greeting.rs" ], 1242deps = [ ":hello_lib" ], 1243) 1244`` ` 1245 1246Run the test with `bazel test //hello_lib:greeting_test` . 1247"""), 1248) 1249 1250def rust_test_suite(name, srcs, **kwargs): 1251""" A rule for creating a test suite for a set of `rust_test` targets . 1252 1253This rule can be used for setting up typical rust [ integration tests ][ it ]. Given the following 1254directory structure : 1255 1256`` `text 1257[ crate ] / 1258BUILD . bazel 1259src / 1260lib . rs 1261main . rs 1262tests / 1263integrated_test_a . rs 1264integrated_test_b . rs 1265integrated_test_c . rs 1266patterns / 1267fibonacci_test . rs 1268`` ` 1269 1270The rule can be used to generate [ rust_test ]( #rust_test) targets for each source file under `tests` 1271and a [ test_suite ][ ts ] which encapsulates all tests . 1272 1273`` `python 1274load ( "//rust:defs.bzl" , "rust_binary" , "rust_library" , "rust_test_suite" ) 1275 1276rust_library ( 1277name = "math_lib" , 1278srcs = [ "src/lib.rs" ], 1279) 1280 1281rust_binary ( 1282name = "math_bin" , 1283srcs = [ "src/main.rs" ], 1284) 1285 1286rust_test_suite ( 1287name = "integrated_tests_suite" , 1288srcs = glob ([ "tests/**" ]), 1289deps = [ ":math_lib" ], 1290) 1291`` ` 1292 1293[ it ]: https : // doc . rust - lang . org / rust - by - example / testing / integration_testing . html 1294[ ts ]: https : // docs . bazel . build / versions / master / be / general . html #test_suite 1295 1296Args : 1297name ( str ): The name of the `test_suite` . 1298srcs ( list ): All test sources , typically `glob(["tests/**/*.rs"])` . 1299** kwargs ( dict ): Additional keyword arguments for the underyling [ rust_test ]( #rust_test) targets. The 1300`tags` argument is also passed to the generated `test_suite` target . 1301 """ 1302 tests = [] 1303 1304 for src in srcs: 1305 if not src.endswith(".rs"): 1306 fail("srcs should have `.rs` extensions") 1307 1308 # Prefixed with `name` to allow parameterization with macros 1309 # The test name should not end with `.rs` 1310 test_name = name + "_" + src[:-3] 1311 rust_test( 1312 name = test_name, 1313 srcs = [src], 1314 **kwargs 1315 ) 1316 tests.append(test_name) 1317 1318 native.test_suite( 1319 name = name, 1320 tests = tests, 1321 tags = kwargs.get("tags", None), 1322 )