//! This file is managed by `cargo dev update_lints`. Do not edit.
+use lazy_static::lazy_static;
+
pub mod lint;
pub use lint::Level;
pub use lint::Lint;
pub use lint::LINT_LEVELS;
+lazy_static! {
// begin lint list, do not remove this comment, it’s used in `update_lints`
-pub const ALL_LINTS: [Lint; 361] = [
+pub static ref ALL_LINTS: Vec<Lint> = vec![
Lint {
name: "absurd_extreme_comparisons",
group: "correctness",
deprecation: None,
module: "assign_ops",
},
+ Lint {
+ name: "await_holding_lock",
+ group: "pedantic",
+ desc: "Inside an async function, holding a MutexGuard while calling await",
+ deprecation: None,
+ module: "await_holding_lock",
+ },
Lint {
name: "bad_bit_mask",
group: "correctness",
module: "bit_mask",
},
Lint {
- name: "blacklisted_name",
- group: "style",
- desc: "usage of a blacklisted/placeholder name",
+ name: "bind_instead_of_map",
+ group: "complexity",
+ desc: "using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`",
deprecation: None,
- module: "blacklisted_name",
+ module: "methods",
},
Lint {
- name: "block_in_if_condition_expr",
+ name: "blacklisted_name",
group: "style",
- desc: "braces that can be eliminated in conditions, e.g., `if { true } ...`",
+ desc: "usage of a blacklisted/placeholder name",
deprecation: None,
- module: "block_in_if_condition",
+ module: "blacklisted_name",
},
Lint {
- name: "block_in_if_condition_stmt",
+ name: "blocks_in_if_conditions",
group: "style",
- desc: "complex blocks in conditions, e.g., `if { let x = true; x } ...`",
+ desc: "useless or complex blocks that can be eliminated in conditions",
deprecation: None,
- module: "block_in_if_condition",
+ module: "blocks_in_if_conditions",
},
Lint {
name: "bool_comparison",
},
Lint {
name: "cognitive_complexity",
- group: "complexity",
+ group: "nursery",
desc: "functions that should be split up into multiple functions",
deprecation: None,
module: "cognitive_complexity",
deprecation: None,
module: "methods",
},
+ Lint {
+ name: "expect_used",
+ group: "restriction",
+ desc: "using `.expect()` on `Result` or `Option`, which might be better handled",
+ deprecation: None,
+ module: "methods",
+ },
Lint {
name: "expl_impl_clone_on_copy",
group: "pedantic",
deprecation: None,
module: "loops",
},
+ Lint {
+ name: "explicit_deref_methods",
+ group: "pedantic",
+ desc: "Explicit use of deref or deref_mut method while not in a method chain.",
+ deprecation: None,
+ module: "dereference",
+ },
Lint {
name: "explicit_into_iter_loop",
group: "pedantic",
deprecation: None,
module: "misc",
},
+ Lint {
+ name: "fn_address_comparisons",
+ group: "correctness",
+ desc: "comparison with an address of a function item",
+ deprecation: None,
+ module: "unnamed_address",
+ },
Lint {
name: "fn_params_excessive_bools",
group: "pedantic",
module: "loops",
},
Lint {
- name: "for_loop_over_option",
- group: "correctness",
- desc: "for-looping over an `Option`, which is more clearly expressed as an `if let`",
- deprecation: None,
- module: "loops",
- },
- Lint {
- name: "for_loop_over_result",
+ name: "for_loops_over_fallibles",
group: "correctness",
- desc: "for-looping over a `Result`, which is more clearly expressed as an `if let`",
+ desc: "for-looping over an `Option` or a `Result`, which is more clearly expressed as an `if let`",
deprecation: None,
module: "loops",
},
deprecation: None,
module: "drop_forget_ref",
},
+ Lint {
+ name: "future_not_send",
+ group: "nursery",
+ desc: "public Futures must be Send",
+ deprecation: None,
+ module: "future_not_send",
+ },
Lint {
name: "get_last_with_len",
group: "complexity",
deprecation: None,
module: "methods",
},
- Lint {
- name: "identity_conversion",
- group: "complexity",
- desc: "using always-identical `Into`/`From`/`IntoIter` conversions",
- deprecation: None,
- module: "identity_conversion",
- },
Lint {
name: "identity_op",
group: "complexity",
deprecation: None,
module: "identity_op",
},
+ Lint {
+ name: "if_let_mutex",
+ group: "correctness",
+ desc: "locking a `Mutex` in an `if let` block can cause deadlocks",
+ deprecation: None,
+ module: "if_let_mutex",
+ },
Lint {
name: "if_let_some_result",
group: "style",
},
Lint {
name: "implicit_hasher",
- group: "style",
+ group: "pedantic",
desc: "missing generalization over different hashers",
deprecation: None,
module: "types",
deprecation: None,
module: "implicit_return",
},
+ Lint {
+ name: "implicit_saturating_sub",
+ group: "pedantic",
+ desc: "Perform saturating subtraction instead of implicitly checking lower bound of data type",
+ deprecation: None,
+ module: "implicit_saturating_sub",
+ },
Lint {
name: "imprecise_flops",
group: "nursery",
},
Lint {
name: "inefficient_to_string",
- group: "perf",
+ group: "pedantic",
desc: "using `to_string` on `&&T` where `T: ToString`",
deprecation: None,
module: "methods",
Lint {
name: "integer_arithmetic",
group: "restriction",
- desc: "any integer arithmetic statement",
+ desc: "any integer arithmetic expression which could overflow or panic",
deprecation: None,
module: "arithmetic",
},
deprecation: None,
module: "non_expressive_names",
},
+ Lint {
+ name: "large_const_arrays",
+ group: "perf",
+ desc: "large non-scalar const array may cause performance overhead",
+ deprecation: None,
+ module: "large_const_arrays",
+ },
Lint {
name: "large_digit_groups",
group: "pedantic",
},
Lint {
name: "let_unit_value",
- group: "style",
+ group: "pedantic",
desc: "creating a `let` binding to a value of unit type, which usually can\'t be used afterwards",
deprecation: None,
module: "types",
deprecation: None,
module: "main_recursion",
},
+ Lint {
+ name: "manual_async_fn",
+ group: "style",
+ desc: "manual implementations of `async` functions can be simplified using the dedicated syntax",
+ deprecation: None,
+ module: "manual_async_fn",
+ },
Lint {
name: "manual_memcpy",
group: "perf",
deprecation: None,
module: "loops",
},
+ Lint {
+ name: "manual_non_exhaustive",
+ group: "style",
+ desc: "manual implementations of the non-exhaustive pattern can be simplified using #[non_exhaustive]",
+ deprecation: None,
+ module: "manual_non_exhaustive",
+ },
Lint {
name: "manual_saturating_arithmetic",
group: "style",
deprecation: None,
module: "methods",
},
+ Lint {
+ name: "map_unwrap_or",
+ group: "pedantic",
+ desc: "using `.map(f).unwrap_or(a)` or `.map(f).unwrap_or_else(func)`, which are more succinctly expressed as `map_or(a, f)` or `map_or_else(a, f)`",
+ deprecation: None,
+ module: "methods",
+ },
Lint {
name: "match_as_ref",
group: "complexity",
},
Lint {
name: "match_bool",
- group: "style",
+ group: "pedantic",
desc: "a `match` on a boolean expression instead of an `if..else` block",
deprecation: None,
module: "matches",
},
+ Lint {
+ name: "match_on_vec_items",
+ group: "pedantic",
+ desc: "matching on vector elements can panic",
+ deprecation: None,
+ module: "match_on_vec_items",
+ },
Lint {
name: "match_overlapping_arm",
group: "style",
},
Lint {
name: "match_wild_err_arm",
- group: "style",
+ group: "pedantic",
desc: "a `match` with `Err(_)` arm and take drastic actions",
deprecation: None,
module: "matches",
},
+ Lint {
+ name: "match_wildcard_for_single_variants",
+ group: "pedantic",
+ desc: "a wildcard enum match for a single variant",
+ deprecation: None,
+ module: "matches",
+ },
Lint {
name: "maybe_infinite_iter",
group: "pedantic",
deprecation: None,
module: "minmax",
},
+ Lint {
+ name: "mismatched_target_os",
+ group: "correctness",
+ desc: "usage of `cfg(operating_system)` instead of `cfg(target_os = \"operating_system\")`",
+ deprecation: None,
+ module: "attrs",
+ },
Lint {
name: "misrefactored_assign_op",
group: "complexity",
Lint {
name: "new_ret_no_self",
group: "style",
- desc: "not returning `Self` in a `new` method",
+ desc: "not returning type containing `Self` in a `new` method",
deprecation: None,
module: "methods",
},
deprecation: None,
module: "eq_op",
},
- Lint {
- name: "option_and_then_some",
- group: "complexity",
- desc: "using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`",
- deprecation: None,
- module: "methods",
- },
Lint {
name: "option_as_ref_deref",
group: "complexity",
deprecation: None,
module: "option_env_unwrap",
},
- Lint {
- name: "option_expect_used",
- group: "restriction",
- desc: "using `Option.expect()`, which might be better handled",
- deprecation: None,
- module: "methods",
- },
Lint {
name: "option_map_or_none",
group: "style",
deprecation: None,
module: "map_unit_fn",
},
- Lint {
- name: "option_map_unwrap_or",
- group: "pedantic",
- desc: "using `Option.map(f).unwrap_or(a)`, which is more succinctly expressed as `map_or(a, f)`",
- deprecation: None,
- module: "methods",
- },
- Lint {
- name: "option_map_unwrap_or_else",
- group: "pedantic",
- desc: "using `Option.map(f).unwrap_or_else(g)`, which is more succinctly expressed as `map_or_else(g, f)`",
- deprecation: None,
- module: "methods",
- },
Lint {
name: "option_option",
- group: "complexity",
+ group: "pedantic",
desc: "usage of `Option<Option<T>>`",
deprecation: None,
module: "types",
},
- Lint {
- name: "option_unwrap_used",
- group: "restriction",
- desc: "using `Option.unwrap()`, which should at least get a better message using `expect()`",
- deprecation: None,
- module: "methods",
- },
Lint {
name: "or_fun_call",
group: "perf",
deprecation: None,
module: "ranges",
},
+ Lint {
+ name: "redundant_allocation",
+ group: "perf",
+ desc: "redundant allocation",
+ deprecation: None,
+ module: "types",
+ },
Lint {
name: "redundant_clone",
group: "perf",
module: "matches",
},
Lint {
- name: "result_expect_used",
- group: "restriction",
- desc: "using `Result.expect()`, which might be better handled",
+ name: "result_map_or_into_option",
+ group: "style",
+ desc: "using `Result.map_or(None, Some)`, which is more succinctly expressed as `ok()`",
deprecation: None,
module: "methods",
},
module: "map_unit_fn",
},
Lint {
- name: "result_map_unwrap_or_else",
- group: "pedantic",
- desc: "using `Result.map(f).unwrap_or_else(g)`, which is more succinctly expressed as `.map_or_else(g, f)`",
- deprecation: None,
- module: "methods",
- },
- Lint {
- name: "result_unwrap_used",
- group: "restriction",
- desc: "using `Result.unwrap()`, which might be better handled",
- deprecation: None,
- module: "methods",
- },
- Lint {
- name: "reverse_range_loop",
+ name: "reversed_empty_ranges",
group: "correctness",
- desc: "iteration over an empty range, such as `10..0` or `5..5`",
+ desc: "reversing the limits of range expressions, resulting in empty ranges",
deprecation: None,
- module: "loops",
+ module: "ranges",
},
Lint {
name: "same_functions_in_if_condition",
},
Lint {
name: "trivially_copy_pass_by_ref",
- group: "perf",
+ group: "pedantic",
desc: "functions taking small copyable arguments by reference",
deprecation: None,
module: "trivially_copy_pass_by_ref",
},
Lint {
name: "unreadable_literal",
- group: "style",
+ group: "pedantic",
desc: "long integer literal without underscores",
deprecation: None,
module: "literal_representation",
},
+ Lint {
+ name: "unsafe_derive_deserialize",
+ group: "pedantic",
+ desc: "deriving `serde::Deserialize` on a type that has methods using `unsafe`",
+ deprecation: None,
+ module: "derive",
+ },
Lint {
name: "unsafe_removed_from_name",
group: "style",
deprecation: None,
module: "returns",
},
+ Lint {
+ name: "unwrap_used",
+ group: "restriction",
+ desc: "using `.unwrap()` on `Result` or `Option`, which should at least get a better message using `expect()`",
+ deprecation: None,
+ module: "methods",
+ },
Lint {
name: "use_debug",
group: "restriction",
deprecation: None,
module: "attrs",
},
+ Lint {
+ name: "useless_conversion",
+ group: "complexity",
+ desc: "calls to `Into`, `TryInto`, `From`, `TryFrom`, `IntoIter` that performs useless conversions to the same type",
+ deprecation: None,
+ module: "useless_conversion",
+ },
Lint {
name: "useless_format",
group: "complexity",
},
Lint {
name: "useless_let_if_seq",
- group: "style",
+ group: "nursery",
desc: "unidiomatic `let mut` declaration followed by initialization in `if`",
deprecation: None,
module: "let_if_seq",
deprecation: None,
module: "verbose_file_reads",
},
+ Lint {
+ name: "vtable_address_comparisons",
+ group: "correctness",
+ desc: "comparison with an address of a trait vtable",
+ deprecation: None,
+ module: "unnamed_address",
+ },
Lint {
name: "while_immutable_condition",
group: "correctness",
Lint {
name: "zero_divided_by_zero",
group: "complexity",
- desc: "usage of `0.0 / 0.0` to obtain NaN instead of `std::f32::NAN` or `std::f64::NAN`",
+ desc: "usage of `0.0 / 0.0` to obtain NaN instead of `f32::NAN` or `f64::NAN`",
deprecation: None,
module: "zero_div_zero",
},
},
];
// end lint list, do not remove this comment, it’s used in `update_lints`
+}