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