fork/rules_rust
git clone https://git.julia.blue/fork/rules_rust
9adfdca9
rust-analyzer
1# Copyright 2020 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"""A module defining clippy rules""" 16 17load ( "//rust/private:common.bzl" , "rust_common" ) 18load ( "//rust/private:providers.bzl" , "CaptureClippyOutputInfo" , "ClippyInfo" ) 19load ( 20"//rust/private:rustc.bzl" , 21"collect_deps" , 22"collect_inputs" , 23"construct_arguments" , 24) 25load ( 26"//rust/private:utils.bzl" , 27"determine_output_hash" , 28"find_cc_toolchain" , 29"find_toolchain" , 30) 31 32ClippyFlagsInfo = provider ( 33doc = "Pass each value as an additional flag to clippy invocations" , 34fields = { "clippy_flags" : "List[string] Flags to pass to clippy" }, 35) 36 37def _clippy_flags_impl ( ctx ): 38return ClippyFlagsInfo ( clippy_flags = ctx . build_setting_value ) 39 40clippy_flags = rule ( 41doc = ( 42"Add custom clippy flags from the command line with `--@rules_rust//:clippy_flags`." 43), 44implementation = _clippy_flags_impl , 45build_setting = config . string_list ( flag = True ), 46) 47 48def _get_clippy_ready_crate_info ( target , aspect_ctx = None ): 49"""Check that a target is suitable for clippy and extract the `CrateInfo` provider from it. 50 51Args: 52target (Target): The target the aspect is running on. 53aspect_ctx (ctx, optional): The aspect's context object. 54 55Returns: 56CrateInfo, optional: A `CrateInfo` provider if clippy should be run or `None`. 57""" 58 59# Ignore external targets 60if target . label . workspace_root . startswith ( "external" ): 61return None 62 63# Targets with specific tags will not be formatted 64if aspect_ctx : 65ignore_tags = [ 66"noclippy" , 67"no-clippy" , 68] 69 70for tag in ignore_tags : 71if tag in aspect_ctx . rule . attr . tags : 72return None 73 74# Obviously ignore any targets that don't contain `CrateInfo` 75if rust_common . crate_info in target : 76return target [ rust_common . crate_info ] 77elif rust_common . test_crate_info in target : 78return target [ rust_common . test_crate_info ]. crate 79else : 80return None 81 82def _clippy_aspect_impl ( target , ctx ): 83crate_info = _get_clippy_ready_crate_info ( target , ctx ) 84if not crate_info : 85return [ ClippyInfo ( output = depset ([]))] 86 87toolchain = find_toolchain ( ctx ) 88cc_toolchain , feature_configuration = find_cc_toolchain ( ctx ) 89 90dep_info , build_info , linkstamps = collect_deps ( 91deps = crate_info . deps , 92proc_macro_deps = crate_info . proc_macro_deps , 93aliases = crate_info . aliases , 94# Clippy doesn't need to invoke transitive linking, therefore doesn't need linkstamps. 95are_linkstamps_supported = False , 96) 97 98compile_inputs , out_dir , build_env_files , build_flags_files , linkstamp_outs , ambiguous_libs = collect_inputs ( 99ctx , 100ctx . rule . file , 101ctx . rule . files , 102linkstamps , 103toolchain , 104cc_toolchain , 105feature_configuration , 106crate_info , 107dep_info , 108build_info , 109) 110 111args , env = construct_arguments ( 112ctx = ctx , 113attr = ctx . rule . attr , 114file = ctx . file , 115toolchain = toolchain , 116tool_path = toolchain . clippy_driver . path , 117cc_toolchain = cc_toolchain , 118feature_configuration = feature_configuration , 119crate_info = crate_info , 120dep_info = dep_info , 121linkstamp_outs = linkstamp_outs , 122ambiguous_libs = ambiguous_libs , 123output_hash = determine_output_hash ( crate_info . root , ctx . label ), 124rust_flags = [], 125out_dir = out_dir , 126build_env_files = build_env_files , 127build_flags_files = build_flags_files , 128emit = [ "dep-info" , "metadata" ], 129) 130 131if crate_info . is_test : 132args . rustc_flags . add ( "--test" ) 133 134clippy_flags = ctx . attr . _clippy_flags [ ClippyFlagsInfo ]. clippy_flags 135 136# For remote execution purposes, the clippy_out file must be a sibling of crate_info.output 137# or rustc may fail to create intermediate output files because the directory does not exist. 138if ctx . attr . _capture_output [ CaptureClippyOutputInfo ]. capture_output : 139clippy_out = ctx . actions . declare_file ( ctx . label . name + ".clippy.out" , sibling = crate_info . output ) 140args . process_wrapper_flags . add ( "--stderr-file" , clippy_out . path ) 141 142if clippy_flags : 143fail ( """Combining @rules_rust//:clippy_flags with @rules_rust//:capture_clippy_output=true is currently not supported. 144See https://github.com/bazelbuild/rules_rust/pull/1264#discussion_r853241339 for more detail.""" ) 145 146# If we are capturing the output, we want the build system to be able to keep going 147# and consume the output. Some clippy lints are denials, so we treat them as warnings. 148args . rustc_flags . add ( "-Wclippy::all" ) 149else : 150# A marker file indicating clippy has executed successfully. 151# This file is necessary because "ctx.actions.run" mandates an output. 152clippy_out = ctx . actions . declare_file ( ctx . label . name + ".clippy.ok" , sibling = crate_info . output ) 153args . process_wrapper_flags . add ( "--touch-file" , clippy_out . path ) 154 155if clippy_flags : 156args . rustc_flags . add_all ( clippy_flags ) 157else : 158# The user didn't provide any clippy flags explicitly so we apply conservative defaults. 159 160# Turn any warnings from clippy or rustc into an error, as otherwise 161# Bazel will consider the execution result of the aspect to be "success", 162# and Clippy won't be re-triggered unless the source file is modified. 163args . rustc_flags . add ( "-Dwarnings" ) 164 165# Upstream clippy requires one of these two filenames or it silently uses 166# the default config. Enforce the naming so users are not confused. 167valid_config_file_names = [ ".clippy.toml" , "clippy.toml" ] 168if ctx . file . _config . basename not in valid_config_file_names : 169fail ( "The clippy config file must be named one of: {}" . format ( valid_config_file_names )) 170env [ "CLIPPY_CONF_DIR" ] = "${{pwd}}/{}" . format ( ctx . file . _config . dirname ) 171compile_inputs = depset ([ ctx . file . _config ], transitive = [ compile_inputs ]) 172 173ctx . actions . run ( 174executable = ctx . executable . _process_wrapper , 175inputs = compile_inputs , 176outputs = [ clippy_out ], 177env = env , 178tools = [ toolchain . clippy_driver ], 179arguments = args . all , 180mnemonic = "Clippy" , 181) 182 183return [ 184OutputGroupInfo ( clippy_checks = depset ([ clippy_out ])), 185ClippyInfo ( output = depset ([ clippy_out ])), 186] 187 188# Example: Run the clippy checker on all targets in the codebase. 189# bazel build --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect \ 190# --output_groups=clippy_checks \ 191# //... 192rust_clippy_aspect = aspect ( 193fragments = [ "cpp" ], 194host_fragments = [ "cpp" ], 195attrs = { 196"_capture_output" : attr . label ( 197doc = "Value of the `capture_clippy_output` build setting" , 198default = Label ( "//:capture_clippy_output" ), 199), 200"_cc_toolchain" : attr . label ( 201doc = ( 202"Required attribute to access the cc_toolchain. See [Accessing the C++ toolchain]" + 203"(https://docs.bazel.build/versions/master/integrating-with-rules-cc.html#accessing-the-c-toolchain)" 204), 205default = Label ( "@bazel_tools//tools/cpp:current_cc_toolchain" ), 206), 207"_clippy_flags" : attr . label ( 208doc = "Arguments to pass to clippy" , 209default = Label ( "//:clippy_flags" ), 210), 211"_config" : attr . label ( 212doc = "The `clippy.toml` file used for configuration" , 213allow_single_file = True , 214default = Label ( "//:clippy.toml" ), 215), 216"_error_format" : attr . label ( 217doc = "The desired `--error-format` flags for clippy" , 218default = "//:error_format" , 219), 220"_extra_rustc_flag" : attr . label ( 221default = Label ( "//:extra_rustc_flag" ), 222), 223"_extra_rustc_flags" : attr . label ( 224default = Label ( "//:extra_rustc_flags" ), 225), 226"_process_wrapper" : attr . label ( 227doc = "A process wrapper for running clippy on all platforms" , 228default = Label ( "//util/process_wrapper" ), 229executable = True , 230cfg = "exec" , 231), 232}, 233provides = [ ClippyInfo ], 234required_providers = [ 235[ rust_common . crate_info ], 236[ rust_common . test_crate_info ], 237], 238toolchains = [ 239str ( Label ( "//rust:toolchain_type" )), 240"@bazel_tools//tools/cpp:toolchain_type" , 241], 242incompatible_use_toolchain_transition = True , 243implementation = _clippy_aspect_impl , 244doc = """\ 245Executes the clippy checker on specified targets. 246 247This aspect applies to existing rust_library, rust_test, and rust_binary rules. 248 249As an example, if the following is defined in `examples/hello_lib/BUILD.bazel`: 250 251```python 252load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test") 253 254rust_library( 255name = "hello_lib", 256srcs = ["src/lib.rs"], 257) 258 259rust_test( 260name = "greeting_test", 261srcs = ["tests/greeting.rs"], 262deps = [":hello_lib"], 263) 264``` 265 266Then the targets can be analyzed with clippy using the following command: 267 268```output 269$ bazel build --aspects=@rules_rust//rust:defs.bzl%rust_clippy_aspect \ 270--output_groups=clippy_checks //hello_lib:all 271``` 272""" , 273) 274 275def _rust_clippy_rule_impl ( ctx ): 276clippy_ready_targets = [ dep for dep in ctx . attr . deps if "clippy_checks" in dir ( dep [ OutputGroupInfo ])] 277files = depset ([], transitive = [ dep [ OutputGroupInfo ]. clippy_checks for dep in clippy_ready_targets ]) 278return [ DefaultInfo ( files = files )] 279 280rust_clippy = rule ( 281implementation = _rust_clippy_rule_impl , 282attrs = { 283"deps" : attr . label_list ( 284doc = "Rust targets to run clippy on." , 285providers = [ rust_common . crate_info ], 286aspects = [ rust_clippy_aspect ], 287), 288}, 289doc = """\ 290Executes the clippy checker on a specific target. 291 292Similar to `rust_clippy_aspect`, but allows specifying a list of dependencies \ 293within the build system. 294 295For example, given the following example targets: 296 297```python 298load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test") 299 300rust_library( 301name = "hello_lib", 302srcs = ["src/lib.rs"], 303) 304 305rust_test( 306name = "greeting_test", 307srcs = ["tests/greeting.rs"], 308deps = [":hello_lib"], 309) 310``` 311 312Rust clippy can be set as a build target with the following: 313 314```python 315load("@rules_rust//rust:defs.bzl", "rust_clippy") 316 317rust_clippy( 318name = "hello_library_clippy", 319testonly = True, 320deps = [ 321":hello_lib", 322":greeting_test", 323], 324) 325``` 326""" , 327) 328 329def _capture_clippy_output_impl ( ctx ): 330"""Implementation of the `capture_clippy_output` rule 331 332Args: 333ctx (ctx): The rule's context object 334 335Returns: 336list: A list containing the CaptureClippyOutputInfo provider 337""" 338return [ CaptureClippyOutputInfo ( capture_output = ctx . build_setting_value )] 339 340capture_clippy_output = rule ( 341doc = "Control whether to print clippy output or store it to a file, using the configured error_format." , 342implementation = _capture_clippy_output_impl , 343build_setting = config . bool ( flag = True ), 344)