src/lintlist/mod.rs

   1 //! This file is managed by `util/dev update_lints`. Do not edit.
   2
   3 pub mod lint;
   4 pub use lint::Level;
   5 pub use lint::Lint;
   6 pub use lint::LINT_LEVELS;
   7
   8 // begin lint list, do not remove this comment, it’s used in `update_lints`
   9 pub const ALL_LINTS: [Lint; 306] = [
  10     Lint {
  11         name: "absurd_extreme_comparisons",
  12         group: "correctness",
  13         desc: "a comparison with a maximum or minimum value that is always true or false",
  14         deprecation: None,
  15         module: "types",
  16     },
  17     Lint {
  18         name: "almost_swapped",
  19         group: "correctness",
  20         desc: "`foo = bar; bar = foo` sequence",
  21         deprecation: None,
  22         module: "swap",
  23     },
  24     Lint {
  25         name: "approx_constant",
  26         group: "correctness",
  27         desc: "the approximate of a known float constant (in `std::fXX::consts`)",
  28         deprecation: None,
  29         module: "approx_const",
  30     },
  31     Lint {
  32         name: "assertions_on_constants",
  33         group: "style",
  34         desc: "`assert!(true)` / `assert!(false)` will be optimized out by the compiler, and should probably be replaced by a `panic!()` or `unreachable!()`",
  35         deprecation: None,
  36         module: "assertions_on_constants",
  37     },
  38     Lint {
  39         name: "assign_op_pattern",
  40         group: "style",
  41         desc: "assigning the result of an operation on a variable to that same variable",
  42         deprecation: None,
  43         module: "assign_ops",
  44     },
  45     Lint {
  46         name: "bad_bit_mask",
  47         group: "correctness",
  48         desc: "expressions of the form `_ & mask == select` that will only ever return `true` or `false`",
  49         deprecation: None,
  50         module: "bit_mask",
  51     },
  52     Lint {
  53         name: "blacklisted_name",
  54         group: "style",
  55         desc: "usage of a blacklisted/placeholder name",
  56         deprecation: None,
  57         module: "blacklisted_name",
  58     },
  59     Lint {
  60         name: "block_in_if_condition_expr",
  61         group: "style",
  62         desc: "braces that can be eliminated in conditions, e.g., `if { true } ...`",
  63         deprecation: None,
  64         module: "block_in_if_condition",
  65     },
  66     Lint {
  67         name: "block_in_if_condition_stmt",
  68         group: "style",
  69         desc: "complex blocks in conditions, e.g., `if { let x = true; x } ...`",
  70         deprecation: None,
  71         module: "block_in_if_condition",
  72     },
  73     Lint {
  74         name: "bool_comparison",
  75         group: "complexity",
  76         desc: "comparing a variable to a boolean, e.g., `if x == true` or `if x != true`",
  77         deprecation: None,
  78         module: "needless_bool",
  79     },
  80     Lint {
  81         name: "borrow_interior_mutable_const",
  82         group: "correctness",
  83         desc: "referencing const with interior mutability",
  84         deprecation: None,
  85         module: "non_copy_const",
  86     },
  87     Lint {
  88         name: "borrowed_box",
  89         group: "complexity",
  90         desc: "a borrow of a boxed type",
  91         deprecation: None,
  92         module: "types",
  93     },
  94     Lint {
  95         name: "box_vec",
  96         group: "perf",
  97         desc: "usage of `Box<Vec<T>>`, vector elements are already on the heap",
  98         deprecation: None,
  99         module: "types",
 100     },
 101     Lint {
 102         name: "boxed_local",
 103         group: "perf",
 104         desc: "using `Box<T>` where unnecessary",
 105         deprecation: None,
 106         module: "escape",
 107     },
 108     Lint {
 109         name: "builtin_type_shadow",
 110         group: "style",
 111         desc: "shadowing a builtin type",
 112         deprecation: None,
 113         module: "misc_early",
 114     },
 115     Lint {
 116         name: "cargo_common_metadata",
 117         group: "cargo",
 118         desc: "common metadata is defined in `Cargo.toml`",
 119         deprecation: None,
 120         module: "cargo_common_metadata",
 121     },
 122     Lint {
 123         name: "cast_lossless",
 124         group: "complexity",
 125         desc: "casts using `as` that are known to be lossless, e.g., `x as u64` where `x: u8`",
 126         deprecation: None,
 127         module: "types",
 128     },
 129     Lint {
 130         name: "cast_possible_truncation",
 131         group: "pedantic",
 132         desc: "casts that may cause truncation of the value, e.g., `x as u8` where `x: u32`, or `x as i32` where `x: f32`",
 133         deprecation: None,
 134         module: "types",
 135     },
 136     Lint {
 137         name: "cast_possible_wrap",
 138         group: "pedantic",
 139         desc: "casts that may cause wrapping around the value, e.g., `x as i32` where `x: u32` and `x > i32::MAX`",
 140         deprecation: None,
 141         module: "types",
 142     },
 143     Lint {
 144         name: "cast_precision_loss",
 145         group: "pedantic",
 146         desc: "casts that cause loss of precision, e.g., `x as f32` where `x: u64`",
 147         deprecation: None,
 148         module: "types",
 149     },
 150     Lint {
 151         name: "cast_ptr_alignment",
 152         group: "correctness",
 153         desc: "cast from a pointer to a more-strictly-aligned pointer",
 154         deprecation: None,
 155         module: "types",
 156     },
 157     Lint {
 158         name: "cast_ref_to_mut",
 159         group: "correctness",
 160         desc: "a cast of reference to a mutable pointer",
 161         deprecation: None,
 162         module: "types",
 163     },
 164     Lint {
 165         name: "cast_sign_loss",
 166         group: "pedantic",
 167         desc: "casts from signed types to unsigned types, e.g., `x as u32` where `x: i32`",
 168         deprecation: None,
 169         module: "types",
 170     },
 171     Lint {
 172         name: "char_lit_as_u8",
 173         group: "complexity",
 174         desc: "casting a character literal to u8",
 175         deprecation: None,
 176         module: "types",
 177     },
 178     Lint {
 179         name: "chars_last_cmp",
 180         group: "style",
 181         desc: "using `.chars().last()` or `.chars().next_back()` to check if a string ends with a char",
 182         deprecation: None,
 183         module: "methods",
 184     },
 185     Lint {
 186         name: "chars_next_cmp",
 187         group: "complexity",
 188         desc: "using `.chars().next()` to check if a string starts with a char",
 189         deprecation: None,
 190         module: "methods",
 191     },
 192     Lint {
 193         name: "checked_conversions",
 194         group: "pedantic",
 195         desc: "`try_from` could replace manual bounds checking when casting",
 196         deprecation: None,
 197         module: "checked_conversions",
 198     },
 199     Lint {
 200         name: "clone_double_ref",
 201         group: "correctness",
 202         desc: "using `clone` on `&&T`",
 203         deprecation: None,
 204         module: "methods",
 205     },
 206     Lint {
 207         name: "clone_on_copy",
 208         group: "complexity",
 209         desc: "using `clone` on a `Copy` type",
 210         deprecation: None,
 211         module: "methods",
 212     },
 213     Lint {
 214         name: "clone_on_ref_ptr",
 215         group: "restriction",
 216         desc: "using \'clone\' on a ref-counted pointer",
 217         deprecation: None,
 218         module: "methods",
 219     },
 220     Lint {
 221         name: "cmp_nan",
 222         group: "correctness",
 223         desc: "comparisons to NAN, which will always return false, probably not intended",
 224         deprecation: None,
 225         module: "misc",
 226     },
 227     Lint {
 228         name: "cmp_null",
 229         group: "style",
 230         desc: "comparing a pointer to a null pointer, suggesting to use `.is_null()` instead.",
 231         deprecation: None,
 232         module: "ptr",
 233     },
 234     Lint {
 235         name: "cmp_owned",
 236         group: "perf",
 237         desc: "creating owned instances for comparing with others, e.g., `x == \"foo\".to_string()`",
 238         deprecation: None,
 239         module: "misc",
 240     },
 241     Lint {
 242         name: "cognitive_complexity",
 243         group: "complexity",
 244         desc: "functions that should be split up into multiple functions",
 245         deprecation: None,
 246         module: "cognitive_complexity",
 247     },
 248     Lint {
 249         name: "collapsible_if",
 250         group: "style",
 251         desc: "`if`s that can be collapsed (e.g., `if x { if y { ... } }` and `else { if x { ... } }`)",
 252         deprecation: None,
 253         module: "collapsible_if",
 254     },
 255     Lint {
 256         name: "copy_iterator",
 257         group: "pedantic",
 258         desc: "implementing `Iterator` on a `Copy` type",
 259         deprecation: None,
 260         module: "copy_iterator",
 261     },
 262     Lint {
 263         name: "crosspointer_transmute",
 264         group: "complexity",
 265         desc: "transmutes that have to or from types that are a pointer to the other",
 266         deprecation: None,
 267         module: "transmute",
 268     },
 269     Lint {
 270         name: "dbg_macro",
 271         group: "restriction",
 272         desc: "`dbg!` macro is intended as a debugging tool",
 273         deprecation: None,
 274         module: "dbg_macro",
 275     },
 276     Lint {
 277         name: "decimal_literal_representation",
 278         group: "restriction",
 279         desc: "using decimal representation when hexadecimal would be better",
 280         deprecation: None,
 281         module: "literal_representation",
 282     },
 283     Lint {
 284         name: "declare_interior_mutable_const",
 285         group: "correctness",
 286         desc: "declaring const with interior mutability",
 287         deprecation: None,
 288         module: "non_copy_const",
 289     },
 290     Lint {
 291         name: "default_trait_access",
 292         group: "pedantic",
 293         desc: "checks for literal calls to Default::default()",
 294         deprecation: None,
 295         module: "default_trait_access",
 296     },
 297     Lint {
 298         name: "deprecated_cfg_attr",
 299         group: "complexity",
 300         desc: "usage of `cfg_attr(rustfmt)` instead of `tool_attributes`",
 301         deprecation: None,
 302         module: "attrs",
 303     },
 304     Lint {
 305         name: "deprecated_semver",
 306         group: "correctness",
 307         desc: "use of `#[deprecated(since = \"x\")]` where x is not semver",
 308         deprecation: None,
 309         module: "attrs",
 310     },
 311     Lint {
 312         name: "deref_addrof",
 313         group: "complexity",
 314         desc: "use of `*&` or `*&mut` in an expression",
 315         deprecation: None,
 316         module: "reference",
 317     },
 318     Lint {
 319         name: "derive_hash_xor_eq",
 320         group: "correctness",
 321         desc: "deriving `Hash` but implementing `PartialEq` explicitly",
 322         deprecation: None,
 323         module: "derive",
 324     },
 325     Lint {
 326         name: "diverging_sub_expression",
 327         group: "complexity",
 328         desc: "whether an expression contains a diverging sub expression",
 329         deprecation: None,
 330         module: "eval_order_dependence",
 331     },
 332     Lint {
 333         name: "doc_markdown",
 334         group: "pedantic",
 335         desc: "presence of `_`, `::` or camel-case outside backticks in documentation",
 336         deprecation: None,
 337         module: "doc",
 338     },
 339     Lint {
 340         name: "double_comparisons",
 341         group: "complexity",
 342         desc: "unnecessary double comparisons that can be simplified",
 343         deprecation: None,
 344         module: "double_comparison",
 345     },
 346     Lint {
 347         name: "double_neg",
 348         group: "style",
 349         desc: "`--x`, which is a double negation of `x` and not a pre-decrement as in C/C++",
 350         deprecation: None,
 351         module: "misc_early",
 352     },
 353     Lint {
 354         name: "double_parens",
 355         group: "complexity",
 356         desc: "Warn on unnecessary double parentheses",
 357         deprecation: None,
 358         module: "double_parens",
 359     },
 360     Lint {
 361         name: "drop_bounds",
 362         group: "correctness",
 363         desc: "Bounds of the form `T: Drop` are useless",
 364         deprecation: None,
 365         module: "drop_bounds",
 366     },
 367     Lint {
 368         name: "drop_copy",
 369         group: "correctness",
 370         desc: "calls to `std::mem::drop` with a value that implements Copy",
 371         deprecation: None,
 372         module: "drop_forget_ref",
 373     },
 374     Lint {
 375         name: "drop_ref",
 376         group: "correctness",
 377         desc: "calls to `std::mem::drop` with a reference instead of an owned value",
 378         deprecation: None,
 379         module: "drop_forget_ref",
 380     },
 381     Lint {
 382         name: "duplicate_underscore_argument",
 383         group: "style",
 384         desc: "function arguments having names which only differ by an underscore",
 385         deprecation: None,
 386         module: "misc_early",
 387     },
 388     Lint {
 389         name: "duration_subsec",
 390         group: "complexity",
 391         desc: "checks for calculation of subsecond microseconds or milliseconds",
 392         deprecation: None,
 393         module: "duration_subsec",
 394     },
 395     Lint {
 396         name: "else_if_without_else",
 397         group: "restriction",
 398         desc: "if expression with an `else if`, but without a final `else` branch",
 399         deprecation: None,
 400         module: "else_if_without_else",
 401     },
 402     Lint {
 403         name: "empty_enum",
 404         group: "pedantic",
 405         desc: "enum with no variants",
 406         deprecation: None,
 407         module: "empty_enum",
 408     },
 409     Lint {
 410         name: "empty_line_after_outer_attr",
 411         group: "nursery",
 412         desc: "empty line after outer attribute",
 413         deprecation: None,
 414         module: "attrs",
 415     },
 416     Lint {
 417         name: "empty_loop",
 418         group: "style",
 419         desc: "empty `loop {}`, which should block or sleep",
 420         deprecation: None,
 421         module: "loops",
 422     },
 423     Lint {
 424         name: "enum_clike_unportable_variant",
 425         group: "correctness",
 426         desc: "C-like enums that are `repr(isize/usize)` and have values that don\'t fit into an `i32`",
 427         deprecation: None,
 428         module: "enum_clike",
 429     },
 430     Lint {
 431         name: "enum_glob_use",
 432         group: "pedantic",
 433         desc: "use items that import all variants of an enum",
 434         deprecation: None,
 435         module: "enum_glob_use",
 436     },
 437     Lint {
 438         name: "enum_variant_names",
 439         group: "style",
 440         desc: "enums where all variants share a prefix/postfix",
 441         deprecation: None,
 442         module: "enum_variants",
 443     },
 444     Lint {
 445         name: "eq_op",
 446         group: "correctness",
 447         desc: "equal operands on both sides of a comparison or bitwise combination (e.g., `x == x`)",
 448         deprecation: None,
 449         module: "eq_op",
 450     },
 451     Lint {
 452         name: "erasing_op",
 453         group: "correctness",
 454         desc: "using erasing operations, e.g., `x * 0` or `y & 0`",
 455         deprecation: None,
 456         module: "erasing_op",
 457     },
 458     Lint {
 459         name: "eval_order_dependence",
 460         group: "complexity",
 461         desc: "whether a variable read occurs before a write depends on sub-expression evaluation order",
 462         deprecation: None,
 463         module: "eval_order_dependence",
 464     },
 465     Lint {
 466         name: "excessive_precision",
 467         group: "style",
 468         desc: "excessive precision for float literal",
 469         deprecation: None,
 470         module: "excessive_precision",
 471     },
 472     Lint {
 473         name: "expect_fun_call",
 474         group: "perf",
 475         desc: "using any `expect` method with a function call",
 476         deprecation: None,
 477         module: "methods",
 478     },
 479     Lint {
 480         name: "expl_impl_clone_on_copy",
 481         group: "pedantic",
 482         desc: "implementing `Clone` explicitly on `Copy` types",
 483         deprecation: None,
 484         module: "derive",
 485     },
 486     Lint {
 487         name: "explicit_counter_loop",
 488         group: "complexity",
 489         desc: "for-looping with an explicit counter when `_.enumerate()` would do",
 490         deprecation: None,
 491         module: "loops",
 492     },
 493     Lint {
 494         name: "explicit_into_iter_loop",
 495         group: "pedantic",
 496         desc: "for-looping over `_.into_iter()` when `_` would do",
 497         deprecation: None,
 498         module: "loops",
 499     },
 500     Lint {
 501         name: "explicit_iter_loop",
 502         group: "pedantic",
 503         desc: "for-looping over `_.iter()` or `_.iter_mut()` when `&_` or `&mut _` would do",
 504         deprecation: None,
 505         module: "loops",
 506     },
 507     Lint {
 508         name: "explicit_write",
 509         group: "complexity",
 510         desc: "using the `write!()` family of functions instead of the `print!()` family of functions, when using the latter would work",
 511         deprecation: None,
 512         module: "explicit_write",
 513     },
 514     Lint {
 515         name: "extra_unused_lifetimes",
 516         group: "complexity",
 517         desc: "unused lifetimes in function definitions",
 518         deprecation: None,
 519         module: "lifetimes",
 520     },
 521     Lint {
 522         name: "fallible_impl_from",
 523         group: "nursery",
 524         desc: "Warn on impls of `From<..>` that contain `panic!()` or `unwrap()`",
 525         deprecation: None,
 526         module: "fallible_impl_from",
 527     },
 528     Lint {
 529         name: "filter_map",
 530         group: "pedantic",
 531         desc: "using combinations of `filter`, `map`, `filter_map` and `flat_map` which can usually be written as a single method call",
 532         deprecation: None,
 533         module: "methods",
 534     },
 535     Lint {
 536         name: "filter_map_next",
 537         group: "pedantic",
 538         desc: "using combination of `filter_map` and `next` which can usually be written as a single method call",
 539         deprecation: None,
 540         module: "methods",
 541     },
 542     Lint {
 543         name: "filter_next",
 544         group: "complexity",
 545         desc: "using `filter(p).next()`, which is more succinctly expressed as `.find(p)`",
 546         deprecation: None,
 547         module: "methods",
 548     },
 549     Lint {
 550         name: "find_map",
 551         group: "pedantic",
 552         desc: "using a combination of `find` and `map` can usually be written as a single method call",
 553         deprecation: None,
 554         module: "methods",
 555     },
 556     Lint {
 557         name: "float_arithmetic",
 558         group: "restriction",
 559         desc: "any floating-point arithmetic statement",
 560         deprecation: None,
 561         module: "arithmetic",
 562     },
 563     Lint {
 564         name: "float_cmp",
 565         group: "correctness",
 566         desc: "using `==` or `!=` on float values instead of comparing difference with an epsilon",
 567         deprecation: None,
 568         module: "misc",
 569     },
 570     Lint {
 571         name: "float_cmp_const",
 572         group: "restriction",
 573         desc: "using `==` or `!=` on float constants instead of comparing difference with an epsilon",
 574         deprecation: None,
 575         module: "misc",
 576     },
 577     Lint {
 578         name: "fn_to_numeric_cast",
 579         group: "style",
 580         desc: "casting a function pointer to a numeric type other than usize",
 581         deprecation: None,
 582         module: "types",
 583     },
 584     Lint {
 585         name: "fn_to_numeric_cast_with_truncation",
 586         group: "style",
 587         desc: "casting a function pointer to a numeric type not wide enough to store the address",
 588         deprecation: None,
 589         module: "types",
 590     },
 591     Lint {
 592         name: "for_kv_map",
 593         group: "style",
 594         desc: "looping on a map using `iter` when `keys` or `values` would do",
 595         deprecation: None,
 596         module: "loops",
 597     },
 598     Lint {
 599         name: "for_loop_over_option",
 600         group: "correctness",
 601         desc: "for-looping over an `Option`, which is more clearly expressed as an `if let`",
 602         deprecation: None,
 603         module: "loops",
 604     },
 605     Lint {
 606         name: "for_loop_over_result",
 607         group: "correctness",
 608         desc: "for-looping over a `Result`, which is more clearly expressed as an `if let`",
 609         deprecation: None,
 610         module: "loops",
 611     },
 612     Lint {
 613         name: "forget_copy",
 614         group: "correctness",
 615         desc: "calls to `std::mem::forget` with a value that implements Copy",
 616         deprecation: None,
 617         module: "drop_forget_ref",
 618     },
 619     Lint {
 620         name: "forget_ref",
 621         group: "correctness",
 622         desc: "calls to `std::mem::forget` with a reference instead of an owned value",
 623         deprecation: None,
 624         module: "drop_forget_ref",
 625     },
 626     Lint {
 627         name: "get_last_with_len",
 628         group: "complexity",
 629         desc: "Using `x.get(x.len() - 1)` when `x.last()` is correct and simpler",
 630         deprecation: None,
 631         module: "get_last_with_len",
 632     },
 633     Lint {
 634         name: "get_unwrap",
 635         group: "restriction",
 636         desc: "using `.get().unwrap()` or `.get_mut().unwrap()` when using `[]` would work instead",
 637         deprecation: None,
 638         module: "methods",
 639     },
 640     Lint {
 641         name: "identity_conversion",
 642         group: "complexity",
 643         desc: "using always-identical `Into`/`From`/`IntoIter` conversions",
 644         deprecation: None,
 645         module: "identity_conversion",
 646     },
 647     Lint {
 648         name: "identity_op",
 649         group: "complexity",
 650         desc: "using identity operations, e.g., `x + 0` or `y / 1`",
 651         deprecation: None,
 652         module: "identity_op",
 653     },
 654     Lint {
 655         name: "if_let_some_result",
 656         group: "style",
 657         desc: "usage of `ok()` in `if let Some(pat)` statements is unnecessary, match on `Ok(pat)` instead",
 658         deprecation: None,
 659         module: "ok_if_let",
 660     },
 661     Lint {
 662         name: "if_not_else",
 663         group: "pedantic",
 664         desc: "`if` branches that could be swapped so no negation operation is necessary on the condition",
 665         deprecation: None,
 666         module: "if_not_else",
 667     },
 668     Lint {
 669         name: "if_same_then_else",
 670         group: "correctness",
 671         desc: "if with the same *then* and *else* blocks",
 672         deprecation: None,
 673         module: "copies",
 674     },
 675     Lint {
 676         name: "ifs_same_cond",
 677         group: "correctness",
 678         desc: "consecutive `ifs` with the same condition",
 679         deprecation: None,
 680         module: "copies",
 681     },
 682     Lint {
 683         name: "implicit_hasher",
 684         group: "style",
 685         desc: "missing generalization over different hashers",
 686         deprecation: None,
 687         module: "types",
 688     },
 689     Lint {
 690         name: "implicit_return",
 691         group: "restriction",
 692         desc: "use a return statement like `return expr` instead of an expression",
 693         deprecation: None,
 694         module: "implicit_return",
 695     },
 696     Lint {
 697         name: "inconsistent_digit_grouping",
 698         group: "style",
 699         desc: "integer literals with digits grouped inconsistently",
 700         deprecation: None,
 701         module: "literal_representation",
 702     },
 703     Lint {
 704         name: "indexing_slicing",
 705         group: "restriction",
 706         desc: "indexing/slicing usage",
 707         deprecation: None,
 708         module: "indexing_slicing",
 709     },
 710     Lint {
 711         name: "ineffective_bit_mask",
 712         group: "correctness",
 713         desc: "expressions where a bit mask will be rendered useless by a comparison, e.g., `(x | 1) > 2`",
 714         deprecation: None,
 715         module: "bit_mask",
 716     },
 717     Lint {
 718         name: "infallible_destructuring_match",
 719         group: "style",
 720         desc: "a match statement with a single infallible arm instead of a `let`",
 721         deprecation: None,
 722         module: "infallible_destructuring_match",
 723     },
 724     Lint {
 725         name: "infinite_iter",
 726         group: "correctness",
 727         desc: "infinite iteration",
 728         deprecation: None,
 729         module: "infinite_iter",
 730     },
 731     Lint {
 732         name: "inline_always",
 733         group: "pedantic",
 734         desc: "use of `#[inline(always)]`",
 735         deprecation: None,
 736         module: "attrs",
 737     },
 738     Lint {
 739         name: "inline_fn_without_body",
 740         group: "correctness",
 741         desc: "use of `#[inline]` on trait methods without bodies",
 742         deprecation: None,
 743         module: "inline_fn_without_body",
 744     },
 745     Lint {
 746         name: "int_plus_one",
 747         group: "complexity",
 748         desc: "instead of using x >= y + 1, use x > y",
 749         deprecation: None,
 750         module: "int_plus_one",
 751     },
 752     Lint {
 753         name: "integer_arithmetic",
 754         group: "restriction",
 755         desc: "any integer arithmetic statement",
 756         deprecation: None,
 757         module: "arithmetic",
 758     },
 759     Lint {
 760         name: "integer_division",
 761         group: "restriction",
 762         desc: "integer division may cause loss of precision",
 763         deprecation: None,
 764         module: "integer_division",
 765     },
 766     Lint {
 767         name: "into_iter_on_array",
 768         group: "correctness",
 769         desc: "using `.into_iter()` on an array",
 770         deprecation: None,
 771         module: "methods",
 772     },
 773     Lint {
 774         name: "into_iter_on_ref",
 775         group: "style",
 776         desc: "using `.into_iter()` on a reference",
 777         deprecation: None,
 778         module: "methods",
 779     },
 780     Lint {
 781         name: "invalid_ref",
 782         group: "correctness",
 783         desc: "creation of invalid reference",
 784         deprecation: None,
 785         module: "invalid_ref",
 786     },
 787     Lint {
 788         name: "invalid_regex",
 789         group: "correctness",
 790         desc: "invalid regular expressions",
 791         deprecation: None,
 792         module: "regex",
 793     },
 794     Lint {
 795         name: "invalid_upcast_comparisons",
 796         group: "pedantic",
 797         desc: "a comparison involving an upcast which is always true or false",
 798         deprecation: None,
 799         module: "types",
 800     },
 801     Lint {
 802         name: "items_after_statements",
 803         group: "pedantic",
 804         desc: "blocks where an item comes after a statement",
 805         deprecation: None,
 806         module: "items_after_statements",
 807     },
 808     Lint {
 809         name: "iter_cloned_collect",
 810         group: "style",
 811         desc: "using `.cloned().collect()` on slice to create a `Vec`",
 812         deprecation: None,
 813         module: "methods",
 814     },
 815     Lint {
 816         name: "iter_next_loop",
 817         group: "correctness",
 818         desc: "for-looping over `_.next()` which is probably not intended",
 819         deprecation: None,
 820         module: "loops",
 821     },
 822     Lint {
 823         name: "iter_nth",
 824         group: "perf",
 825         desc: "using `.iter().nth()` on a standard library type with O(1) element access",
 826         deprecation: None,
 827         module: "methods",
 828     },
 829     Lint {
 830         name: "iter_skip_next",
 831         group: "style",
 832         desc: "using `.skip(x).next()` on an iterator",
 833         deprecation: None,
 834         module: "methods",
 835     },
 836     Lint {
 837         name: "iterator_step_by_zero",
 838         group: "correctness",
 839         desc: "using `Iterator::step_by(0)`, which produces an infinite iterator",
 840         deprecation: None,
 841         module: "ranges",
 842     },
 843     Lint {
 844         name: "just_underscores_and_digits",
 845         group: "style",
 846         desc: "unclear name",
 847         deprecation: None,
 848         module: "non_expressive_names",
 849     },
 850     Lint {
 851         name: "large_digit_groups",
 852         group: "pedantic",
 853         desc: "grouping digits into groups that are too large",
 854         deprecation: None,
 855         module: "literal_representation",
 856     },
 857     Lint {
 858         name: "large_enum_variant",
 859         group: "perf",
 860         desc: "large size difference between variants on an enum",
 861         deprecation: None,
 862         module: "large_enum_variant",
 863     },
 864     Lint {
 865         name: "len_without_is_empty",
 866         group: "style",
 867         desc: "traits or impls with a public `len` method but no corresponding `is_empty` method",
 868         deprecation: None,
 869         module: "len_zero",
 870     },
 871     Lint {
 872         name: "len_zero",
 873         group: "style",
 874         desc: "checking `.len() == 0` or `.len() > 0` (or similar) when `.is_empty()` could be used instead",
 875         deprecation: None,
 876         module: "len_zero",
 877     },
 878     Lint {
 879         name: "let_and_return",
 880         group: "style",
 881         desc: "creating a let-binding and then immediately returning it like `let x = expr; x` at the end of a block",
 882         deprecation: None,
 883         module: "returns",
 884     },
 885     Lint {
 886         name: "let_unit_value",
 887         group: "style",
 888         desc: "creating a let binding to a value of unit type, which usually can\'t be used afterwards",
 889         deprecation: None,
 890         module: "types",
 891     },
 892     Lint {
 893         name: "linkedlist",
 894         group: "pedantic",
 895         desc: "usage of LinkedList, usually a vector is faster, or a more specialized data structure like a VecDeque",
 896         deprecation: None,
 897         module: "types",
 898     },
 899     Lint {
 900         name: "logic_bug",
 901         group: "correctness",
 902         desc: "boolean expressions that contain terminals which can be eliminated",
 903         deprecation: None,
 904         module: "booleans",
 905     },
 906     Lint {
 907         name: "manual_memcpy",
 908         group: "perf",
 909         desc: "manually copying items between slices",
 910         deprecation: None,
 911         module: "loops",
 912     },
 913     Lint {
 914         name: "manual_swap",
 915         group: "complexity",
 916         desc: "manual swap of two variables",
 917         deprecation: None,
 918         module: "swap",
 919     },
 920     Lint {
 921         name: "many_single_char_names",
 922         group: "style",
 923         desc: "too many single character bindings",
 924         deprecation: None,
 925         module: "non_expressive_names",
 926     },
 927     Lint {
 928         name: "map_clone",
 929         group: "style",
 930         desc: "using `iterator.map(|x| x.clone())`, or dereferencing closures for `Copy` types",
 931         deprecation: None,
 932         module: "map_clone",
 933     },
 934     Lint {
 935         name: "map_entry",
 936         group: "perf",
 937         desc: "use of `contains_key` followed by `insert` on a `HashMap` or `BTreeMap`",
 938         deprecation: None,
 939         module: "entry",
 940     },
 941     Lint {
 942         name: "map_flatten",
 943         group: "pedantic",
 944         desc: "using combinations of `flatten` and `map` which can usually be written as a single method call",
 945         deprecation: None,
 946         module: "methods",
 947     },
 948     Lint {
 949         name: "match_as_ref",
 950         group: "complexity",
 951         desc: "a match on an Option value instead of using `as_ref()` or `as_mut`",
 952         deprecation: None,
 953         module: "matches",
 954     },
 955     Lint {
 956         name: "match_bool",
 957         group: "style",
 958         desc: "a match on a boolean expression instead of an `if..else` block",
 959         deprecation: None,
 960         module: "matches",
 961     },
 962     Lint {
 963         name: "match_overlapping_arm",
 964         group: "style",
 965         desc: "a match with overlapping arms",
 966         deprecation: None,
 967         module: "matches",
 968     },
 969     Lint {
 970         name: "match_ref_pats",
 971         group: "style",
 972         desc: "a match or `if let` with all arms prefixed with `&` instead of deref-ing the match expression",
 973         deprecation: None,
 974         module: "matches",
 975     },
 976     Lint {
 977         name: "match_same_arms",
 978         group: "pedantic",
 979         desc: "`match` with identical arm bodies",
 980         deprecation: None,
 981         module: "copies",
 982     },
 983     Lint {
 984         name: "match_wild_err_arm",
 985         group: "style",
 986         desc: "a match with `Err(_)` arm and take drastic actions",
 987         deprecation: None,
 988         module: "matches",
 989     },
 990     Lint {
 991         name: "maybe_infinite_iter",
 992         group: "pedantic",
 993         desc: "possible infinite iteration",
 994         deprecation: None,
 995         module: "infinite_iter",
 996     },
 997     Lint {
 998         name: "mem_discriminant_non_enum",
 999         group: "correctness",
1000         desc: "calling mem::descriminant on non-enum type",
1001         deprecation: None,
1002         module: "mem_discriminant",
1003     },
1004     Lint {
1005         name: "mem_forget",
1006         group: "restriction",
1007         desc: "`mem::forget` usage on `Drop` types, likely to cause memory leaks",
1008         deprecation: None,
1009         module: "mem_forget",
1010     },
1011     Lint {
1012         name: "mem_replace_option_with_none",
1013         group: "style",
1014         desc: "replacing an `Option` with `None` instead of `take()`",
1015         deprecation: None,
1016         module: "mem_replace",
1017     },
1018     Lint {
1019         name: "min_max",
1020         group: "correctness",
1021         desc: "`min(_, max(_, _))` (or vice versa) with bounds clamping the result to a constant",
1022         deprecation: None,
1023         module: "minmax",
1024     },
1025     Lint {
1026         name: "misrefactored_assign_op",
1027         group: "complexity",
1028         desc: "having a variable on both sides of an assign op",
1029         deprecation: None,
1030         module: "assign_ops",
1031     },
1032     Lint {
1033         name: "missing_const_for_fn",
1034         group: "nursery",
1035         desc: "Lint functions definitions that could be made `const fn`",
1036         deprecation: None,
1037         module: "missing_const_for_fn",
1038     },
1039     Lint {
1040         name: "missing_docs_in_private_items",
1041         group: "restriction",
1042         desc: "detects missing documentation for public and private members",
1043         deprecation: None,
1044         module: "missing_doc",
1045     },
1046     Lint {
1047         name: "missing_inline_in_public_items",
1048         group: "restriction",
1049         desc: "detects missing #[inline] attribute for public callables (functions, trait methods, methods...)",
1050         deprecation: None,
1051         module: "missing_inline",
1052     },
1053     Lint {
1054         name: "mistyped_literal_suffixes",
1055         group: "correctness",
1056         desc: "mistyped literal suffix",
1057         deprecation: None,
1058         module: "literal_representation",
1059     },
1060     Lint {
1061         name: "mixed_case_hex_literals",
1062         group: "style",
1063         desc: "hex literals whose letter digits are not consistently upper- or lowercased",
1064         deprecation: None,
1065         module: "misc_early",
1066     },
1067     Lint {
1068         name: "module_inception",
1069         group: "style",
1070         desc: "modules that have the same name as their parent module",
1071         deprecation: None,
1072         module: "enum_variants",
1073     },
1074     Lint {
1075         name: "module_name_repetitions",
1076         group: "pedantic",
1077         desc: "type names prefixed/postfixed with their containing module\'s name",
1078         deprecation: None,
1079         module: "enum_variants",
1080     },
1081     Lint {
1082         name: "modulo_one",
1083         group: "correctness",
1084         desc: "taking a number modulo 1, which always returns 0",
1085         deprecation: None,
1086         module: "misc",
1087     },
1088     Lint {
1089         name: "multiple_crate_versions",
1090         group: "cargo",
1091         desc: "multiple versions of the same crate being used",
1092         deprecation: None,
1093         module: "multiple_crate_versions",
1094     },
1095     Lint {
1096         name: "multiple_inherent_impl",
1097         group: "restriction",
1098         desc: "Multiple inherent impl that could be grouped",
1099         deprecation: None,
1100         module: "inherent_impl",
1101     },
1102     Lint {
1103         name: "mut_from_ref",
1104         group: "correctness",
1105         desc: "fns that create mutable refs from immutable ref args",
1106         deprecation: None,
1107         module: "ptr",
1108     },
1109     Lint {
1110         name: "mut_mut",
1111         group: "pedantic",
1112         desc: "usage of double-mut refs, e.g., `&mut &mut ...`",
1113         deprecation: None,
1114         module: "mut_mut",
1115     },
1116     Lint {
1117         name: "mut_range_bound",
1118         group: "complexity",
1119         desc: "for loop over a range where one of the bounds is a mutable variable",
1120         deprecation: None,
1121         module: "loops",
1122     },
1123     Lint {
1124         name: "mutex_atomic",
1125         group: "perf",
1126         desc: "using a mutex where an atomic value could be used instead",
1127         deprecation: None,
1128         module: "mutex_atomic",
1129     },
1130     Lint {
1131         name: "mutex_integer",
1132         group: "nursery",
1133         desc: "using a mutex for an integer type",
1134         deprecation: None,
1135         module: "mutex_atomic",
1136     },
1137     Lint {
1138         name: "naive_bytecount",
1139         group: "perf",
1140         desc: "use of naive `<slice>.filter(|&x| x == y).count()` to count byte values",
1141         deprecation: None,
1142         module: "bytecount",
1143     },
1144     Lint {
1145         name: "needless_bool",
1146         group: "complexity",
1147         desc: "if-statements with plain booleans in the then- and else-clause, e.g., `if p { true } else { false }`",
1148         deprecation: None,
1149         module: "needless_bool",
1150     },
1151     Lint {
1152         name: "needless_borrow",
1153         group: "nursery",
1154         desc: "taking a reference that is going to be automatically dereferenced",
1155         deprecation: None,
1156         module: "needless_borrow",
1157     },
1158     Lint {
1159         name: "needless_borrowed_reference",
1160         group: "complexity",
1161         desc: "taking a needless borrowed reference",
1162         deprecation: None,
1163         module: "needless_borrowed_ref",
1164     },
1165     Lint {
1166         name: "needless_collect",
1167         group: "perf",
1168         desc: "collecting an iterator when collect is not needed",
1169         deprecation: None,
1170         module: "loops",
1171     },
1172     Lint {
1173         name: "needless_continue",
1174         group: "pedantic",
1175         desc: "`continue` statements that can be replaced by a rearrangement of code",
1176         deprecation: None,
1177         module: "needless_continue",
1178     },
1179     Lint {
1180         name: "needless_lifetimes",
1181         group: "complexity",
1182         desc: "using explicit lifetimes for references in function arguments when elision rules would allow omitting them",
1183         deprecation: None,
1184         module: "lifetimes",
1185     },
1186     Lint {
1187         name: "needless_pass_by_value",
1188         group: "pedantic",
1189         desc: "functions taking arguments by value, but not consuming them in its body",
1190         deprecation: None,
1191         module: "needless_pass_by_value",
1192     },
1193     Lint {
1194         name: "needless_range_loop",
1195         group: "style",
1196         desc: "for-looping over a range of indices where an iterator over items would do",
1197         deprecation: None,
1198         module: "loops",
1199     },
1200     Lint {
1201         name: "needless_return",
1202         group: "style",
1203         desc: "using a return statement like `return expr;` where an expression would suffice",
1204         deprecation: None,
1205         module: "returns",
1206     },
1207     Lint {
1208         name: "needless_update",
1209         group: "complexity",
1210         desc: "using `Foo { ..base }` when there are no missing fields",
1211         deprecation: None,
1212         module: "needless_update",
1213     },
1214     Lint {
1215         name: "neg_cmp_op_on_partial_ord",
1216         group: "complexity",
1217         desc: "The use of negated comparison operators on partially ordered types may produce confusing code.",
1218         deprecation: None,
1219         module: "neg_cmp_op_on_partial_ord",
1220     },
1221     Lint {
1222         name: "neg_multiply",
1223         group: "style",
1224         desc: "multiplying integers with -1",
1225         deprecation: None,
1226         module: "neg_multiply",
1227     },
1228     Lint {
1229         name: "never_loop",
1230         group: "correctness",
1231         desc: "any loop that will always `break` or `return`",
1232         deprecation: None,
1233         module: "loops",
1234     },
1235     Lint {
1236         name: "new_ret_no_self",
1237         group: "style",
1238         desc: "not returning `Self` in a `new` method",
1239         deprecation: None,
1240         module: "methods",
1241     },
1242     Lint {
1243         name: "new_without_default",
1244         group: "style",
1245         desc: "`fn new() -> Self` method without `Default` implementation",
1246         deprecation: None,
1247         module: "new_without_default",
1248     },
1249     Lint {
1250         name: "no_effect",
1251         group: "complexity",
1252         desc: "statements with no effect",
1253         deprecation: None,
1254         module: "no_effect",
1255     },
1256     Lint {
1257         name: "non_ascii_literal",
1258         group: "pedantic",
1259         desc: "using any literal non-ASCII chars in a string literal instead of using the `\\\\u` escape",
1260         deprecation: None,
1261         module: "unicode",
1262     },
1263     Lint {
1264         name: "nonminimal_bool",
1265         group: "complexity",
1266         desc: "boolean expressions that can be written more concisely",
1267         deprecation: None,
1268         module: "booleans",
1269     },
1270     Lint {
1271         name: "nonsensical_open_options",
1272         group: "correctness",
1273         desc: "nonsensical combination of options for opening a file",
1274         deprecation: None,
1275         module: "open_options",
1276     },
1277     Lint {
1278         name: "not_unsafe_ptr_arg_deref",
1279         group: "correctness",
1280         desc: "public functions dereferencing raw pointer arguments but not marked `unsafe`",
1281         deprecation: None,
1282         module: "functions",
1283     },
1284     Lint {
1285         name: "ok_expect",
1286         group: "style",
1287         desc: "using `ok().expect()`, which gives worse error messages than calling `expect` directly on the Result",
1288         deprecation: None,
1289         module: "methods",
1290     },
1291     Lint {
1292         name: "op_ref",
1293         group: "style",
1294         desc: "taking a reference to satisfy the type constraints on `==`",
1295         deprecation: None,
1296         module: "eq_op",
1297     },
1298     Lint {
1299         name: "option_map_or_none",
1300         group: "style",
1301         desc: "using `Option.map_or(None, f)`, which is more succinctly expressed as `and_then(f)`",
1302         deprecation: None,
1303         module: "methods",
1304     },
1305     Lint {
1306         name: "option_map_unit_fn",
1307         group: "complexity",
1308         desc: "using `option.map(f)`, where f is a function or closure that returns ()",
1309         deprecation: None,
1310         module: "map_unit_fn",
1311     },
1312     Lint {
1313         name: "option_map_unwrap_or",
1314         group: "pedantic",
1315         desc: "using `Option.map(f).unwrap_or(a)`, which is more succinctly expressed as `map_or(a, f)`",
1316         deprecation: None,
1317         module: "methods",
1318     },
1319     Lint {
1320         name: "option_map_unwrap_or_else",
1321         group: "pedantic",
1322         desc: "using `Option.map(f).unwrap_or_else(g)`, which is more succinctly expressed as `map_or_else(g, f)`",
1323         deprecation: None,
1324         module: "methods",
1325     },
1326     Lint {
1327         name: "option_option",
1328         group: "complexity",
1329         desc: "usage of `Option<Option<T>>`",
1330         deprecation: None,
1331         module: "types",
1332     },
1333     Lint {
1334         name: "option_unwrap_used",
1335         group: "restriction",
1336         desc: "using `Option.unwrap()`, which should at least get a better message using `expect()`",
1337         deprecation: None,
1338         module: "methods",
1339     },
1340     Lint {
1341         name: "or_fun_call",
1342         group: "perf",
1343         desc: "using any `*or` method with a function call, which suggests `*or_else`",
1344         deprecation: None,
1345         module: "methods",
1346     },
1347     Lint {
1348         name: "out_of_bounds_indexing",
1349         group: "correctness",
1350         desc: "out of bounds constant indexing",
1351         deprecation: None,
1352         module: "indexing_slicing",
1353     },
1354     Lint {
1355         name: "overflow_check_conditional",
1356         group: "complexity",
1357         desc: "overflow checks inspired by C which are likely to panic",
1358         deprecation: None,
1359         module: "overflow_check_conditional",
1360     },
1361     Lint {
1362         name: "panic_params",
1363         group: "style",
1364         desc: "missing parameters in `panic!` calls",
1365         deprecation: None,
1366         module: "panic_unimplemented",
1367     },
1368     Lint {
1369         name: "panicking_unwrap",
1370         group: "nursery",
1371         desc: "checks for calls of unwrap[_err]() that will always fail",
1372         deprecation: None,
1373         module: "unwrap",
1374     },
1375     Lint {
1376         name: "partialeq_ne_impl",
1377         group: "complexity",
1378         desc: "re-implementing `PartialEq::ne`",
1379         deprecation: None,
1380         module: "partialeq_ne_impl",
1381     },
1382     Lint {
1383         name: "path_buf_push_overwrite",
1384         group: "nursery",
1385         desc: "calling `push` with file system root on `PathBuf` can overwrite it",
1386         deprecation: None,
1387         module: "path_buf_push_overwrite",
1388     },
1389     Lint {
1390         name: "possible_missing_comma",
1391         group: "correctness",
1392         desc: "possible missing comma in array",
1393         deprecation: None,
1394         module: "formatting",
1395     },
1396     Lint {
1397         name: "precedence",
1398         group: "complexity",
1399         desc: "operations where precedence may be unclear",
1400         deprecation: None,
1401         module: "precedence",
1402     },
1403     Lint {
1404         name: "print_literal",
1405         group: "style",
1406         desc: "printing a literal with a format string",
1407         deprecation: None,
1408         module: "write",
1409     },
1410     Lint {
1411         name: "print_stdout",
1412         group: "restriction",
1413         desc: "printing on stdout",
1414         deprecation: None,
1415         module: "write",
1416     },
1417     Lint {
1418         name: "print_with_newline",
1419         group: "style",
1420         desc: "using `print!()` with a format string that ends in a single newline",
1421         deprecation: None,
1422         module: "write",
1423     },
1424     Lint {
1425         name: "println_empty_string",
1426         group: "style",
1427         desc: "using `println!(\"\")` with an empty string",
1428         deprecation: None,
1429         module: "write",
1430     },
1431     Lint {
1432         name: "ptr_arg",
1433         group: "style",
1434         desc: "fn arguments of the type `&Vec<...>` or `&String`, suggesting to use `&[...]` or `&str` instead, respectively",
1435         deprecation: None,
1436         module: "ptr",
1437     },
1438     Lint {
1439         name: "ptr_offset_with_cast",
1440         group: "complexity",
1441         desc: "unneeded pointer offset cast",
1442         deprecation: None,
1443         module: "ptr_offset_with_cast",
1444     },
1445     Lint {
1446         name: "pub_enum_variant_names",
1447         group: "pedantic",
1448         desc: "enums where all variants share a prefix/postfix",
1449         deprecation: None,
1450         module: "enum_variants",
1451     },
1452     Lint {
1453         name: "question_mark",
1454         group: "style",
1455         desc: "checks for expressions that could be replaced by the question mark operator",
1456         deprecation: None,
1457         module: "question_mark",
1458     },
1459     Lint {
1460         name: "range_minus_one",
1461         group: "complexity",
1462         desc: "`x..=(y-1)` reads better as `x..y`",
1463         deprecation: None,
1464         module: "ranges",
1465     },
1466     Lint {
1467         name: "range_plus_one",
1468         group: "complexity",
1469         desc: "`x..(y+1)` reads better as `x..=y`",
1470         deprecation: None,
1471         module: "ranges",
1472     },
1473     Lint {
1474         name: "range_zip_with_len",
1475         group: "complexity",
1476         desc: "zipping iterator with a range when `enumerate()` would do",
1477         deprecation: None,
1478         module: "ranges",
1479     },
1480     Lint {
1481         name: "redundant_clone",
1482         group: "nursery",
1483         desc: "`clone()` of an owned value that is going to be dropped immediately",
1484         deprecation: None,
1485         module: "redundant_clone",
1486     },
1487     Lint {
1488         name: "redundant_closure",
1489         group: "style",
1490         desc: "redundant closures, i.e., `|a| foo(a)` (which can be written as just `foo`)",
1491         deprecation: None,
1492         module: "eta_reduction",
1493     },
1494     Lint {
1495         name: "redundant_closure_call",
1496         group: "complexity",
1497         desc: "throwaway closures called in the expression they are defined",
1498         deprecation: None,
1499         module: "misc_early",
1500     },
1501     Lint {
1502         name: "redundant_closure_for_method_calls",
1503         group: "pedantic",
1504         desc: "redundant closures for method calls",
1505         deprecation: None,
1506         module: "eta_reduction",
1507     },
1508     Lint {
1509         name: "redundant_field_names",
1510         group: "style",
1511         desc: "checks for fields in struct literals where shorthands could be used",
1512         deprecation: None,
1513         module: "redundant_field_names",
1514     },
1515     Lint {
1516         name: "redundant_pattern",
1517         group: "style",
1518         desc: "using `name @ _` in a pattern",
1519         deprecation: None,
1520         module: "misc",
1521     },
1522     Lint {
1523         name: "redundant_pattern_matching",
1524         group: "style",
1525         desc: "use the proper utility function avoiding an `if let`",
1526         deprecation: None,
1527         module: "redundant_pattern_matching",
1528     },
1529     Lint {
1530         name: "redundant_static_lifetimes",
1531         group: "style",
1532         desc: "Using explicit `\'static` lifetime for constants or statics when elision rules would allow omitting them.",
1533         deprecation: None,
1534         module: "redundant_static_lifetimes",
1535     },
1536     Lint {
1537         name: "ref_in_deref",
1538         group: "complexity",
1539         desc: "Use of reference in auto dereference expression.",
1540         deprecation: None,
1541         module: "reference",
1542     },
1543     Lint {
1544         name: "regex_macro",
1545         group: "style",
1546         desc: "use of `regex!(_)` instead of `Regex::new(_)`",
1547         deprecation: None,
1548         module: "regex",
1549     },
1550     Lint {
1551         name: "replace_consts",
1552         group: "pedantic",
1553         desc: "Lint usages of standard library `const`s that could be replaced by `const fn`s",
1554         deprecation: None,
1555         module: "replace_consts",
1556     },
1557     Lint {
1558         name: "result_map_unit_fn",
1559         group: "complexity",
1560         desc: "using `result.map(f)`, where f is a function or closure that returns ()",
1561         deprecation: None,
1562         module: "map_unit_fn",
1563     },
1564     Lint {
1565         name: "result_map_unwrap_or_else",
1566         group: "pedantic",
1567         desc: "using `Result.map(f).unwrap_or_else(g)`, which is more succinctly expressed as `.ok().map_or_else(g, f)`",
1568         deprecation: None,
1569         module: "methods",
1570     },
1571     Lint {
1572         name: "result_unwrap_used",
1573         group: "restriction",
1574         desc: "using `Result.unwrap()`, which might be better handled",
1575         deprecation: None,
1576         module: "methods",
1577     },
1578     Lint {
1579         name: "reverse_range_loop",
1580         group: "correctness",
1581         desc: "iteration over an empty range, such as `10..0` or `5..5`",
1582         deprecation: None,
1583         module: "loops",
1584     },
1585     Lint {
1586         name: "search_is_some",
1587         group: "complexity",
1588         desc: "using an iterator search followed by `is_some()`, which is more succinctly expressed as a call to `any()`",
1589         deprecation: None,
1590         module: "methods",
1591     },
1592     Lint {
1593         name: "serde_api_misuse",
1594         group: "correctness",
1595         desc: "various things that will negatively affect your serde experience",
1596         deprecation: None,
1597         module: "serde_api",
1598     },
1599     Lint {
1600         name: "shadow_reuse",
1601         group: "restriction",
1602         desc: "rebinding a name to an expression that re-uses the original value, e.g., `let x = x + 1`",
1603         deprecation: None,
1604         module: "shadow",
1605     },
1606     Lint {
1607         name: "shadow_same",
1608         group: "restriction",
1609         desc: "rebinding a name to itself, e.g., `let mut x = &mut x`",
1610         deprecation: None,
1611         module: "shadow",
1612     },
1613     Lint {
1614         name: "shadow_unrelated",
1615         group: "pedantic",
1616         desc: "rebinding a name without even using the original value",
1617         deprecation: None,
1618         module: "shadow",
1619     },
1620     Lint {
1621         name: "short_circuit_statement",
1622         group: "complexity",
1623         desc: "using a short circuit boolean condition as a statement",
1624         deprecation: None,
1625         module: "misc",
1626     },
1627     Lint {
1628         name: "should_implement_trait",
1629         group: "style",
1630         desc: "defining a method that should be implementing a std trait",
1631         deprecation: None,
1632         module: "methods",
1633     },
1634     Lint {
1635         name: "similar_names",
1636         group: "pedantic",
1637         desc: "similarly named items and bindings",
1638         deprecation: None,
1639         module: "non_expressive_names",
1640     },
1641     Lint {
1642         name: "single_char_pattern",
1643         group: "perf",
1644         desc: "using a single-character str where a char could be used, e.g., `_.split(\"x\")`",
1645         deprecation: None,
1646         module: "methods",
1647     },
1648     Lint {
1649         name: "single_match",
1650         group: "style",
1651         desc: "a match statement with a single nontrivial arm (i.e., where the other arm is `_ => {}`) instead of `if let`",
1652         deprecation: None,
1653         module: "matches",
1654     },
1655     Lint {
1656         name: "single_match_else",
1657         group: "pedantic",
1658         desc: "a match statement with a two arms where the second arm\'s pattern is a placeholder instead of a specific match pattern",
1659         deprecation: None,
1660         module: "matches",
1661     },
1662     Lint {
1663         name: "slow_vector_initialization",
1664         group: "perf",
1665         desc: "slow vector initialization",
1666         deprecation: None,
1667         module: "slow_vector_initialization",
1668     },
1669     Lint {
1670         name: "string_add",
1671         group: "restriction",
1672         desc: "using `x + ..` where x is a `String` instead of `push_str()`",
1673         deprecation: None,
1674         module: "strings",
1675     },
1676     Lint {
1677         name: "string_add_assign",
1678         group: "pedantic",
1679         desc: "using `x = x + ..` where x is a `String` instead of `push_str()`",
1680         deprecation: None,
1681         module: "strings",
1682     },
1683     Lint {
1684         name: "string_extend_chars",
1685         group: "style",
1686         desc: "using `x.extend(s.chars())` where s is a `&str` or `String`",
1687         deprecation: None,
1688         module: "methods",
1689     },
1690     Lint {
1691         name: "string_lit_as_bytes",
1692         group: "style",
1693         desc: "calling `as_bytes` on a string literal instead of using a byte string literal",
1694         deprecation: None,
1695         module: "strings",
1696     },
1697     Lint {
1698         name: "suspicious_arithmetic_impl",
1699         group: "correctness",
1700         desc: "suspicious use of operators in impl of arithmetic trait",
1701         deprecation: None,
1702         module: "suspicious_trait_impl",
1703     },
1704     Lint {
1705         name: "suspicious_assignment_formatting",
1706         group: "style",
1707         desc: "suspicious formatting of `*=`, `-=` or `!=`",
1708         deprecation: None,
1709         module: "formatting",
1710     },
1711     Lint {
1712         name: "suspicious_else_formatting",
1713         group: "style",
1714         desc: "suspicious formatting of `else`",
1715         deprecation: None,
1716         module: "formatting",
1717     },
1718     Lint {
1719         name: "suspicious_op_assign_impl",
1720         group: "correctness",
1721         desc: "suspicious use of operators in impl of OpAssign trait",
1722         deprecation: None,
1723         module: "suspicious_trait_impl",
1724     },
1725     Lint {
1726         name: "temporary_assignment",
1727         group: "complexity",
1728         desc: "assignments to temporaries",
1729         deprecation: None,
1730         module: "temporary_assignment",
1731     },
1732     Lint {
1733         name: "temporary_cstring_as_ptr",
1734         group: "correctness",
1735         desc: "getting the inner pointer of a temporary `CString`",
1736         deprecation: None,
1737         module: "methods",
1738     },
1739     Lint {
1740         name: "too_many_arguments",
1741         group: "complexity",
1742         desc: "functions with too many arguments",
1743         deprecation: None,
1744         module: "functions",
1745     },
1746     Lint {
1747         name: "too_many_lines",
1748         group: "pedantic",
1749         desc: "functions with too many lines",
1750         deprecation: None,
1751         module: "functions",
1752     },
1753     Lint {
1754         name: "toplevel_ref_arg",
1755         group: "style",
1756         desc: "an entire binding declared as `ref`, in a function argument or a `let` statement",
1757         deprecation: None,
1758         module: "misc",
1759     },
1760     Lint {
1761         name: "transmute_bytes_to_str",
1762         group: "complexity",
1763         desc: "transmutes from a `&[u8]` to a `&str`",
1764         deprecation: None,
1765         module: "transmute",
1766     },
1767     Lint {
1768         name: "transmute_int_to_bool",
1769         group: "complexity",
1770         desc: "transmutes from an integer to a `bool`",
1771         deprecation: None,
1772         module: "transmute",
1773     },
1774     Lint {
1775         name: "transmute_int_to_char",
1776         group: "complexity",
1777         desc: "transmutes from an integer to a `char`",
1778         deprecation: None,
1779         module: "transmute",
1780     },
1781     Lint {
1782         name: "transmute_int_to_float",
1783         group: "complexity",
1784         desc: "transmutes from an integer to a float",
1785         deprecation: None,
1786         module: "transmute",
1787     },
1788     Lint {
1789         name: "transmute_ptr_to_ptr",
1790         group: "complexity",
1791         desc: "transmutes from a pointer to a pointer / a reference to a reference",
1792         deprecation: None,
1793         module: "transmute",
1794     },
1795     Lint {
1796         name: "transmute_ptr_to_ref",
1797         group: "complexity",
1798         desc: "transmutes from a pointer to a reference type",
1799         deprecation: None,
1800         module: "transmute",
1801     },
1802     Lint {
1803         name: "transmuting_null",
1804         group: "correctness",
1805         desc: "transmutes from a null pointer to a reference, which is undefined behavior",
1806         deprecation: None,
1807         module: "transmuting_null",
1808     },
1809     Lint {
1810         name: "trivial_regex",
1811         group: "style",
1812         desc: "trivial regular expressions",
1813         deprecation: None,
1814         module: "regex",
1815     },
1816     Lint {
1817         name: "trivially_copy_pass_by_ref",
1818         group: "perf",
1819         desc: "functions taking small copyable arguments by reference",
1820         deprecation: None,
1821         module: "trivially_copy_pass_by_ref",
1822     },
1823     Lint {
1824         name: "try_err",
1825         group: "style",
1826         desc: "return errors explicitly rather than hiding them behind a `?`",
1827         deprecation: None,
1828         module: "try_err",
1829     },
1830     Lint {
1831         name: "type_complexity",
1832         group: "complexity",
1833         desc: "usage of very complex types that might be better factored into `type` definitions",
1834         deprecation: None,
1835         module: "types",
1836     },
1837     Lint {
1838         name: "unicode_not_nfc",
1839         group: "pedantic",
1840         desc: "using a unicode literal not in NFC normal form (see [unicode tr15](http://www.unicode.org/reports/tr15/) for further information)",
1841         deprecation: None,
1842         module: "unicode",
1843     },
1844     Lint {
1845         name: "unimplemented",
1846         group: "restriction",
1847         desc: "`unimplemented!` should not be present in production code",
1848         deprecation: None,
1849         module: "panic_unimplemented",
1850     },
1851     Lint {
1852         name: "unit_arg",
1853         group: "complexity",
1854         desc: "passing unit to a function",
1855         deprecation: None,
1856         module: "types",
1857     },
1858     Lint {
1859         name: "unit_cmp",
1860         group: "correctness",
1861         desc: "comparing unit values",
1862         deprecation: None,
1863         module: "types",
1864     },
1865     Lint {
1866         name: "unknown_clippy_lints",
1867         group: "style",
1868         desc: "unknown_lints for scoped Clippy lints",
1869         deprecation: None,
1870         module: "attrs",
1871     },
1872     Lint {
1873         name: "unnecessary_cast",
1874         group: "complexity",
1875         desc: "cast to the same type, e.g., `x as i32` where `x: i32`",
1876         deprecation: None,
1877         module: "types",
1878     },
1879     Lint {
1880         name: "unnecessary_filter_map",
1881         group: "complexity",
1882         desc: "using `filter_map` when a more succinct alternative exists",
1883         deprecation: None,
1884         module: "methods",
1885     },
1886     Lint {
1887         name: "unnecessary_fold",
1888         group: "style",
1889         desc: "using `fold` when a more succinct alternative exists",
1890         deprecation: None,
1891         module: "methods",
1892     },
1893     Lint {
1894         name: "unnecessary_mut_passed",
1895         group: "style",
1896         desc: "an argument passed as a mutable reference although the callee only demands an immutable reference",
1897         deprecation: None,
1898         module: "mut_reference",
1899     },
1900     Lint {
1901         name: "unnecessary_operation",
1902         group: "complexity",
1903         desc: "outer expressions with no effect",
1904         deprecation: None,
1905         module: "no_effect",
1906     },
1907     Lint {
1908         name: "unnecessary_unwrap",
1909         group: "nursery",
1910         desc: "checks for calls of unwrap[_err]() that cannot fail",
1911         deprecation: None,
1912         module: "unwrap",
1913     },
1914     Lint {
1915         name: "unneeded_field_pattern",
1916         group: "style",
1917         desc: "struct fields bound to a wildcard instead of using `..`",
1918         deprecation: None,
1919         module: "misc_early",
1920     },
1921     Lint {
1922         name: "unreadable_literal",
1923         group: "style",
1924         desc: "long integer literal without underscores",
1925         deprecation: None,
1926         module: "literal_representation",
1927     },
1928     Lint {
1929         name: "unsafe_removed_from_name",
1930         group: "style",
1931         desc: "`unsafe` removed from API names on import",
1932         deprecation: None,
1933         module: "unsafe_removed_from_name",
1934     },
1935     Lint {
1936         name: "unseparated_literal_suffix",
1937         group: "pedantic",
1938         desc: "literals whose suffix is not separated by an underscore",
1939         deprecation: None,
1940         module: "misc_early",
1941     },
1942     Lint {
1943         name: "unused_collect",
1944         group: "perf",
1945         desc: "`collect()`ing an iterator without using the result; this is usually better written as a for loop",
1946         deprecation: None,
1947         module: "loops",
1948     },
1949     Lint {
1950         name: "unused_io_amount",
1951         group: "correctness",
1952         desc: "unused written/read amount",
1953         deprecation: None,
1954         module: "unused_io_amount",
1955     },
1956     Lint {
1957         name: "unused_label",
1958         group: "complexity",
1959         desc: "unused labels",
1960         deprecation: None,
1961         module: "unused_label",
1962     },
1963     Lint {
1964         name: "unused_unit",
1965         group: "style",
1966         desc: "needless unit expression",
1967         deprecation: None,
1968         module: "returns",
1969     },
1970     Lint {
1971         name: "use_debug",
1972         group: "restriction",
1973         desc: "use of `Debug`-based formatting",
1974         deprecation: None,
1975         module: "write",
1976     },
1977     Lint {
1978         name: "use_self",
1979         group: "pedantic",
1980         desc: "Unnecessary structure name repetition whereas `Self` is applicable",
1981         deprecation: None,
1982         module: "use_self",
1983     },
1984     Lint {
1985         name: "used_underscore_binding",
1986         group: "pedantic",
1987         desc: "using a binding which is prefixed with an underscore",
1988         deprecation: None,
1989         module: "misc",
1990     },
1991     Lint {
1992         name: "useless_asref",
1993         group: "complexity",
1994         desc: "using `as_ref` where the types before and after the call are the same",
1995         deprecation: None,
1996         module: "methods",
1997     },
1998     Lint {
1999         name: "useless_attribute",
2000         group: "correctness",
2001         desc: "use of lint attributes on `extern crate` items",
2002         deprecation: None,
2003         module: "attrs",
2004     },
2005     Lint {
2006         name: "useless_format",
2007         group: "complexity",
2008         desc: "useless use of `format!`",
2009         deprecation: None,
2010         module: "format",
2011     },
2012     Lint {
2013         name: "useless_let_if_seq",
2014         group: "style",
2015         desc: "unidiomatic `let mut` declaration followed by initialization in `if`",
2016         deprecation: None,
2017         module: "let_if_seq",
2018     },
2019     Lint {
2020         name: "useless_transmute",
2021         group: "complexity",
2022         desc: "transmutes that have the same to and from types or could be a cast/coercion",
2023         deprecation: None,
2024         module: "transmute",
2025     },
2026     Lint {
2027         name: "useless_vec",
2028         group: "perf",
2029         desc: "useless `vec!`",
2030         deprecation: None,
2031         module: "vec",
2032     },
2033     Lint {
2034         name: "vec_box",
2035         group: "complexity",
2036         desc: "usage of `Vec<Box<T>>` where T: Sized, vector elements are already on the heap",
2037         deprecation: None,
2038         module: "types",
2039     },
2040     Lint {
2041         name: "verbose_bit_mask",
2042         group: "style",
2043         desc: "expressions where a bit mask is less readable than the corresponding method call",
2044         deprecation: None,
2045         module: "bit_mask",
2046     },
2047     Lint {
2048         name: "while_immutable_condition",
2049         group: "correctness",
2050         desc: "variables used within while expression are not mutated in the body",
2051         deprecation: None,
2052         module: "loops",
2053     },
2054     Lint {
2055         name: "while_let_loop",
2056         group: "complexity",
2057         desc: "`loop { if let { ... } else break }`, which can be written as a `while let` loop",
2058         deprecation: None,
2059         module: "loops",
2060     },
2061     Lint {
2062         name: "while_let_on_iterator",
2063         group: "style",
2064         desc: "using a while-let loop instead of a for loop on an iterator",
2065         deprecation: None,
2066         module: "loops",
2067     },
2068     Lint {
2069         name: "wildcard_dependencies",
2070         group: "cargo",
2071         desc: "wildcard dependencies being used",
2072         deprecation: None,
2073         module: "wildcard_dependencies",
2074     },
2075     Lint {
2076         name: "wildcard_enum_match_arm",
2077         group: "restriction",
2078         desc: "a wildcard enum match arm using `_`",
2079         deprecation: None,
2080         module: "matches",
2081     },
2082     Lint {
2083         name: "write_literal",
2084         group: "style",
2085         desc: "writing a literal with a format string",
2086         deprecation: None,
2087         module: "write",
2088     },
2089     Lint {
2090         name: "write_with_newline",
2091         group: "style",
2092         desc: "using `write!()` with a format string that ends in a single newline",
2093         deprecation: None,
2094         module: "write",
2095     },
2096     Lint {
2097         name: "writeln_empty_string",
2098         group: "style",
2099         desc: "using `writeln!(buf, \"\")` with an empty string",
2100         deprecation: None,
2101         module: "write",
2102     },
2103     Lint {
2104         name: "wrong_pub_self_convention",
2105         group: "restriction",
2106         desc: "defining a public method named with an established prefix (like \"into_\") that takes `self` with the wrong convention",
2107         deprecation: None,
2108         module: "methods",
2109     },
2110     Lint {
2111         name: "wrong_self_convention",
2112         group: "style",
2113         desc: "defining a method named with an established prefix (like \"into_\") that takes `self` with the wrong convention",
2114         deprecation: None,
2115         module: "methods",
2116     },
2117     Lint {
2118         name: "wrong_transmute",
2119         group: "correctness",
2120         desc: "transmutes that are confusing at best, undefined behaviour at worst and always useless",
2121         deprecation: None,
2122         module: "transmute",
2123     },
2124     Lint {
2125         name: "zero_divided_by_zero",
2126         group: "complexity",
2127         desc: "usage of `0.0 / 0.0` to obtain NaN instead of std::f32::NaN or std::f64::NaN",
2128         deprecation: None,
2129         module: "zero_div_zero",
2130     },
2131     Lint {
2132         name: "zero_prefixed_literal",
2133         group: "complexity",
2134         desc: "integer literals starting with `0`",
2135         deprecation: None,
2136         module: "misc_early",
2137     },
2138     Lint {
2139         name: "zero_ptr",
2140         group: "style",
2141         desc: "using 0 as *{const, mut} T",
2142         deprecation: None,
2143         module: "misc",
2144     },
2145     Lint {
2146         name: "zero_width_space",
2147         group: "correctness",
2148         desc: "using a zero-width space in a string literal, which is confusing",
2149         deprecation: None,
2150         module: "unicode",
2151     },
2152 ];
2153 // end lint list, do not remove this comment, it’s used in `update_lints`