bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Make lint descriptions short and to the point; always fitting the column "triggers on".

Browse source
This commit is contained in:
Georg Brandl 2016-08-06 10:18:36 +02:00
parent 3b5ff0f813
commit b91c1a509e
51 changed files with 340 additions and 243 deletions
Download patch file Download diff file Expand all files Collapse all files

140
README.md
View file

@ -19,17 +19,17 @@ Table of contents:
There are 162 lints included in this crate: There are 162 lints included in this crate:
name | default | meaning name | default | triggers on
---------------------------------------------------------------------------------------------------------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ---------------------------------------------------------------------------------------------------------------------|---------|----------------------------------------------------------------------------------------------------------------------------------
[absurd_extreme_comparisons](https://github.com/Manishearth/rust-clippy/wiki#absurd_extreme_comparisons) | warn | a comparison involving a maximum or minimum value involves a case that is always true or always false [absurd_extreme_comparisons](https://github.com/Manishearth/rust-clippy/wiki#absurd_extreme_comparisons) | warn | a comparison with a maximum or minimum value that is always true or false
[almost_swapped](https://github.com/Manishearth/rust-clippy/wiki#almost_swapped) | warn | `foo = bar; bar = foo` sequence [almost_swapped](https://github.com/Manishearth/rust-clippy/wiki#almost_swapped) | warn | `foo = bar; bar = foo` sequence
[approx_constant](https://github.com/Manishearth/rust-clippy/wiki#approx_constant) | warn | the approximate of a known float constant (in `std::f64::consts` or `std::f32::consts`) is found; suggests to use the constant [approx_constant](https://github.com/Manishearth/rust-clippy/wiki#approx_constant) | warn | the approximate of a known float constant (in `std::fXX::consts`)
[assign_op_pattern](https://github.com/Manishearth/rust-clippy/wiki#assign_op_pattern) | warn | assigning the result of an operation on a variable to that same variable [assign_op_pattern](https://github.com/Manishearth/rust-clippy/wiki#assign_op_pattern) | warn | assigning the result of an operation on a variable to that same variable
[assign_ops](https://github.com/Manishearth/rust-clippy/wiki#assign_ops) | allow | any assignment operation [assign_ops](https://github.com/Manishearth/rust-clippy/wiki#assign_ops) | allow | any compound assignment operation
[bad_bit_mask](https://github.com/Manishearth/rust-clippy/wiki#bad_bit_mask) | warn | expressions of the form `_ & mask == select` that will only ever return `true` or `false` (because in the example `select` containing bits that `mask` doesn't have) [bad_bit_mask](https://github.com/Manishearth/rust-clippy/wiki#bad_bit_mask) | warn | expressions of the form `_ & mask == select` that will only ever return `true` or `false`
[blacklisted_name](https://github.com/Manishearth/rust-clippy/wiki#blacklisted_name) | warn | usage of a blacklisted/placeholder name [blacklisted_name](https://github.com/Manishearth/rust-clippy/wiki#blacklisted_name) | warn | usage of a blacklisted/placeholder name
[block_in_if_condition_expr](https://github.com/Manishearth/rust-clippy/wiki#block_in_if_condition_expr) | warn | braces can be eliminated in conditions that are expressions, e.g `if { true } ...` [block_in_if_condition_expr](https://github.com/Manishearth/rust-clippy/wiki#block_in_if_condition_expr) | warn | braces that can be eliminated in conditions, e.g `if { true } ...`
[block_in_if_condition_stmt](https://github.com/Manishearth/rust-clippy/wiki#block_in_if_condition_stmt) | warn | avoid complex blocks in conditions, instead move the block higher and bind it with 'let'; e.g: `if { let x = true; x } ...` [block_in_if_condition_stmt](https://github.com/Manishearth/rust-clippy/wiki#block_in_if_condition_stmt) | warn | complex blocks in conditions, e.g. `if { let x = true; x } ...`
[bool_comparison](https://github.com/Manishearth/rust-clippy/wiki#bool_comparison) | warn | comparing a variable to a boolean, e.g. `if x == true` [bool_comparison](https://github.com/Manishearth/rust-clippy/wiki#bool_comparison) | warn | comparing a variable to a boolean, e.g. `if x == true`
[box_vec](https://github.com/Manishearth/rust-clippy/wiki#box_vec) | warn | usage of `Box<Vec<T>>`, vector elements are already on the heap [box_vec](https://github.com/Manishearth/rust-clippy/wiki#box_vec) | warn | usage of `Box<Vec<T>>`, vector elements are already on the heap
[boxed_local](https://github.com/Manishearth/rust-clippy/wiki#boxed_local) | warn | using `Box<T>` where unnecessary [boxed_local](https://github.com/Manishearth/rust-clippy/wiki#boxed_local) | warn | using `Box<T>` where unnecessary
@ -37,25 +37,25 @@ name
[cast_possible_wrap](https://github.com/Manishearth/rust-clippy/wiki#cast_possible_wrap) | allow | casts that may cause wrapping around the value, e.g `x as i32` where `x: u32` and `x > i32::MAX` [cast_possible_wrap](https://github.com/Manishearth/rust-clippy/wiki#cast_possible_wrap) | allow | casts that may cause wrapping around the value, e.g `x as i32` where `x: u32` and `x > i32::MAX`
[cast_precision_loss](https://github.com/Manishearth/rust-clippy/wiki#cast_precision_loss) | allow | casts that cause loss of precision, e.g `x as f32` where `x: u64` [cast_precision_loss](https://github.com/Manishearth/rust-clippy/wiki#cast_precision_loss) | allow | casts that cause loss of precision, e.g `x as f32` where `x: u64`
[cast_sign_loss](https://github.com/Manishearth/rust-clippy/wiki#cast_sign_loss) | allow | casts from signed types to unsigned types, e.g `x as u32` where `x: i32` [cast_sign_loss](https://github.com/Manishearth/rust-clippy/wiki#cast_sign_loss) | allow | casts from signed types to unsigned types, e.g `x as u32` where `x: i32`
[char_lit_as_u8](https://github.com/Manishearth/rust-clippy/wiki#char_lit_as_u8) | warn | Casting a character literal to u8 [char_lit_as_u8](https://github.com/Manishearth/rust-clippy/wiki#char_lit_as_u8) | warn | casting a character literal to u8
[chars_next_cmp](https://github.com/Manishearth/rust-clippy/wiki#chars_next_cmp) | warn | using `.chars().next()` to check if a string starts with a char [chars_next_cmp](https://github.com/Manishearth/rust-clippy/wiki#chars_next_cmp) | warn | using `.chars().next()` to check if a string starts with a char
[clone_double_ref](https://github.com/Manishearth/rust-clippy/wiki#clone_double_ref) | warn | using `clone` on `&&T` [clone_double_ref](https://github.com/Manishearth/rust-clippy/wiki#clone_double_ref) | warn | using `clone` on `&&T`
[clone_on_copy](https://github.com/Manishearth/rust-clippy/wiki#clone_on_copy) | warn | using `clone` on a `Copy` type [clone_on_copy](https://github.com/Manishearth/rust-clippy/wiki#clone_on_copy) | warn | using `clone` on a `Copy` type
[cmp_nan](https://github.com/Manishearth/rust-clippy/wiki#cmp_nan) | deny | comparisons to NAN (which will always return false, which is probably not intended) [cmp_nan](https://github.com/Manishearth/rust-clippy/wiki#cmp_nan) | deny | comparisons to NAN, which will always return false, probably not intended
[cmp_owned](https://github.com/Manishearth/rust-clippy/wiki#cmp_owned) | warn | creating owned instances for comparing with others, e.g. `x == "foo".to_string()` [cmp_owned](https://github.com/Manishearth/rust-clippy/wiki#cmp_owned) | warn | creating owned instances for comparing with others, e.g. `x == "foo".to_string()`
[collapsible_if](https://github.com/Manishearth/rust-clippy/wiki#collapsible_if) | warn | `if`s that can be collapsed (e.g. `if x { if y { ... } }` and `else { if x { ... } }`) [collapsible_if](https://github.com/Manishearth/rust-clippy/wiki#collapsible_if) | warn | `if`s that can be collapsed (e.g. `if x { if y { ... } }` and `else { if x { ... } }`)
[crosspointer_transmute](https://github.com/Manishearth/rust-clippy/wiki#crosspointer_transmute) | warn | transmutes that have to or from types that are a pointer to the other [crosspointer_transmute](https://github.com/Manishearth/rust-clippy/wiki#crosspointer_transmute) | warn | transmutes that have to or from types that are a pointer to the other
[cyclomatic_complexity](https://github.com/Manishearth/rust-clippy/wiki#cyclomatic_complexity) | warn | finds functions that should be split up into multiple functions [cyclomatic_complexity](https://github.com/Manishearth/rust-clippy/wiki#cyclomatic_complexity) | warn | functions that should be split up into multiple functions
[deprecated_semver](https://github.com/Manishearth/rust-clippy/wiki#deprecated_semver) | warn | `Warn` on `#[deprecated(since = "x")]` where x is not semver [deprecated_semver](https://github.com/Manishearth/rust-clippy/wiki#deprecated_semver) | warn | use of `#[deprecated(since = "x")]` where x is not semver
[derive_hash_xor_eq](https://github.com/Manishearth/rust-clippy/wiki#derive_hash_xor_eq) | warn | deriving `Hash` but implementing `PartialEq` explicitly [derive_hash_xor_eq](https://github.com/Manishearth/rust-clippy/wiki#derive_hash_xor_eq) | warn | deriving `Hash` but implementing `PartialEq` explicitly
[doc_markdown](https://github.com/Manishearth/rust-clippy/wiki#doc_markdown) | warn | checks for the presence of `_`, `::` or camel-case outside ticks in documentation [doc_markdown](https://github.com/Manishearth/rust-clippy/wiki#doc_markdown) | warn | presence of `_`, `::` or camel-case outside backticks in documentation
[double_neg](https://github.com/Manishearth/rust-clippy/wiki#double_neg) | warn | `--x` is a double negation of `x` and not a pre-decrement as in C or C++ [double_neg](https://github.com/Manishearth/rust-clippy/wiki#double_neg) | warn | `--x`, which is a double negation of `x` and not a pre-decrement as in C/C++
[drop_ref](https://github.com/Manishearth/rust-clippy/wiki#drop_ref) | warn | call to `std::mem::drop` with a reference instead of an owned value, which will not call the `Drop::drop` method on the underlying value [drop_ref](https://github.com/Manishearth/rust-clippy/wiki#drop_ref) | warn | calls to `std::mem::drop` with a reference instead of an owned value
[duplicate_underscore_argument](https://github.com/Manishearth/rust-clippy/wiki#duplicate_underscore_argument) | warn | Function arguments having names which only differ by an underscore [duplicate_underscore_argument](https://github.com/Manishearth/rust-clippy/wiki#duplicate_underscore_argument) | warn | function arguments having names which only differ by an underscore
[empty_loop](https://github.com/Manishearth/rust-clippy/wiki#empty_loop) | warn | empty `loop {}` detected [empty_loop](https://github.com/Manishearth/rust-clippy/wiki#empty_loop) | warn | empty `loop {}`, which should block or sleep
[enum_clike_unportable_variant](https://github.com/Manishearth/rust-clippy/wiki#enum_clike_unportable_variant) | warn | finds C-like enums that are `repr(isize/usize)` and have values that don't fit into an `i32` [enum_clike_unportable_variant](https://github.com/Manishearth/rust-clippy/wiki#enum_clike_unportable_variant) | warn | C-like enums that are `repr(isize/usize)` and have values that don't fit into an `i32`
[enum_glob_use](https://github.com/Manishearth/rust-clippy/wiki#enum_glob_use) | allow | finds use items that import all variants of an enum [enum_glob_use](https://github.com/Manishearth/rust-clippy/wiki#enum_glob_use) | allow | use items that import all variants of an enum
[enum_variant_names](https://github.com/Manishearth/rust-clippy/wiki#enum_variant_names) | warn | finds enums where all variants share a prefix/postfix [enum_variant_names](https://github.com/Manishearth/rust-clippy/wiki#enum_variant_names) | warn | enums where all variants share a prefix/postfix
[eq_op](https://github.com/Manishearth/rust-clippy/wiki#eq_op) | warn | equal operands on both sides of a comparison or bitwise combination (e.g. `x == x`) [eq_op](https://github.com/Manishearth/rust-clippy/wiki#eq_op) | warn | equal operands on both sides of a comparison or bitwise combination (e.g. `x == x`)
[expl_impl_clone_on_copy](https://github.com/Manishearth/rust-clippy/wiki#expl_impl_clone_on_copy) | warn | implementing `Clone` explicitly on `Copy` types [expl_impl_clone_on_copy](https://github.com/Manishearth/rust-clippy/wiki#expl_impl_clone_on_copy) | warn | implementing `Clone` explicitly on `Copy` types
[explicit_counter_loop](https://github.com/Manishearth/rust-clippy/wiki#explicit_counter_loop) | warn | for-looping with an explicit counter when `_.enumerate()` would do [explicit_counter_loop](https://github.com/Manishearth/rust-clippy/wiki#explicit_counter_loop) | warn | for-looping with an explicit counter when `_.enumerate()` would do
@ -63,22 +63,22 @@ name
[extend_from_slice](https://github.com/Manishearth/rust-clippy/wiki#extend_from_slice) | warn | `.extend_from_slice(_)` is a faster way to extend a Vec by a slice [extend_from_slice](https://github.com/Manishearth/rust-clippy/wiki#extend_from_slice) | warn | `.extend_from_slice(_)` is a faster way to extend a Vec by a slice
[filter_map](https://github.com/Manishearth/rust-clippy/wiki#filter_map) | allow | using combinations of `filter`, `map`, `filter_map` and `flat_map` which can usually be written as a single method call [filter_map](https://github.com/Manishearth/rust-clippy/wiki#filter_map) | allow | using combinations of `filter`, `map`, `filter_map` and `flat_map` which can usually be written as a single method call
[filter_next](https://github.com/Manishearth/rust-clippy/wiki#filter_next) | warn | using `filter(p).next()`, which is more succinctly expressed as `.find(p)` [filter_next](https://github.com/Manishearth/rust-clippy/wiki#filter_next) | warn | using `filter(p).next()`, which is more succinctly expressed as `.find(p)`
[float_arithmetic](https://github.com/Manishearth/rust-clippy/wiki#float_arithmetic) | allow | Any floating-point arithmetic statement [float_arithmetic](https://github.com/Manishearth/rust-clippy/wiki#float_arithmetic) | allow | any floating-point arithmetic statement
[float_cmp](https://github.com/Manishearth/rust-clippy/wiki#float_cmp) | warn | using `==` or `!=` on float values (as floating-point operations usually involve rounding errors, it is always better to check for approximate equality within small bounds) [float_cmp](https://github.com/Manishearth/rust-clippy/wiki#float_cmp) | warn | using `==` or `!=` on float values instead of comparing difference with an epsilon
[for_kv_map](https://github.com/Manishearth/rust-clippy/wiki#for_kv_map) | warn | looping on a map using `iter` when `keys` or `values` would do [for_kv_map](https://github.com/Manishearth/rust-clippy/wiki#for_kv_map) | warn | looping on a map using `iter` when `keys` or `values` would do
[for_loop_over_option](https://github.com/Manishearth/rust-clippy/wiki#for_loop_over_option) | warn | for-looping over an `Option`, which is more clearly expressed as an `if let` [for_loop_over_option](https://github.com/Manishearth/rust-clippy/wiki#for_loop_over_option) | warn | for-looping over an `Option`, which is more clearly expressed as an `if let`
[for_loop_over_result](https://github.com/Manishearth/rust-clippy/wiki#for_loop_over_result) | warn | for-looping over a `Result`, which is more clearly expressed as an `if let` [for_loop_over_result](https://github.com/Manishearth/rust-clippy/wiki#for_loop_over_result) | warn | for-looping over a `Result`, which is more clearly expressed as an `if let`
[identity_op](https://github.com/Manishearth/rust-clippy/wiki#identity_op) | warn | using identity operations, e.g. `x + 0` or `y / 1` [identity_op](https://github.com/Manishearth/rust-clippy/wiki#identity_op) | warn | using identity operations, e.g. `x + 0` or `y / 1`
[if_not_else](https://github.com/Manishearth/rust-clippy/wiki#if_not_else) | allow | finds if branches that could be swapped so no negation operation is necessary on the condition [if_not_else](https://github.com/Manishearth/rust-clippy/wiki#if_not_else) | allow | `if` branches that could be swapped so no negation operation is necessary on the condition
[if_same_then_else](https://github.com/Manishearth/rust-clippy/wiki#if_same_then_else) | warn | if with the same *then* and *else* blocks [if_same_then_else](https://github.com/Manishearth/rust-clippy/wiki#if_same_then_else) | warn | if with the same *then* and *else* blocks
[ifs_same_cond](https://github.com/Manishearth/rust-clippy/wiki#ifs_same_cond) | warn | consecutive `ifs` with the same condition [ifs_same_cond](https://github.com/Manishearth/rust-clippy/wiki#ifs_same_cond) | warn | consecutive `ifs` with the same condition
[indexing_slicing](https://github.com/Manishearth/rust-clippy/wiki#indexing_slicing) | allow | indexing/slicing usage [indexing_slicing](https://github.com/Manishearth/rust-clippy/wiki#indexing_slicing) | allow | indexing/slicing usage
[ineffective_bit_mask](https://github.com/Manishearth/rust-clippy/wiki#ineffective_bit_mask) | warn | expressions where a bit mask will be rendered useless by a comparison, e.g. `(x | 1) > 2` [ineffective_bit_mask](https://github.com/Manishearth/rust-clippy/wiki#ineffective_bit_mask) | warn | expressions where a bit mask will be rendered useless by a comparison, e.g. `(x | 1) > 2`
[inline_always](https://github.com/Manishearth/rust-clippy/wiki#inline_always) | warn | `#[inline(always)]` is a bad idea in most cases [inline_always](https://github.com/Manishearth/rust-clippy/wiki#inline_always) | warn | use of `#[inline(always)]`
[integer_arithmetic](https://github.com/Manishearth/rust-clippy/wiki#integer_arithmetic) | allow | Any integer arithmetic statement [integer_arithmetic](https://github.com/Manishearth/rust-clippy/wiki#integer_arithmetic) | allow | any integer arithmetic statement
[invalid_regex](https://github.com/Manishearth/rust-clippy/wiki#invalid_regex) | deny | finds invalid regular expressions [invalid_regex](https://github.com/Manishearth/rust-clippy/wiki#invalid_regex) | deny | invalid regular expressions
[invalid_upcast_comparisons](https://github.com/Manishearth/rust-clippy/wiki#invalid_upcast_comparisons) | allow | a comparison involving an upcast which is always true or false [invalid_upcast_comparisons](https://github.com/Manishearth/rust-clippy/wiki#invalid_upcast_comparisons) | allow | a comparison involving an upcast which is always true or false
[items_after_statements](https://github.com/Manishearth/rust-clippy/wiki#items_after_statements) | allow | finds blocks where an item comes after a statement [items_after_statements](https://github.com/Manishearth/rust-clippy/wiki#items_after_statements) | allow | blocks where an item comes after a statement
[iter_next_loop](https://github.com/Manishearth/rust-clippy/wiki#iter_next_loop) | warn | for-looping over `_.next()` which is probably not intended [iter_next_loop](https://github.com/Manishearth/rust-clippy/wiki#iter_next_loop) | warn | for-looping over `_.next()` which is probably not intended
[iter_nth](https://github.com/Manishearth/rust-clippy/wiki#iter_nth) | warn | using `.iter().nth()` on a standard library type with O(1) element access [iter_nth](https://github.com/Manishearth/rust-clippy/wiki#iter_nth) | warn | using `.iter().nth()` on a standard library type with O(1) element access
[len_without_is_empty](https://github.com/Manishearth/rust-clippy/wiki#len_without_is_empty) | warn | traits and impls that have `.len()` but not `.is_empty()` [len_without_is_empty](https://github.com/Manishearth/rust-clippy/wiki#len_without_is_empty) | warn | traits and impls that have `.len()` but not `.is_empty()`
@ -86,19 +86,19 @@ name
[let_and_return](https://github.com/Manishearth/rust-clippy/wiki#let_and_return) | warn | creating a let-binding and then immediately returning it like `let x = expr; x` at the end of a block [let_and_return](https://github.com/Manishearth/rust-clippy/wiki#let_and_return) | warn | creating a let-binding and then immediately returning it like `let x = expr; x` at the end of a block
[let_unit_value](https://github.com/Manishearth/rust-clippy/wiki#let_unit_value) | warn | creating a let binding to a value of unit type, which usually can't be used afterwards [let_unit_value](https://github.com/Manishearth/rust-clippy/wiki#let_unit_value) | warn | creating a let binding to a value of unit type, which usually can't be used afterwards
[linkedlist](https://github.com/Manishearth/rust-clippy/wiki#linkedlist) | warn | usage of LinkedList, usually a vector is faster, or a more specialized data structure like a VecDeque [linkedlist](https://github.com/Manishearth/rust-clippy/wiki#linkedlist) | warn | usage of LinkedList, usually a vector is faster, or a more specialized data structure like a VecDeque
[logic_bug](https://github.com/Manishearth/rust-clippy/wiki#logic_bug) | warn | checks for boolean expressions that contain terminals which can be eliminated [logic_bug](https://github.com/Manishearth/rust-clippy/wiki#logic_bug) | warn | boolean expressions that contain terminals which can be eliminated
[manual_swap](https://github.com/Manishearth/rust-clippy/wiki#manual_swap) | warn | manual swap [manual_swap](https://github.com/Manishearth/rust-clippy/wiki#manual_swap) | warn | manual swap of two variables
[many_single_char_names](https://github.com/Manishearth/rust-clippy/wiki#many_single_char_names) | warn | too many single character bindings [many_single_char_names](https://github.com/Manishearth/rust-clippy/wiki#many_single_char_names) | warn | too many single character bindings
[map_clone](https://github.com/Manishearth/rust-clippy/wiki#map_clone) | warn | using `.map(|x| x.clone())` to clone an iterator or option's contents (recommends `.cloned()` instead) [map_clone](https://github.com/Manishearth/rust-clippy/wiki#map_clone) | warn | using `.map(|x| x.clone())` to clone an iterator or option's contents
[map_entry](https://github.com/Manishearth/rust-clippy/wiki#map_entry) | warn | use of `contains_key` followed by `insert` on a `HashMap` or `BTreeMap` [map_entry](https://github.com/Manishearth/rust-clippy/wiki#map_entry) | warn | use of `contains_key` followed by `insert` on a `HashMap` or `BTreeMap`
[match_bool](https://github.com/Manishearth/rust-clippy/wiki#match_bool) | warn | a match on boolean expression; recommends `if..else` block instead [match_bool](https://github.com/Manishearth/rust-clippy/wiki#match_bool) | warn | a match on a boolean expression instead of an `if..else` block
[match_overlapping_arm](https://github.com/Manishearth/rust-clippy/wiki#match_overlapping_arm) | warn | a match has overlapping arms [match_overlapping_arm](https://github.com/Manishearth/rust-clippy/wiki#match_overlapping_arm) | warn | a match with overlapping arms
[match_ref_pats](https://github.com/Manishearth/rust-clippy/wiki#match_ref_pats) | warn | a match or `if let` has all arms prefixed with `&`; the match expression can be dereferenced instead [match_ref_pats](https://github.com/Manishearth/rust-clippy/wiki#match_ref_pats) | warn | a match or `if let` with all arms prefixed with `&` instead of deref-ing the match expression
[match_same_arms](https://github.com/Manishearth/rust-clippy/wiki#match_same_arms) | warn | `match` with identical arm bodies [match_same_arms](https://github.com/Manishearth/rust-clippy/wiki#match_same_arms) | warn | `match` with identical arm bodies
[mem_forget](https://github.com/Manishearth/rust-clippy/wiki#mem_forget) | allow | `mem::forget` usage on `Drop` types is likely to cause memory leaks [mem_forget](https://github.com/Manishearth/rust-clippy/wiki#mem_forget) | allow | `mem::forget` usage on `Drop` types, likely to cause memory leaks
[min_max](https://github.com/Manishearth/rust-clippy/wiki#min_max) | warn | `min(_, max(_, _))` (or vice versa) with bounds clamping the result to a constant [min_max](https://github.com/Manishearth/rust-clippy/wiki#min_max) | warn | `min(_, max(_, _))` (or vice versa) with bounds clamping the result to a constant
[misrefactored_assign_op](https://github.com/Manishearth/rust-clippy/wiki#misrefactored_assign_op) | warn | having a variable on both sides of an assign op [misrefactored_assign_op](https://github.com/Manishearth/rust-clippy/wiki#misrefactored_assign_op) | warn | having a variable on both sides of an assign op
[mixed_case_hex_literals](https://github.com/Manishearth/rust-clippy/wiki#mixed_case_hex_literals) | warn | letter digits in hex literals should be either completely upper- or lowercased [mixed_case_hex_literals](https://github.com/Manishearth/rust-clippy/wiki#mixed_case_hex_literals) | warn | hex literals whose letter digits are not consistently upper- or lowercased
[modulo_one](https://github.com/Manishearth/rust-clippy/wiki#modulo_one) | warn | taking a number modulo 1, which always returns 0 [modulo_one](https://github.com/Manishearth/rust-clippy/wiki#modulo_one) | warn | taking a number modulo 1, which always returns 0
[mut_mut](https://github.com/Manishearth/rust-clippy/wiki#mut_mut) | allow | usage of double-mut refs, e.g. `&mut &mut ...` [mut_mut](https://github.com/Manishearth/rust-clippy/wiki#mut_mut) | allow | usage of double-mut refs, e.g. `&mut &mut ...`
[mutex_atomic](https://github.com/Manishearth/rust-clippy/wiki#mutex_atomic) | warn | using a mutex where an atomic value could be used instead [mutex_atomic](https://github.com/Manishearth/rust-clippy/wiki#mutex_atomic) | warn | using a mutex where an atomic value could be used instead
@ -109,74 +109,74 @@ name
[needless_range_loop](https://github.com/Manishearth/rust-clippy/wiki#needless_range_loop) | warn | for-looping over a range of indices where an iterator over items would do [needless_range_loop](https://github.com/Manishearth/rust-clippy/wiki#needless_range_loop) | warn | for-looping over a range of indices where an iterator over items would do
[needless_return](https://github.com/Manishearth/rust-clippy/wiki#needless_return) | warn | using a return statement like `return expr;` where an expression would suffice [needless_return](https://github.com/Manishearth/rust-clippy/wiki#needless_return) | warn | using a return statement like `return expr;` where an expression would suffice
[needless_update](https://github.com/Manishearth/rust-clippy/wiki#needless_update) | warn | using `Foo { ..base }` when there are no missing fields [needless_update](https://github.com/Manishearth/rust-clippy/wiki#needless_update) | warn | using `Foo { ..base }` when there are no missing fields
[neg_multiply](https://github.com/Manishearth/rust-clippy/wiki#neg_multiply) | warn | Warns on multiplying integers with -1 [neg_multiply](https://github.com/Manishearth/rust-clippy/wiki#neg_multiply) | warn | multiplying integers with -1
[new_ret_no_self](https://github.com/Manishearth/rust-clippy/wiki#new_ret_no_self) | warn | not returning `Self` in a `new` method [new_ret_no_self](https://github.com/Manishearth/rust-clippy/wiki#new_ret_no_self) | warn | not returning `Self` in a `new` method
[new_without_default](https://github.com/Manishearth/rust-clippy/wiki#new_without_default) | warn | `fn new() -> Self` method without `Default` implementation [new_without_default](https://github.com/Manishearth/rust-clippy/wiki#new_without_default) | warn | `fn new() -> Self` method without `Default` implementation
[new_without_default_derive](https://github.com/Manishearth/rust-clippy/wiki#new_without_default_derive) | warn | `fn new() -> Self` without `#[derive]`able `Default` implementation [new_without_default_derive](https://github.com/Manishearth/rust-clippy/wiki#new_without_default_derive) | warn | `fn new() -> Self` without `#[derive]`able `Default` implementation
[no_effect](https://github.com/Manishearth/rust-clippy/wiki#no_effect) | warn | statements with no effect [no_effect](https://github.com/Manishearth/rust-clippy/wiki#no_effect) | warn | statements with no effect
[non_ascii_literal](https://github.com/Manishearth/rust-clippy/wiki#non_ascii_literal) | allow | using any literal non-ASCII chars in a string literal; suggests using the `\\u` escape instead [non_ascii_literal](https://github.com/Manishearth/rust-clippy/wiki#non_ascii_literal) | allow | using any literal non-ASCII chars in a string literal instead of using the `\\u` escape
[nonminimal_bool](https://github.com/Manishearth/rust-clippy/wiki#nonminimal_bool) | allow | checks for boolean expressions that can be written more concisely [nonminimal_bool](https://github.com/Manishearth/rust-clippy/wiki#nonminimal_bool) | allow | boolean expressions that can be written more concisely
[nonsensical_open_options](https://github.com/Manishearth/rust-clippy/wiki#nonsensical_open_options) | warn | nonsensical combination of options for opening a file [nonsensical_open_options](https://github.com/Manishearth/rust-clippy/wiki#nonsensical_open_options) | warn | nonsensical combination of options for opening a file
[not_unsafe_ptr_arg_deref](https://github.com/Manishearth/rust-clippy/wiki#not_unsafe_ptr_arg_deref) | warn | public functions dereferencing raw pointer arguments but not marked `unsafe` [not_unsafe_ptr_arg_deref](https://github.com/Manishearth/rust-clippy/wiki#not_unsafe_ptr_arg_deref) | warn | public functions dereferencing raw pointer arguments but not marked `unsafe`
[ok_expect](https://github.com/Manishearth/rust-clippy/wiki#ok_expect) | warn | using `ok().expect()`, which gives worse error messages than calling `expect` directly on the Result [ok_expect](https://github.com/Manishearth/rust-clippy/wiki#ok_expect) | warn | using `ok().expect()`, which gives worse error messages than calling `expect` directly on the Result
[option_map_unwrap_or](https://github.com/Manishearth/rust-clippy/wiki#option_map_unwrap_or) | warn | using `Option.map(f).unwrap_or(a)`, which is more succinctly expressed as `map_or(a, f)` [option_map_unwrap_or](https://github.com/Manishearth/rust-clippy/wiki#option_map_unwrap_or) | warn | using `Option.map(f).unwrap_or(a)`, which is more succinctly expressed as `map_or(a, f)`
[option_map_unwrap_or_else](https://github.com/Manishearth/rust-clippy/wiki#option_map_unwrap_or_else) | warn | using `Option.map(f).unwrap_or_else(g)`, which is more succinctly expressed as `map_or_else(g, f)` [option_map_unwrap_or_else](https://github.com/Manishearth/rust-clippy/wiki#option_map_unwrap_or_else) | warn | using `Option.map(f).unwrap_or_else(g)`, which is more succinctly expressed as `map_or_else(g, f)`
[option_unwrap_used](https://github.com/Manishearth/rust-clippy/wiki#option_unwrap_used) | allow | using `Option.unwrap()`, which should at least get a better message using `expect()` [option_unwrap_used](https://github.com/Manishearth/rust-clippy/wiki#option_unwrap_used) | allow | using `Option.unwrap()`, which should at least get a better message using `expect()`
[or_fun_call](https://github.com/Manishearth/rust-clippy/wiki#or_fun_call) | warn | using any `*or` method when the `*or_else` would do [or_fun_call](https://github.com/Manishearth/rust-clippy/wiki#or_fun_call) | warn | using any `*or` method with a function call, which suggests `*or_else`
[out_of_bounds_indexing](https://github.com/Manishearth/rust-clippy/wiki#out_of_bounds_indexing) | deny | out of bound constant indexing [out_of_bounds_indexing](https://github.com/Manishearth/rust-clippy/wiki#out_of_bounds_indexing) | deny | out of bounds constant indexing
[overflow_check_conditional](https://github.com/Manishearth/rust-clippy/wiki#overflow_check_conditional) | warn | Using overflow checks which are likely to panic [overflow_check_conditional](https://github.com/Manishearth/rust-clippy/wiki#overflow_check_conditional) | warn | overflow checks inspired by C which are likely to panic
[panic_params](https://github.com/Manishearth/rust-clippy/wiki#panic_params) | warn | missing parameters in `panic!` [panic_params](https://github.com/Manishearth/rust-clippy/wiki#panic_params) | warn | missing parameters in `panic!` calls
[precedence](https://github.com/Manishearth/rust-clippy/wiki#precedence) | warn | catches operations where precedence may be unclear [precedence](https://github.com/Manishearth/rust-clippy/wiki#precedence) | warn | operations where precedence may be unclear
[print_stdout](https://github.com/Manishearth/rust-clippy/wiki#print_stdout) | allow | printing on stdout [print_stdout](https://github.com/Manishearth/rust-clippy/wiki#print_stdout) | allow | printing on stdout
[ptr_arg](https://github.com/Manishearth/rust-clippy/wiki#ptr_arg) | warn | fn arguments of the type `&Vec<...>` or `&String`, suggesting to use `&[...]` or `&str` instead, respectively [ptr_arg](https://github.com/Manishearth/rust-clippy/wiki#ptr_arg) | warn | arguments of the type `&Vec<...>` (instead of `&[...]`) or `&String` (instead of `&str`)
[range_step_by_zero](https://github.com/Manishearth/rust-clippy/wiki#range_step_by_zero) | warn | using Range::step_by(0), which produces an infinite iterator [range_step_by_zero](https://github.com/Manishearth/rust-clippy/wiki#range_step_by_zero) | warn | using `Range::step_by(0)`, which produces an infinite iterator
[range_zip_with_len](https://github.com/Manishearth/rust-clippy/wiki#range_zip_with_len) | warn | zipping iterator with a range when enumerate() would do [range_zip_with_len](https://github.com/Manishearth/rust-clippy/wiki#range_zip_with_len) | warn | zipping iterator with a range when `enumerate()` would do
[redundant_closure](https://github.com/Manishearth/rust-clippy/wiki#redundant_closure) | warn | using redundant closures, i.e. `|a| foo(a)` (which can be written as just `foo`) [redundant_closure](https://github.com/Manishearth/rust-clippy/wiki#redundant_closure) | warn | redundant closures, i.e. `|a| foo(a)` (which can be written as just `foo`)
[redundant_closure_call](https://github.com/Manishearth/rust-clippy/wiki#redundant_closure_call) | warn | Closures should not be called in the expression they are defined [redundant_closure_call](https://github.com/Manishearth/rust-clippy/wiki#redundant_closure_call) | warn | throwaway closures called in the expression they are defined
[redundant_pattern](https://github.com/Manishearth/rust-clippy/wiki#redundant_pattern) | warn | using `name @ _` in a pattern [redundant_pattern](https://github.com/Manishearth/rust-clippy/wiki#redundant_pattern) | warn | using `name @ _` in a pattern
[regex_macro](https://github.com/Manishearth/rust-clippy/wiki#regex_macro) | warn | finds use of `regex!(_)`, suggests `Regex::new(_)` instead [regex_macro](https://github.com/Manishearth/rust-clippy/wiki#regex_macro) | warn | use of `regex!(_)` instead of `Regex::new(_)`
[result_unwrap_used](https://github.com/Manishearth/rust-clippy/wiki#result_unwrap_used) | allow | using `Result.unwrap()`, which might be better handled [result_unwrap_used](https://github.com/Manishearth/rust-clippy/wiki#result_unwrap_used) | allow | using `Result.unwrap()`, which might be better handled
[reverse_range_loop](https://github.com/Manishearth/rust-clippy/wiki#reverse_range_loop) | warn | Iterating over an empty range, such as `10..0` or `5..5` [reverse_range_loop](https://github.com/Manishearth/rust-clippy/wiki#reverse_range_loop) | warn | iteration over an empty range, such as `10..0` or `5..5`
[search_is_some](https://github.com/Manishearth/rust-clippy/wiki#search_is_some) | warn | using an iterator search followed by `is_some()`, which is more succinctly expressed as a call to `any()` [search_is_some](https://github.com/Manishearth/rust-clippy/wiki#search_is_some) | warn | using an iterator search followed by `is_some()`, which is more succinctly expressed as a call to `any()`
[serde_api_misuse](https://github.com/Manishearth/rust-clippy/wiki#serde_api_misuse) | warn | Various things that will negatively affect your serde experience [serde_api_misuse](https://github.com/Manishearth/rust-clippy/wiki#serde_api_misuse) | warn | various things that will negatively affect your serde experience
[shadow_reuse](https://github.com/Manishearth/rust-clippy/wiki#shadow_reuse) | allow | rebinding a name to an expression that re-uses the original value, e.g. `let x = x + 1` [shadow_reuse](https://github.com/Manishearth/rust-clippy/wiki#shadow_reuse) | allow | rebinding a name to an expression that re-uses the original value, e.g. `let x = x + 1`
[shadow_same](https://github.com/Manishearth/rust-clippy/wiki#shadow_same) | allow | rebinding a name to itself, e.g. `let mut x = &mut x` [shadow_same](https://github.com/Manishearth/rust-clippy/wiki#shadow_same) | allow | rebinding a name to itself, e.g. `let mut x = &mut x`
[shadow_unrelated](https://github.com/Manishearth/rust-clippy/wiki#shadow_unrelated) | allow | The name is re-bound without even using the original value [shadow_unrelated](https://github.com/Manishearth/rust-clippy/wiki#shadow_unrelated) | allow | rebinding a name without even using the original value
[should_implement_trait](https://github.com/Manishearth/rust-clippy/wiki#should_implement_trait) | warn | defining a method that should be implementing a std trait [should_implement_trait](https://github.com/Manishearth/rust-clippy/wiki#should_implement_trait) | warn | defining a method that should be implementing a std trait
[similar_names](https://github.com/Manishearth/rust-clippy/wiki#similar_names) | allow | similarly named items and bindings [similar_names](https://github.com/Manishearth/rust-clippy/wiki#similar_names) | allow | similarly named items and bindings
[single_char_pattern](https://github.com/Manishearth/rust-clippy/wiki#single_char_pattern) | warn | using a single-character str where a char could be used, e.g. `_.split("x")` [single_char_pattern](https://github.com/Manishearth/rust-clippy/wiki#single_char_pattern) | warn | using a single-character str where a char could be used, e.g. `_.split("x")`
[single_match](https://github.com/Manishearth/rust-clippy/wiki#single_match) | warn | a match statement with a single nontrivial arm (i.e, where the other arm is `_ => {}`) is used; recommends `if let` instead [single_match](https://github.com/Manishearth/rust-clippy/wiki#single_match) | warn | a match statement with a single nontrivial arm (i.e, where the other arm is `_ => {}`) instead of `if let`
[single_match_else](https://github.com/Manishearth/rust-clippy/wiki#single_match_else) | allow | a match statement with a two arms where the second arm's pattern is a wildcard; recommends `if let` instead [single_match_else](https://github.com/Manishearth/rust-clippy/wiki#single_match_else) | allow | a match statement with a two arms where the second arm's pattern is a wildcard instead of `if let`
[string_add](https://github.com/Manishearth/rust-clippy/wiki#string_add) | allow | using `x + ..` where x is a `String`; suggests using `push_str()` instead [string_add](https://github.com/Manishearth/rust-clippy/wiki#string_add) | allow | using `x + ..` where x is a `String` instead of `push_str()`
[string_add_assign](https://github.com/Manishearth/rust-clippy/wiki#string_add_assign) | allow | using `x = x + ..` where x is a `String`; suggests using `push_str()` instead [string_add_assign](https://github.com/Manishearth/rust-clippy/wiki#string_add_assign) | allow | using `x = x + ..` where x is a `String` instead of `push_str()`
[string_lit_as_bytes](https://github.com/Manishearth/rust-clippy/wiki#string_lit_as_bytes) | warn | calling `as_bytes` on a string literal; suggests using a byte string literal instead [string_lit_as_bytes](https://github.com/Manishearth/rust-clippy/wiki#string_lit_as_bytes) | warn | calling `as_bytes` on a string literal instead of using a byte string literal
[stutter](https://github.com/Manishearth/rust-clippy/wiki#stutter) | allow | finds type names prefixed/postfixed with their containing module's name [stutter](https://github.com/Manishearth/rust-clippy/wiki#stutter) | allow | type names prefixed/postfixed with their containing module's name
[suspicious_assignment_formatting](https://github.com/Manishearth/rust-clippy/wiki#suspicious_assignment_formatting) | warn | suspicious formatting of `*=`, `-=` or `!=` [suspicious_assignment_formatting](https://github.com/Manishearth/rust-clippy/wiki#suspicious_assignment_formatting) | warn | suspicious formatting of `*=`, `-=` or `!=`
[suspicious_else_formatting](https://github.com/Manishearth/rust-clippy/wiki#suspicious_else_formatting) | warn | suspicious formatting of `else if` [suspicious_else_formatting](https://github.com/Manishearth/rust-clippy/wiki#suspicious_else_formatting) | warn | suspicious formatting of `else if`
[temporary_assignment](https://github.com/Manishearth/rust-clippy/wiki#temporary_assignment) | warn | assignments to temporaries [temporary_assignment](https://github.com/Manishearth/rust-clippy/wiki#temporary_assignment) | warn | assignments to temporaries
[temporary_cstring_as_ptr](https://github.com/Manishearth/rust-clippy/wiki#temporary_cstring_as_ptr) | warn | getting the inner pointer of a temporary `CString` [temporary_cstring_as_ptr](https://github.com/Manishearth/rust-clippy/wiki#temporary_cstring_as_ptr) | warn | getting the inner pointer of a temporary `CString`
[too_many_arguments](https://github.com/Manishearth/rust-clippy/wiki#too_many_arguments) | warn | functions with too many arguments [too_many_arguments](https://github.com/Manishearth/rust-clippy/wiki#too_many_arguments) | warn | functions with too many arguments
[toplevel_ref_arg](https://github.com/Manishearth/rust-clippy/wiki#toplevel_ref_arg) | warn | An entire binding was declared as `ref`, in a function argument (`fn foo(ref x: Bar)`), or a `let` statement (`let ref x = foo()`). In such cases, it is preferred to take references with `&`. [toplevel_ref_arg](https://github.com/Manishearth/rust-clippy/wiki#toplevel_ref_arg) | warn | an entire binding declared as `ref`, in a function argument or a `let` statement
[transmute_ptr_to_ref](https://github.com/Manishearth/rust-clippy/wiki#transmute_ptr_to_ref) | warn | transmutes from a pointer to a reference type [transmute_ptr_to_ref](https://github.com/Manishearth/rust-clippy/wiki#transmute_ptr_to_ref) | warn | transmutes from a pointer to a reference type
[trivial_regex](https://github.com/Manishearth/rust-clippy/wiki#trivial_regex) | warn | finds trivial regular expressions [trivial_regex](https://github.com/Manishearth/rust-clippy/wiki#trivial_regex) | warn | trivial regular expressions
[type_complexity](https://github.com/Manishearth/rust-clippy/wiki#type_complexity) | warn | usage of very complex types; recommends factoring out parts into `type` definitions [type_complexity](https://github.com/Manishearth/rust-clippy/wiki#type_complexity) | warn | usage of very complex types that might be better factored into `type` definitions
[unicode_not_nfc](https://github.com/Manishearth/rust-clippy/wiki#unicode_not_nfc) | allow | using a unicode literal not in NFC normal form (see [unicode tr15](http://www.unicode.org/reports/tr15/) for further information) [unicode_not_nfc](https://github.com/Manishearth/rust-clippy/wiki#unicode_not_nfc) | allow | using a unicode literal not in NFC normal form (see [unicode tr15](http://www.unicode.org/reports/tr15/) for further information)
[unit_cmp](https://github.com/Manishearth/rust-clippy/wiki#unit_cmp) | warn | comparing unit values (which is always `true` or `false`, respectively) [unit_cmp](https://github.com/Manishearth/rust-clippy/wiki#unit_cmp) | warn | comparing unit values
[unnecessary_mut_passed](https://github.com/Manishearth/rust-clippy/wiki#unnecessary_mut_passed) | warn | an argument is passed as a mutable reference although the function/method only demands an immutable reference [unnecessary_mut_passed](https://github.com/Manishearth/rust-clippy/wiki#unnecessary_mut_passed) | warn | an argument passed as a mutable reference although the callee only demands an immutable reference
[unnecessary_operation](https://github.com/Manishearth/rust-clippy/wiki#unnecessary_operation) | warn | outer expressions with no effect [unnecessary_operation](https://github.com/Manishearth/rust-clippy/wiki#unnecessary_operation) | warn | outer expressions with no effect
[unneeded_field_pattern](https://github.com/Manishearth/rust-clippy/wiki#unneeded_field_pattern) | warn | Struct fields are bound to a wildcard instead of using `..` [unneeded_field_pattern](https://github.com/Manishearth/rust-clippy/wiki#unneeded_field_pattern) | warn | struct fields bound to a wildcard instead of using `..`
[unsafe_removed_from_name](https://github.com/Manishearth/rust-clippy/wiki#unsafe_removed_from_name) | warn | unsafe removed from name [unsafe_removed_from_name](https://github.com/Manishearth/rust-clippy/wiki#unsafe_removed_from_name) | warn | `unsafe` removed from API names on import
[unseparated_literal_suffix](https://github.com/Manishearth/rust-clippy/wiki#unseparated_literal_suffix) | allow | literal suffixes should be separated with an underscore [unseparated_literal_suffix](https://github.com/Manishearth/rust-clippy/wiki#unseparated_literal_suffix) | allow | literals whose suffix is not separated by an underscore
[unused_collect](https://github.com/Manishearth/rust-clippy/wiki#unused_collect) | warn | `collect()`ing an iterator without using the result; this is usually better written as a for loop [unused_collect](https://github.com/Manishearth/rust-clippy/wiki#unused_collect) | warn | `collect()`ing an iterator without using the result; this is usually better written as a for loop
[unused_label](https://github.com/Manishearth/rust-clippy/wiki#unused_label) | warn | unused label [unused_label](https://github.com/Manishearth/rust-clippy/wiki#unused_label) | warn | unused labels
[unused_lifetimes](https://github.com/Manishearth/rust-clippy/wiki#unused_lifetimes) | warn | unused lifetimes in function definitions [unused_lifetimes](https://github.com/Manishearth/rust-clippy/wiki#unused_lifetimes) | warn | unused lifetimes in function definitions
[use_debug](https://github.com/Manishearth/rust-clippy/wiki#use_debug) | allow | use `Debug`-based formatting [use_debug](https://github.com/Manishearth/rust-clippy/wiki#use_debug) | allow | use of `Debug`-based formatting
[used_underscore_binding](https://github.com/Manishearth/rust-clippy/wiki#used_underscore_binding) | allow | using a binding which is prefixed with an underscore [used_underscore_binding](https://github.com/Manishearth/rust-clippy/wiki#used_underscore_binding) | allow | using a binding which is prefixed with an underscore
[useless_format](https://github.com/Manishearth/rust-clippy/wiki#useless_format) | warn | useless use of `format!` [useless_format](https://github.com/Manishearth/rust-clippy/wiki#useless_format) | warn | useless use of `format!`
[useless_let_if_seq](https://github.com/Manishearth/rust-clippy/wiki#useless_let_if_seq) | warn | Checks for unidiomatic `let mut` declaration followed by initialization in `if` [useless_let_if_seq](https://github.com/Manishearth/rust-clippy/wiki#useless_let_if_seq) | warn | unidiomatic `let mut` declaration followed by initialization in `if`
[useless_transmute](https://github.com/Manishearth/rust-clippy/wiki#useless_transmute) | warn | transmutes that have the same to and from types or could be a cast/coercion [useless_transmute](https://github.com/Manishearth/rust-clippy/wiki#useless_transmute) | warn | transmutes that have the same to and from types or could be a cast/coercion
[useless_vec](https://github.com/Manishearth/rust-clippy/wiki#useless_vec) | warn | useless `vec!` [useless_vec](https://github.com/Manishearth/rust-clippy/wiki#useless_vec) | warn | useless `vec!`
[while_let_loop](https://github.com/Manishearth/rust-clippy/wiki#while_let_loop) | warn | `loop { if let { ... } else break }` can be written as a `while let` loop [while_let_loop](https://github.com/Manishearth/rust-clippy/wiki#while_let_loop) | warn | `loop { if let { ... } else break }`, which can be written as a `while let` loop
[while_let_on_iterator](https://github.com/Manishearth/rust-clippy/wiki#while_let_on_iterator) | warn | using a while-let loop instead of a for loop on an iterator [while_let_on_iterator](https://github.com/Manishearth/rust-clippy/wiki#while_let_on_iterator) | warn | using a while-let loop instead of a for loop on an iterator
[wrong_pub_self_convention](https://github.com/Manishearth/rust-clippy/wiki#wrong_pub_self_convention) | allow | defining a public method named with an established prefix (like "into_") that takes `self` with the wrong convention [wrong_pub_self_convention](https://github.com/Manishearth/rust-clippy/wiki#wrong_pub_self_convention) | allow | defining a public method named with an established prefix (like "into_") that takes `self` with the wrong convention
[wrong_self_convention](https://github.com/Manishearth/rust-clippy/wiki#wrong_self_convention) | warn | defining a method named with an established prefix (like "into_") that takes `self` with the wrong convention [wrong_self_convention](https://github.com/Manishearth/rust-clippy/wiki#wrong_self_convention) | warn | defining a method named with an established prefix (like "into_") that takes `self` with the wrong convention

3
clippy_lints/src/approx_const.rs
View file

@ -28,8 +28,7 @@ use utils::span_lint;
declare_lint! { declare_lint! {
pub APPROX_CONSTANT, pub APPROX_CONSTANT,
Warn, Warn,
"the approximate of a known float constant (in `std::f64::consts` or `std::f32::consts`) \ "the approximate of a known float constant (in `std::fXX::consts`)"
is found; suggests to use the constant"
} }
// Tuples are of the form (constant, name, min_digits) // Tuples are of the form (constant, name, min_digits)

4
clippy_lints/src/arithmetic.rs
View file

@ -17,7 +17,7 @@ use utils::span_lint;
/// ``` /// ```
declare_restriction_lint! { declare_restriction_lint! {
pub INTEGER_ARITHMETIC, pub INTEGER_ARITHMETIC,
"Any integer arithmetic statement" "any integer arithmetic statement"
} }
/// **What it does:** Checks for float arithmetic. /// **What it does:** Checks for float arithmetic.
@ -33,7 +33,7 @@ declare_restriction_lint! {
/// ``` /// ```
declare_restriction_lint! { declare_restriction_lint! {
pub FLOAT_ARITHMETIC, pub FLOAT_ARITHMETIC,
"Any floating-point arithmetic statement" "any floating-point arithmetic statement"
} }
#[derive(Copy, Clone, Default)] #[derive(Copy, Clone, Default)]

2
clippy_lints/src/array_indexing.rs
View file

@ -24,7 +24,7 @@ use utils::{self, higher};
declare_lint! { declare_lint! {
pub OUT_OF_BOUNDS_INDEXING, pub OUT_OF_BOUNDS_INDEXING,
Deny, Deny,
"out of bound constant indexing" "out of bounds constant indexing"
} }
/// **What it does:** Checks for usage of indexing or slicing. /// **What it does:** Checks for usage of indexing or slicing.

2
clippy_lints/src/assign_ops.rs
View file

@ -16,7 +16,7 @@ use utils::{higher, sugg};
/// ``` /// ```
declare_restriction_lint! { declare_restriction_lint! {
pub ASSIGN_OPS, pub ASSIGN_OPS,
"any assignment operation" "any compound assignment operation"
} }
/// **What it does:** Checks for `a = a op b` or `a = b commutative_op a` patterns. /// **What it does:** Checks for `a = a op b` or `a = b commutative_op a` patterns.

10
clippy_lints/src/attrs.rs
View file

@ -30,8 +30,9 @@ use utils::paths;
/// fn not_quite_hot_code(..) { ... } /// fn not_quite_hot_code(..) { ... }
/// ``` /// ```
declare_lint! { declare_lint! {
pub INLINE_ALWAYS, Warn, pub INLINE_ALWAYS,
"`#[inline(always)]` is a bad idea in most cases" Warn,
"use of `#[inline(always)]`"
} }
/// **What it does:** Checks for `#[deprecated]` annotations with a `since` /// **What it does:** Checks for `#[deprecated]` annotations with a `since`
@ -48,8 +49,9 @@ declare_lint! {
/// fn something_else(..) { ... } /// fn something_else(..) { ... }
/// ``` /// ```
declare_lint! { declare_lint! {
pub DEPRECATED_SEMVER, Warn, pub DEPRECATED_SEMVER,
"`Warn` on `#[deprecated(since = \"x\")]` where x is not semver" Warn,
"use of `#[deprecated(since = \"x\")]` where x is not semver"
} }
#[derive(Copy,Clone)] #[derive(Copy,Clone)]

3
clippy_lints/src/bit_mask.rs
View file

@ -39,8 +39,7 @@ use utils::span_lint;
declare_lint! { declare_lint! {
pub BAD_BIT_MASK, pub BAD_BIT_MASK,
Warn, Warn,
"expressions of the form `_ & mask == select` that will only ever return `true` or `false` \ "expressions of the form `_ & mask == select` that will only ever return `true` or `false`"
(because in the example `select` containing bits that `mask` doesn't have)"
} }
/// **What it does:** Checks for bit masks in comparisons which can be removed /// **What it does:** Checks for bit masks in comparisons which can be removed

11
clippy_lints/src/block_in_if_condition.rs
View file

@ -16,8 +16,9 @@ use utils::*;
/// if { true } .. /// if { true } ..
/// ``` /// ```
declare_lint! { declare_lint! {
pub BLOCK_IN_IF_CONDITION_EXPR, Warn, pub BLOCK_IN_IF_CONDITION_EXPR,
"braces can be eliminated in conditions that are expressions, e.g `if { true } ...`" Warn,
"braces that can be eliminated in conditions, e.g `if { true } ...`"
} }
/// **What it does:** Checks for `if` conditions that use blocks containing /// **What it does:** Checks for `if` conditions that use blocks containing
@ -34,9 +35,9 @@ declare_lint! {
/// if somefunc(|x| { x == 47 }) .. /// if somefunc(|x| { x == 47 }) ..
/// ``` /// ```
declare_lint! { declare_lint! {
pub BLOCK_IN_IF_CONDITION_STMT, Warn, pub BLOCK_IN_IF_CONDITION_STMT,
"avoid complex blocks in conditions, instead move the block higher and bind it \ Warn,
with 'let'; e.g: `if { let x = true; x } ...`" "complex blocks in conditions, e.g. `if { let x = true; x } ...`"
} }
#[derive(Copy,Clone)] #[derive(Copy,Clone)]

10
clippy_lints/src/booleans.rs
View file

@ -20,8 +20,9 @@ use utils::{span_lint_and_then, in_macro, snippet_opt, SpanlessEq};
/// if a && true // should be: if a /// if a && true // should be: if a
/// if !(a == b) // should be: if a != b /// if !(a == b) // should be: if a != b
declare_lint! { declare_lint! {
pub NONMINIMAL_BOOL, Allow, pub NONMINIMAL_BOOL,
"checks for boolean expressions that can be written more concisely" Allow,
"boolean expressions that can be written more concisely"
} }
/// **What it does:** Checks for boolean expressions that contain terminals that /// **What it does:** Checks for boolean expressions that contain terminals that
@ -37,8 +38,9 @@ declare_lint! {
/// ``` /// ```
/// The `b` is unnecessary, the expression is equivalent to `if a`. /// The `b` is unnecessary, the expression is equivalent to `if a`.
declare_lint! { declare_lint! {
pub LOGIC_BUG, Warn, pub LOGIC_BUG,
"checks for boolean expressions that contain terminals which can be eliminated" Warn,
"boolean expressions that contain terminals which can be eliminated"
} }
#[derive(Copy,Clone)] #[derive(Copy,Clone)]

5
clippy_lints/src/cyclomatic_complexity.rs
View file

@ -20,8 +20,9 @@ use utils::{in_macro, LimitStack, span_help_and_lint, paths, match_type};
/// ///
/// **Example:** No. You'll see it when you get the warning. /// **Example:** No. You'll see it when you get the warning.
declare_lint! { declare_lint! {
pub CYCLOMATIC_COMPLEXITY, Warn, pub CYCLOMATIC_COMPLEXITY,
"finds functions that should be split up into multiple functions" Warn,
"functions that should be split up into multiple functions"
} }
pub struct CyclomaticComplexity { pub struct CyclomaticComplexity {

5
clippy_lints/src/doc.rs
View file

@ -21,8 +21,9 @@ use utils::span_lint;
/// fn doit(foo_bar) { .. } /// fn doit(foo_bar) { .. }
/// ``` /// ```
declare_lint! { declare_lint! {
pub DOC_MARKDOWN, Warn, pub DOC_MARKDOWN,
"checks for the presence of `_`, `::` or camel-case outside ticks in documentation" Warn,
"presence of `_`, `::` or camel-case outside backticks in documentation"
} }
#[derive(Clone)] #[derive(Clone)]

6
clippy_lints/src/drop_ref.rs
View file

@ -21,9 +21,9 @@ use utils::{match_def_path, paths, span_note_and_lint};
/// operation_that_requires_mutex_to_be_unlocked(); /// operation_that_requires_mutex_to_be_unlocked();
/// ``` /// ```
declare_lint! { declare_lint! {
pub DROP_REF, Warn, pub DROP_REF,
"call to `std::mem::drop` with a reference instead of an owned value, \ Warn,
which will not call the `Drop::drop` method on the underlying value" "calls to `std::mem::drop` with a reference instead of an owned value"
} }
#[allow(missing_copy_implementations)] #[allow(missing_copy_implementations)]

5
clippy_lints/src/enum_clike.rs
View file

@ -23,8 +23,9 @@ use utils::span_lint;
/// } /// }
/// ``` /// ```
declare_lint! { declare_lint! {
pub ENUM_CLIKE_UNPORTABLE_VARIANT, Warn, pub ENUM_CLIKE_UNPORTABLE_VARIANT,
"finds C-like enums that are `repr(isize/usize)` and have values that don't fit into an `i32`" Warn,
"C-like enums that are `repr(isize/usize)` and have values that don't fit into an `i32`"
} }
pub struct UnportableVariant; pub struct UnportableVariant;

7
clippy_lints/src/enum_glob_use.rs
View file

@ -21,8 +21,11 @@ use utils::span_lint;
/// ```rust /// ```rust
/// use std::cmp::Ordering::*; /// use std::cmp::Ordering::*;
/// ``` /// ```
declare_lint! { pub ENUM_GLOB_USE, Allow, declare_lint! {
"finds use items that import all variants of an enum" } pub ENUM_GLOB_USE,
Allow,
"use items that import all variants of an enum"
}
pub struct EnumGlobUse; pub struct EnumGlobUse;

10
clippy_lints/src/enum_variants.rs
View file

@ -23,8 +23,9 @@ use utils::{camel_case_from, camel_case_until, in_macro};
/// } /// }
/// ``` /// ```
declare_lint! { declare_lint! {
pub ENUM_VARIANT_NAMES, Warn, pub ENUM_VARIANT_NAMES,
"finds enums where all variants share a prefix/postfix" Warn,
"enums where all variants share a prefix/postfix"
} }
/// **What it does:** Detects type names that are prefixed or suffixed by the /// **What it does:** Detects type names that are prefixed or suffixed by the
@ -41,8 +42,9 @@ declare_lint! {
/// } /// }
/// ``` /// ```
declare_lint! { declare_lint! {
pub STUTTER, Allow, pub STUTTER,
"finds type names prefixed/postfixed with their containing module's name" Allow,
"type names prefixed/postfixed with their containing module's name"
} }
pub struct EnumVariantNames { pub struct EnumVariantNames {

4
clippy_lints/src/escape.rs
View file

@ -35,7 +35,9 @@ pub struct Pass {
/// } /// }
/// ``` /// ```
declare_lint! { declare_lint! {
pub BOXED_LOCAL, Warn, "using `Box<T>` where unnecessary" pub BOXED_LOCAL,
Warn,
"using `Box<T>` where unnecessary"
} }
fn is_non_trait_box(ty: ty::Ty) -> bool { fn is_non_trait_box(ty: ty::Ty) -> bool {

5
clippy_lints/src/eta_reduction.rs
View file

@ -22,8 +22,9 @@ pub struct EtaPass;
/// ``` /// ```
/// where `foo(_)` is a plain function that takes the exact argument type of `x`. /// where `foo(_)` is a plain function that takes the exact argument type of `x`.
declare_lint! { declare_lint! {
pub REDUNDANT_CLOSURE, Warn, pub REDUNDANT_CLOSURE,
"using redundant closures, i.e. `|a| foo(a)` (which can be written as just `foo`)" Warn,
"redundant closures, i.e. `|a| foo(a)` (which can be written as just `foo`)"
} }
impl LintPass for EtaPass { impl LintPass for EtaPass {

3
clippy_lints/src/identity_op.rs
View file

@ -17,7 +17,8 @@ use rustc_const_math::ConstInt;
/// x / 1 + 0 * 1 - 0 | 0 /// x / 1 + 0 * 1 - 0 | 0
/// ``` /// ```
declare_lint! { declare_lint! {
pub IDENTITY_OP, Warn, pub IDENTITY_OP,
Warn,
"using identity operations, e.g. `x + 0` or `y / 1`" "using identity operations, e.g. `x + 0` or `y / 1`"
} }

5
clippy_lints/src/if_not_else.rs
View file

@ -31,8 +31,9 @@ use utils::span_help_and_lint;
/// } /// }
/// ``` /// ```
declare_lint! { declare_lint! {
pub IF_NOT_ELSE, Allow, pub IF_NOT_ELSE,
"finds if branches that could be swapped so no negation operation is necessary on the condition" Allow,
"`if` branches that could be swapped so no negation operation is necessary on the condition"
} }
pub struct IfNotElse; pub struct IfNotElse;

2
clippy_lints/src/items_after_statements.rs
View file

@ -29,7 +29,7 @@ use utils::{in_macro, span_lint};
declare_lint! { declare_lint! {
pub ITEMS_AFTER_STATEMENTS, pub ITEMS_AFTER_STATEMENTS,
Allow, Allow,
"finds blocks where an item comes after a statement" "blocks where an item comes after a statement"
} }
pub struct ItemsAfterStatements; pub struct ItemsAfterStatements;

6
clippy_lints/src/len_zero.rs
View file

@ -22,7 +22,8 @@ use utils::{get_item_name, in_macro, snippet, span_lint, span_lint_and_then, wal
/// if x.len() == 0 { .. } /// if x.len() == 0 { .. }
/// ``` /// ```
declare_lint! { declare_lint! {
pub LEN_ZERO, Warn, pub LEN_ZERO,
Warn,
"checking `.len() == 0` or `.len() > 0` (or similar) when `.is_empty()` \ "checking `.len() == 0` or `.len() > 0` (or similar) when `.is_empty()` \
could be used instead" could be used instead"
} }
@ -45,7 +46,8 @@ declare_lint! {
/// } /// }
/// ``` /// ```
declare_lint! { declare_lint! {
pub LEN_WITHOUT_IS_EMPTY, Warn, pub LEN_WITHOUT_IS_EMPTY,
Warn,
"traits and impls that have `.len()` but not `.is_empty()`" "traits and impls that have `.len()` but not `.is_empty()`"
} }

2
clippy_lints/src/let_if_seq.rs
View file

@ -45,7 +45,7 @@ use utils::{snippet, span_lint_and_then};
declare_lint! { declare_lint! {
pub USELESS_LET_IF_SEQ, pub USELESS_LET_IF_SEQ,
Warn, Warn,
"Checks for unidiomatic `let mut` declaration followed by initialization in `if`" "unidiomatic `let mut` declaration followed by initialization in `if`"
} }
#[derive(Copy,Clone)] #[derive(Copy,Clone)]

6
clippy_lints/src/loops.rs
View file

@ -145,7 +145,7 @@ declare_lint! {
declare_lint! { declare_lint! {
pub WHILE_LET_LOOP, pub WHILE_LET_LOOP,
Warn, Warn,
"`loop { if let { ... } else break }` can be written as a `while let` loop" "`loop { if let { ... } else break }`, which can be written as a `while let` loop"
} }
/// **What it does:** Checks for using `collect()` on an iterator without using /// **What it does:** Checks for using `collect()` on an iterator without using
@ -186,7 +186,7 @@ declare_lint! {
declare_lint! { declare_lint! {
pub REVERSE_RANGE_LOOP, pub REVERSE_RANGE_LOOP,
Warn, Warn,
"Iterating over an empty range, such as `10..0` or `5..5`" "iteration over an empty range, such as `10..0` or `5..5`"
} }
/// **What it does:** Checks `for` loops over slices with an explicit counter /// **What it does:** Checks `for` loops over slices with an explicit counter
@ -224,7 +224,7 @@ declare_lint! {
declare_lint! { declare_lint! {
pub EMPTY_LOOP, pub EMPTY_LOOP,
Warn, Warn,
"empty `loop {}` detected" "empty `loop {}`, which should block or sleep"
} }
/// **What it does:** Checks for `while let` expressions on iterators. /// **What it does:** Checks for `while let` expressions on iterators.

6
clippy_lints/src/map_clone.rs
View file

@ -16,9 +16,9 @@ use utils::{is_adjusted, match_path, match_trait_method, match_type, paths, snip
/// x.map(|e| e.clone()); /// x.map(|e| e.clone());
/// ``` /// ```
declare_lint! { declare_lint! {
pub MAP_CLONE, Warn, pub MAP_CLONE,
"using `.map(|x| x.clone())` to clone an iterator or option's contents (recommends \ Warn,
`.cloned()` instead)" "using `.map(|x| x.clone())` to clone an iterator or option's contents"
} }
#[derive(Copy, Clone)] #[derive(Copy, Clone)]

27
clippy_lints/src/matches.rs
View file

@ -27,9 +27,10 @@ use utils::sugg::Sugg;
/// } /// }
/// ``` /// ```
declare_lint! { declare_lint! {
pub SINGLE_MATCH, Warn, pub SINGLE_MATCH,
Warn,
"a match statement with a single nontrivial arm (i.e, where the other arm \ "a match statement with a single nontrivial arm (i.e, where the other arm \
is `_ => {}`) is used; recommends `if let` instead" is `_ => {}`) instead of `if let`"
} }
/// **What it does:** Checks for matches with a two arms where an `if let` will /// **What it does:** Checks for matches with a two arms where an `if let` will
@ -47,9 +48,10 @@ declare_lint! {
/// } /// }
/// ``` /// ```
declare_lint! { declare_lint! {
pub SINGLE_MATCH_ELSE, Allow, pub SINGLE_MATCH_ELSE,
"a match statement with a two arms where the second arm's pattern is a wildcard; \ Allow,
recommends `if let` instead" "a match statement with a two arms where the second arm's pattern is a wildcard \
instead of `if let`"
} }
/// **What it does:** Checks for matches where all arms match a reference, /// **What it does:** Checks for matches where all arms match a reference,
@ -70,9 +72,9 @@ declare_lint! {
/// } /// }
/// ``` /// ```
declare_lint! { declare_lint! {
pub MATCH_REF_PATS, Warn, pub MATCH_REF_PATS,
"a match or `if let` has all arms prefixed with `&`; the match expression can be \ Warn,
dereferenced instead" "a match or `if let` with all arms prefixed with `&` instead of deref-ing the match expression"
} }
/// **What it does:** Checks for matches where match expression is a `bool`. It /// **What it does:** Checks for matches where match expression is a `bool`. It
@ -91,8 +93,9 @@ declare_lint! {
/// } /// }
/// ``` /// ```
declare_lint! { declare_lint! {
pub MATCH_BOOL, Warn, pub MATCH_BOOL,
"a match on boolean expression; recommends `if..else` block instead" Warn,
"a match on a boolean expression instead of an `if..else` block"
} }
/// **What it does:** Checks for overlapping match arms. /// **What it does:** Checks for overlapping match arms.
@ -112,7 +115,9 @@ declare_lint! {
/// } /// }
/// ``` /// ```
declare_lint! { declare_lint! {
pub MATCH_OVERLAPPING_ARM, Warn, "a match has overlapping arms" pub MATCH_OVERLAPPING_ARM,
Warn,
"a match with overlapping arms"
} }
#[allow(missing_copy_implementations)] #[allow(missing_copy_implementations)]

2
clippy_lints/src/mem_forget.rs
View file

@ -16,7 +16,7 @@ use utils::{match_def_path, paths, span_lint};
declare_lint! { declare_lint! {
pub MEM_FORGET, pub MEM_FORGET,
Allow, Allow,
"`mem::forget` usage on `Drop` types is likely to cause memory leaks" "`mem::forget` usage on `Drop` types, likely to cause memory leaks"
} }
pub struct MemForget; pub struct MemForget;

59
clippy_lints/src/methods.rs
View file

@ -34,7 +34,8 @@ pub struct Pass;
/// x.unwrap() /// x.unwrap()
/// ``` /// ```
declare_lint! { declare_lint! {
pub OPTION_UNWRAP_USED, Allow, pub OPTION_UNWRAP_USED,
Allow,
"using `Option.unwrap()`, which should at least get a better message using `expect()`" "using `Option.unwrap()`, which should at least get a better message using `expect()`"
} }
@ -55,7 +56,8 @@ declare_lint! {
/// x.unwrap() /// x.unwrap()
/// ``` /// ```
declare_lint! { declare_lint! {
pub RESULT_UNWRAP_USED, Allow, pub RESULT_UNWRAP_USED,
Allow,
"using `Result.unwrap()`, which might be better handled" "using `Result.unwrap()`, which might be better handled"
} }
@ -79,7 +81,8 @@ declare_lint! {
/// } /// }
/// ``` /// ```
declare_lint! { declare_lint! {
pub SHOULD_IMPLEMENT_TRAIT, Warn, pub SHOULD_IMPLEMENT_TRAIT,
Warn,
"defining a method that should be implementing a std trait" "defining a method that should be implementing a std trait"
} }
@ -107,7 +110,8 @@ declare_lint! {
/// } /// }
/// ``` /// ```
declare_lint! { declare_lint! {
pub WRONG_SELF_CONVENTION, Warn, pub WRONG_SELF_CONVENTION,
Warn,
"defining a method named with an established prefix (like \"into_\") that takes \ "defining a method named with an established prefix (like \"into_\") that takes \
`self` with the wrong convention" `self` with the wrong convention"
} }
@ -128,7 +132,8 @@ declare_lint! {
/// } /// }
/// ``` /// ```
declare_lint! { declare_lint! {
pub WRONG_PUB_SELF_CONVENTION, Allow, pub WRONG_PUB_SELF_CONVENTION,
Allow,
"defining a public method named with an established prefix (like \"into_\") that takes \ "defining a public method named with an established prefix (like \"into_\") that takes \
`self` with the wrong convention" `self` with the wrong convention"
} }
@ -145,7 +150,8 @@ declare_lint! {
/// x.ok().expect("why did I do this again?") /// x.ok().expect("why did I do this again?")
/// ``` /// ```
declare_lint! { declare_lint! {
pub OK_EXPECT, Warn, pub OK_EXPECT,
Warn,
"using `ok().expect()`, which gives worse error messages than \ "using `ok().expect()`, which gives worse error messages than \
calling `expect` directly on the Result" calling `expect` directly on the Result"
} }
@ -162,7 +168,8 @@ declare_lint! {
/// x.map(|a| a + 1).unwrap_or(0) /// x.map(|a| a + 1).unwrap_or(0)
/// ``` /// ```
declare_lint! { declare_lint! {
pub OPTION_MAP_UNWRAP_OR, Warn, pub OPTION_MAP_UNWRAP_OR,
Warn,
"using `Option.map(f).unwrap_or(a)`, which is more succinctly expressed as \ "using `Option.map(f).unwrap_or(a)`, which is more succinctly expressed as \
`map_or(a, f)`" `map_or(a, f)`"
} }
@ -179,7 +186,8 @@ declare_lint! {
/// x.map(|a| a + 1).unwrap_or_else(some_function) /// x.map(|a| a + 1).unwrap_or_else(some_function)
/// ``` /// ```
declare_lint! { declare_lint! {
pub OPTION_MAP_UNWRAP_OR_ELSE, Warn, pub OPTION_MAP_UNWRAP_OR_ELSE,
Warn,
"using `Option.map(f).unwrap_or_else(g)`, which is more succinctly expressed as \ "using `Option.map(f).unwrap_or_else(g)`, which is more succinctly expressed as \
`map_or_else(g, f)`" `map_or_else(g, f)`"
} }
@ -196,7 +204,8 @@ declare_lint! {
/// iter.filter(|x| x == 0).next() /// iter.filter(|x| x == 0).next()
/// ``` /// ```
declare_lint! { declare_lint! {
pub FILTER_NEXT, Warn, pub FILTER_NEXT,
Warn,
"using `filter(p).next()`, which is more succinctly expressed as `.find(p)`" "using `filter(p).next()`, which is more succinctly expressed as `.find(p)`"
} }
@ -214,8 +223,10 @@ declare_lint! {
/// iter.filter(|x| x == 0).map(|x| x * 2) /// iter.filter(|x| x == 0).map(|x| x * 2)
/// ``` /// ```
declare_lint! { declare_lint! {
pub FILTER_MAP, Allow, pub FILTER_MAP,
"using combinations of `filter`, `map`, `filter_map` and `flat_map` which can usually be written as a single method call" Allow,
"using combinations of `filter`, `map`, `filter_map` and `flat_map` which can \
usually be written as a single method call"
} }
/// **What it does:** Checks for an iterator search (such as `find()`, /// **What it does:** Checks for an iterator search (such as `find()`,
@ -231,7 +242,8 @@ declare_lint! {
/// iter.find(|x| x == 0).is_some() /// iter.find(|x| x == 0).is_some()
/// ``` /// ```
declare_lint! { declare_lint! {
pub SEARCH_IS_SOME, Warn, pub SEARCH_IS_SOME,
Warn,
"using an iterator search followed by `is_some()`, which is more succinctly \ "using an iterator search followed by `is_some()`, which is more succinctly \
expressed as a call to `any()`" expressed as a call to `any()`"
} }
@ -249,7 +261,8 @@ declare_lint! {
/// name.chars().next() == Some('_') /// name.chars().next() == Some('_')
/// ``` /// ```
declare_lint! { declare_lint! {
pub CHARS_NEXT_CMP, Warn, pub CHARS_NEXT_CMP,
Warn,
"using `.chars().next()` to check if a string starts with a char" "using `.chars().next()` to check if a string starts with a char"
} }
@ -276,8 +289,9 @@ declare_lint! {
/// foo.unwrap_or_default() /// foo.unwrap_or_default()
/// ``` /// ```
declare_lint! { declare_lint! {
pub OR_FUN_CALL, Warn, pub OR_FUN_CALL,
"using any `*or` method when the `*or_else` would do" Warn,
"using any `*or` method with a function call, which suggests `*or_else`"
} }
/// **What it does:** Checks for usage of `.extend(s)` on a `Vec` to extend the /// **What it does:** Checks for usage of `.extend(s)` on a `Vec` to extend the
@ -293,7 +307,8 @@ declare_lint! {
/// my_vec.extend(&xs) /// my_vec.extend(&xs)
/// ``` /// ```
declare_lint! { declare_lint! {
pub EXTEND_FROM_SLICE, Warn, pub EXTEND_FROM_SLICE,
Warn,
"`.extend_from_slice(_)` is a faster way to extend a Vec by a slice" "`.extend_from_slice(_)` is a faster way to extend a Vec by a slice"
} }
@ -309,7 +324,9 @@ declare_lint! {
/// 42u64.clone() /// 42u64.clone()
/// ``` /// ```
declare_lint! { declare_lint! {
pub CLONE_ON_COPY, Warn, "using `clone` on a `Copy` type" pub CLONE_ON_COPY,
Warn,
"using `clone` on a `Copy` type"
} }
/// **What it does:** Checks for usage of `.clone()` on an `&&T`. /// **What it does:** Checks for usage of `.clone()` on an `&&T`.
@ -329,7 +346,9 @@ declare_lint! {
/// } /// }
/// ``` /// ```
declare_lint! { declare_lint! {
pub CLONE_DOUBLE_REF, Warn, "using `clone` on `&&T`" pub CLONE_DOUBLE_REF,
Warn,
"using `clone` on `&&T`"
} }
/// **What it does:** Checks for `new` not returning `Self`. /// **What it does:** Checks for `new` not returning `Self`.
@ -347,7 +366,9 @@ declare_lint! {
/// } /// }
/// ``` /// ```
declare_lint! { declare_lint! {
pub NEW_RET_NO_SELF, Warn, "not returning `Self` in a `new` method" pub NEW_RET_NO_SELF,
Warn,
"not returning `Self` in a `new` method"
} }
/// **What it does:** Checks for string methods that receive a single-character /// **What it does:** Checks for string methods that receive a single-character

3
clippy_lints/src/minmax.rs
View file

@ -20,7 +20,8 @@ use utils::{match_def_path, paths, span_lint};
/// It will always be equal to `0`. Probably the author meant to clamp the value /// It will always be equal to `0`. Probably the author meant to clamp the value
/// between 0 and 100, but has erroneously swapped `min` and `max`. /// between 0 and 100, but has erroneously swapped `min` and `max`.
declare_lint! { declare_lint! {
pub MIN_MAX, Warn, pub MIN_MAX,
Warn,
"`min(_, max(_, _))` (or vice versa) with bounds clamping the result to a constant" "`min(_, max(_, _))` (or vice versa) with bounds clamping the result to a constant"
} }

49
clippy_lints/src/misc.rs
View file

@ -35,10 +35,9 @@ use utils::sugg::Sugg;
/// fn foo(ref x: u8) -> bool { .. } /// fn foo(ref x: u8) -> bool { .. }
/// ``` /// ```
declare_lint! { declare_lint! {
pub TOPLEVEL_REF_ARG, Warn, pub TOPLEVEL_REF_ARG,
"An entire binding was declared as `ref`, in a function argument (`fn foo(ref x: Bar)`), \ Warn,
or a `let` statement (`let ref x = foo()`). In such cases, it is preferred to take \ "an entire binding declared as `ref`, in a function argument or a `let` statement"
references with `&`."
} }
#[allow(missing_copy_implementations)] #[allow(missing_copy_implementations)]
@ -111,8 +110,11 @@ impl LateLintPass for TopLevelRefPass {
/// ```rust /// ```rust
/// x == NAN /// x == NAN
/// ``` /// ```
declare_lint!(pub CMP_NAN, Deny, declare_lint! {
"comparisons to NAN (which will always return false, which is probably not intended)"); pub CMP_NAN,
Deny,
"comparisons to NAN, which will always return false, probably not intended"
}
#[derive(Copy,Clone)] #[derive(Copy,Clone)]
pub struct CmpNan; pub struct CmpNan;
@ -165,10 +167,11 @@ fn check_nan(cx: &LateContext, path: &Path, span: Span) {
/// y == 1.23f64 /// y == 1.23f64
/// y != x // where both are floats /// y != x // where both are floats
/// ``` /// ```
declare_lint!(pub FLOAT_CMP, Warn, declare_lint! {
"using `==` or `!=` on float values (as floating-point operations \ pub FLOAT_CMP,
usually involve rounding errors, it is always better to check for approximate \ Warn,
equality within small bounds)"); "using `==` or `!=` on float values instead of comparing difference with an epsilon"
}
#[derive(Copy,Clone)] #[derive(Copy,Clone)]
pub struct FloatCmp; pub struct FloatCmp;
@ -257,8 +260,11 @@ fn is_float(cx: &LateContext, expr: &Expr) -> bool {
/// ```rust /// ```rust
/// x.to_owned() == y /// x.to_owned() == y
/// ``` /// ```
declare_lint!(pub CMP_OWNED, Warn, declare_lint! {
"creating owned instances for comparing with others, e.g. `x == \"foo\".to_string()`"); pub CMP_OWNED,
Warn,
"creating owned instances for comparing with others, e.g. `x == \"foo\".to_string()`"
}
#[derive(Copy,Clone)] #[derive(Copy,Clone)]
pub struct CmpOwned; pub struct CmpOwned;
@ -353,7 +359,11 @@ fn is_str_arg(cx: &LateContext, args: &[P<Expr>]) -> bool {
/// ```rust /// ```rust
/// x % 1 /// x % 1
/// ``` /// ```
declare_lint!(pub MODULO_ONE, Warn, "taking a number modulo 1, which always returns 0"); declare_lint! {
pub MODULO_ONE,
Warn,
"taking a number modulo 1, which always returns 0"
}
#[derive(Copy,Clone)] #[derive(Copy,Clone)]
pub struct ModuloOne; pub struct ModuloOne;
@ -389,7 +399,11 @@ impl LateLintPass for ModuloOne {
/// y @ _ => (), // easier written as `y`, /// y @ _ => (), // easier written as `y`,
/// } /// }
/// ``` /// ```
declare_lint!(pub REDUNDANT_PATTERN, Warn, "using `name @ _` in a pattern"); declare_lint! {
pub REDUNDANT_PATTERN,
Warn,
"using `name @ _` in a pattern"
}
#[derive(Copy,Clone)] #[derive(Copy,Clone)]
pub struct PatternPass; pub struct PatternPass;
@ -431,8 +445,11 @@ impl LateLintPass for PatternPass {
/// let y = _x + 1; // Here we are using `_x`, even though it has a leading underscore. /// let y = _x + 1; // Here we are using `_x`, even though it has a leading underscore.
/// // We should rename `_x` to `x` /// // We should rename `_x` to `x`
/// ``` /// ```
declare_lint!(pub USED_UNDERSCORE_BINDING, Allow, declare_lint! {
"using a binding which is prefixed with an underscore"); pub USED_UNDERSCORE_BINDING,
Allow,
"using a binding which is prefixed with an underscore"
}
#[derive(Copy, Clone)] #[derive(Copy, Clone)]
pub struct UsedUnderscoreBinding; pub struct UsedUnderscoreBinding;

30
clippy_lints/src/misc_early.rs
View file

@ -18,8 +18,9 @@ use utils::{span_lint, span_help_and_lint, snippet, snippet_opt, span_lint_and_t
/// let { a: _, b: ref b, c: _ } = .. /// let { a: _, b: ref b, c: _ } = ..
/// ``` /// ```
declare_lint! { declare_lint! {
pub UNNEEDED_FIELD_PATTERN, Warn, pub UNNEEDED_FIELD_PATTERN,
"Struct fields are bound to a wildcard instead of using `..`" Warn,
"struct fields bound to a wildcard instead of using `..`"
} }
/// **What it does:** Checks for function arguments having the similar names /// **What it does:** Checks for function arguments having the similar names
@ -34,8 +35,9 @@ declare_lint! {
/// fn foo(a: i32, _a: i32) {} /// fn foo(a: i32, _a: i32) {}
/// ``` /// ```
declare_lint! { declare_lint! {
pub DUPLICATE_UNDERSCORE_ARGUMENT, Warn, pub DUPLICATE_UNDERSCORE_ARGUMENT,
"Function arguments having names which only differ by an underscore" Warn,
"function arguments having names which only differ by an underscore"
} }
/// **What it does:** Detects closures called in the same expression where they are defined. /// **What it does:** Detects closures called in the same expression where they are defined.
@ -49,8 +51,9 @@ declare_lint! {
/// (|| 42)() /// (|| 42)()
/// ``` /// ```
declare_lint! { declare_lint! {
pub REDUNDANT_CLOSURE_CALL, Warn, pub REDUNDANT_CLOSURE_CALL,
"Closures should not be called in the expression they are defined" Warn,
"throwaway closures called in the expression they are defined"
} }
/// **What it does:** Detects expressions of the form `--x`. /// **What it does:** Detects expressions of the form `--x`.
@ -65,8 +68,9 @@ declare_lint! {
/// --x; /// --x;
/// ``` /// ```
declare_lint! { declare_lint! {
pub DOUBLE_NEG, Warn, pub DOUBLE_NEG,
"`--x` is a double negation of `x` and not a pre-decrement as in C or C++" Warn,
"`--x`, which is a double negation of `x` and not a pre-decrement as in C/C++"
} }
/// **What it does:** Warns on hexadecimal literals with mixed-case letter digits. /// **What it does:** Warns on hexadecimal literals with mixed-case letter digits.
@ -80,8 +84,9 @@ declare_lint! {
/// let y = 0x1a9BAcD; /// let y = 0x1a9BAcD;
/// ``` /// ```
declare_lint! { declare_lint! {
pub MIXED_CASE_HEX_LITERALS, Warn, pub MIXED_CASE_HEX_LITERALS,
"letter digits in hex literals should be either completely upper- or lowercased" Warn,
"hex literals whose letter digits are not consistently upper- or lowercased"
} }
/// **What it does:** Warns if literal suffixes are not separated by an underscore. /// **What it does:** Warns if literal suffixes are not separated by an underscore.
@ -95,8 +100,9 @@ declare_lint! {
/// let y = 123832i32; /// let y = 123832i32;
/// ``` /// ```
declare_lint! { declare_lint! {
pub UNSEPARATED_LITERAL_SUFFIX, Allow, pub UNSEPARATED_LITERAL_SUFFIX,
"literal suffixes should be separated with an underscore" Allow,
"literals whose suffix is not separated by an underscore"
} }

2
clippy_lints/src/mut_reference.rs
View file

@ -19,7 +19,7 @@ use utils::span_lint;
declare_lint! { declare_lint! {
pub UNNECESSARY_MUT_PASSED, pub UNNECESSARY_MUT_PASSED,
Warn, Warn,
"an argument is passed as a mutable reference although the function/method only demands an \ "an argument passed as a mutable reference although the callee only demands an \
immutable reference" immutable reference"
} }

3
clippy_lints/src/needless_bool.rs
View file

@ -44,8 +44,7 @@ declare_lint! {
declare_lint! { declare_lint! {
pub BOOL_COMPARISON, pub BOOL_COMPARISON,
Warn, Warn,
"comparing a variable to a boolean, e.g. \ "comparing a variable to a boolean, e.g. `if x == true`"
`if x == true`"
} }
#[derive(Copy,Clone)] #[derive(Copy,Clone)]

2
clippy_lints/src/neg_multiply.rs
View file

@ -18,7 +18,7 @@ use utils::span_lint;
declare_lint! { declare_lint! {
pub NEG_MULTIPLY, pub NEG_MULTIPLY,
Warn, Warn,
"Warns on multiplying integers with -1" "multiplying integers with -1"
} }
#[derive(Copy, Clone)] #[derive(Copy, Clone)]

7
clippy_lints/src/overflow_check_conditional.rs
View file

@ -14,8 +14,11 @@ use utils::span_lint;
/// a + b < a /// a + b < a
/// ``` /// ```
declare_lint!(pub OVERFLOW_CHECK_CONDITIONAL, Warn, declare_lint! {
"Using overflow checks which are likely to panic"); pub OVERFLOW_CHECK_CONDITIONAL,
Warn,
"overflow checks inspired by C which are likely to panic"
}
#[derive(Copy, Clone)] #[derive(Copy, Clone)]
pub struct OverflowCheckConditional; pub struct OverflowCheckConditional;

4
clippy_lints/src/panic.rs
View file

@ -18,7 +18,9 @@ use utils::{is_direct_expn_of, match_path, paths, span_lint};
/// panic!("This `panic!` is probably missing a parameter there: {}"); /// panic!("This `panic!` is probably missing a parameter there: {}");
/// ``` /// ```
declare_lint! { declare_lint! {
pub PANIC_PARAMS, Warn, "missing parameters in `panic!`" pub PANIC_PARAMS,
Warn,
"missing parameters in `panic!` calls"
} }
#[allow(missing_copy_implementations)] #[allow(missing_copy_implementations)]

5
clippy_lints/src/precedence.rs
View file

@ -19,8 +19,9 @@ use utils::{span_lint, snippet};
/// * `1 << 2 + 3` equals 32, while `(1 << 2) + 3` equals 7 /// * `1 << 2 + 3` equals 32, while `(1 << 2) + 3` equals 7
/// * `-1i32.abs()` equals -1, while `(-1i32).abs()` equals 1 /// * `-1i32.abs()` equals -1, while `(-1i32).abs()` equals 1
declare_lint! { declare_lint! {
pub PRECEDENCE, Warn, pub PRECEDENCE,
"catches operations where precedence may be unclear" Warn,
"operations where precedence may be unclear"
} }
#[derive(Copy,Clone)] #[derive(Copy,Clone)]

2
clippy_lints/src/print.rs
View file

@ -35,7 +35,7 @@ declare_lint! {
declare_lint! { declare_lint! {
pub USE_DEBUG, pub USE_DEBUG,
Allow, Allow,
"use `Debug`-based formatting" "use of `Debug`-based formatting"
} }
#[derive(Copy, Clone, Debug)] #[derive(Copy, Clone, Debug)]

3
clippy_lints/src/ptr_arg.rs
View file

@ -23,8 +23,7 @@ use utils::{match_type, paths, span_lint};
declare_lint! { declare_lint! {
pub PTR_ARG, pub PTR_ARG,
Warn, Warn,
"fn arguments of the type `&Vec<...>` or `&String`, suggesting to use `&[...]` or `&str` \ "arguments of the type `&Vec<...>` (instead of `&[...]`) or `&String` (instead of `&str`)"
instead, respectively"
} }
#[derive(Copy,Clone)] #[derive(Copy,Clone)]

10
clippy_lints/src/ranges.rs
View file

@ -17,8 +17,9 @@ use utils::higher;
/// for x in (5..5).step_by(0) { .. } /// for x in (5..5).step_by(0) { .. }
/// ``` /// ```
declare_lint! { declare_lint! {
pub RANGE_STEP_BY_ZERO, Warn, pub RANGE_STEP_BY_ZERO,
"using Range::step_by(0), which produces an infinite iterator" Warn,
"using `Range::step_by(0)`, which produces an infinite iterator"
} }
/// **What it does:** Checks for zipping a collection with the range of `0.._.len()`. /// **What it does:** Checks for zipping a collection with the range of `0.._.len()`.
/// ///
@ -31,8 +32,9 @@ declare_lint! {
/// x.iter().zip(0..x.len()) /// x.iter().zip(0..x.len())
/// ``` /// ```
declare_lint! { declare_lint! {
pub RANGE_ZIP_WITH_LEN, Warn, pub RANGE_ZIP_WITH_LEN,
"zipping iterator with a range when enumerate() would do" Warn,
"zipping iterator with a range when `enumerate()` would do"
} }
#[derive(Copy,Clone)] #[derive(Copy,Clone)]

6
clippy_lints/src/regex.rs
View file

@ -27,7 +27,7 @@ use utils::{is_expn_of, match_def_path, match_type, paths, span_lint, span_help_
declare_lint! { declare_lint! {
pub INVALID_REGEX, pub INVALID_REGEX,
Deny, Deny,
"finds invalid regular expressions" "invalid regular expressions"
} }
/// **What it does:** Checks for trivial [regex] creation (with `Regex::new`, /// **What it does:** Checks for trivial [regex] creation (with `Regex::new`,
@ -48,7 +48,7 @@ declare_lint! {
declare_lint! { declare_lint! {
pub TRIVIAL_REGEX, pub TRIVIAL_REGEX,
Warn, Warn,
"finds trivial regular expressions" "trivial regular expressions"
} }
/// **What it does:** Checks for usage of `regex!(_)` which (as of now) is /// **What it does:** Checks for usage of `regex!(_)` which (as of now) is
@ -67,7 +67,7 @@ declare_lint! {
declare_lint! { declare_lint! {
pub REGEX_MACRO, pub REGEX_MACRO,
Warn, Warn,
"finds use of `regex!(_)`, suggests `Regex::new(_)` instead" "use of `regex!(_)` instead of `Regex::new(_)`"
} }
#[derive(Clone, Default)] #[derive(Clone, Default)]

6
clippy_lints/src/returns.rs
View file

@ -20,7 +20,8 @@ use utils::{span_note_and_lint, span_lint_and_then, snippet_opt, match_path_ast,
/// fn foo(x: usize) { return x; } /// fn foo(x: usize) { return x; }
/// ``` /// ```
declare_lint! { declare_lint! {
pub NEEDLESS_RETURN, Warn, pub NEEDLESS_RETURN,
Warn,
"using a return statement like `return expr;` where an expression would suffice" "using a return statement like `return expr;` where an expression would suffice"
} }
@ -39,7 +40,8 @@ declare_lint! {
/// { let x = ..; x } /// { let x = ..; x }
/// ``` /// ```
declare_lint! { declare_lint! {
pub LET_AND_RETURN, Warn, pub LET_AND_RETURN,
Warn,
"creating a let-binding and then immediately returning it like `let x = expr; x` at \ "creating a let-binding and then immediately returning it like `let x = expr; x` at \
the end of a block" the end of a block"
} }

5
clippy_lints/src/serde.rs
View file

@ -11,8 +11,9 @@ use utils::{span_lint, get_trait_def_id, paths};
/// ///
/// **Example:** Implementing `Visitor::visit_string` but not `Visitor::visit_str`. /// **Example:** Implementing `Visitor::visit_string` but not `Visitor::visit_str`.
declare_lint! { declare_lint! {
pub SERDE_API_MISUSE, Warn, pub SERDE_API_MISUSE,
"Various things that will negatively affect your serde experience" Warn,
"various things that will negatively affect your serde experience"
} }

13
clippy_lints/src/shadow.rs
View file

@ -22,7 +22,8 @@ use utils::{higher, in_external_macro, snippet, span_lint_and_then};
/// let x = &x; /// let x = &x;
/// ``` /// ```
declare_lint! { declare_lint! {
pub SHADOW_SAME, Allow, pub SHADOW_SAME,
Allow,
"rebinding a name to itself, e.g. `let mut x = &mut x`" "rebinding a name to itself, e.g. `let mut x = &mut x`"
} }
@ -42,9 +43,10 @@ declare_lint! {
/// let x = x + 1; /// let x = x + 1;
/// ``` /// ```
declare_lint! { declare_lint! {
pub SHADOW_REUSE, Allow, pub SHADOW_REUSE,
Allow,
"rebinding a name to an expression that re-uses the original value, e.g. \ "rebinding a name to an expression that re-uses the original value, e.g. \
`let x = x + 1`" `let x = x + 1`"
} }
/// **What it does:** Checks for bindings that shadow other bindings already in /// **What it does:** Checks for bindings that shadow other bindings already in
@ -64,8 +66,9 @@ declare_lint! {
/// let x = y; let x = z; // shadows the earlier binding /// let x = y; let x = z; // shadows the earlier binding
/// ``` /// ```
declare_lint! { declare_lint! {
pub SHADOW_UNRELATED, Allow, pub SHADOW_UNRELATED,
"The name is re-bound without even using the original value" Allow,
"rebinding a name without even using the original value"
} }
#[derive(Copy, Clone)] #[derive(Copy, Clone)]

6
clippy_lints/src/strings.rs
View file

@ -21,7 +21,7 @@ use utils::{match_type, paths, span_lint, span_lint_and_then, walk_ptrs_ty, get_
declare_lint! { declare_lint! {
pub STRING_ADD_ASSIGN, pub STRING_ADD_ASSIGN,
Allow, Allow,
"using `x = x + ..` where x is a `String`; suggests using `push_str()` instead" "using `x = x + ..` where x is a `String` instead of `push_str()`"
} }
/// **What it does:** Checks for all instances of `x + _` where `x` is of type /// **What it does:** Checks for all instances of `x + _` where `x` is of type
@ -49,7 +49,7 @@ declare_lint! {
declare_lint! { declare_lint! {
pub STRING_ADD, pub STRING_ADD,
Allow, Allow,
"using `x + ..` where x is a `String`; suggests using `push_str()` instead" "using `x + ..` where x is a `String` instead of `push_str()`"
} }
/// **What it does:** Checks for the `as_bytes` method called on string literals /// **What it does:** Checks for the `as_bytes` method called on string literals
@ -67,7 +67,7 @@ declare_lint! {
declare_lint! { declare_lint! {
pub STRING_LIT_AS_BYTES, pub STRING_LIT_AS_BYTES,
Warn, Warn,
"calling `as_bytes` on a string literal; suggests using a byte string literal instead" "calling `as_bytes` on a string literal instead of using a byte string literal"
} }
#[derive(Copy, Clone)] #[derive(Copy, Clone)]

2
clippy_lints/src/swap.rs
View file

@ -21,7 +21,7 @@ use utils::sugg::Sugg;
declare_lint! { declare_lint! {
pub MANUAL_SWAP, pub MANUAL_SWAP,
Warn, Warn,
"manual swap" "manual swap of two variables"
} }
/// **What it does:** Checks for `foo = bar; bar = foo` sequences. /// **What it does:** Checks for `foo = bar; bar = foo` sequences.

51
clippy_lints/src/types.rs
View file

@ -29,7 +29,8 @@ pub struct TypePass;
/// } /// }
/// ``` /// ```
declare_lint! { declare_lint! {
pub BOX_VEC, Warn, pub BOX_VEC,
Warn,
"usage of `Box<Vec<T>>`, vector elements are already on the heap" "usage of `Box<Vec<T>>`, vector elements are already on the heap"
} }
@ -56,7 +57,8 @@ declare_lint! {
/// let x = LinkedList::new(); /// let x = LinkedList::new();
/// ``` /// ```
declare_lint! { declare_lint! {
pub LINKEDLIST, Warn, pub LINKEDLIST,
Warn,
"usage of LinkedList, usually a vector is faster, or a more specialized data \ "usage of LinkedList, usually a vector is faster, or a more specialized data \
structure like a VecDeque" structure like a VecDeque"
} }
@ -117,7 +119,8 @@ pub struct LetPass;
/// let x = { 1; }; /// let x = { 1; };
/// ``` /// ```
declare_lint! { declare_lint! {
pub LET_UNIT_VALUE, Warn, pub LET_UNIT_VALUE,
Warn,
"creating a let binding to a value of unit type, which usually can't be used afterwards" "creating a let binding to a value of unit type, which usually can't be used afterwards"
} }
@ -169,8 +172,9 @@ impl LateLintPass for LetPass {
/// { foo(); bar(); baz(); } /// { foo(); bar(); baz(); }
/// ``` /// ```
declare_lint! { declare_lint! {
pub UNIT_CMP, Warn, pub UNIT_CMP,
"comparing unit values (which is always `true` or `false`, respectively)" Warn,
"comparing unit values"
} }
#[allow(missing_copy_implementations)] #[allow(missing_copy_implementations)]
@ -227,7 +231,8 @@ pub struct CastPass;
/// let x = u64::MAX; x as f64 /// let x = u64::MAX; x as f64
/// ``` /// ```
declare_lint! { declare_lint! {
pub CAST_PRECISION_LOSS, Allow, pub CAST_PRECISION_LOSS,
Allow,
"casts that cause loss of precision, e.g `x as f32` where `x: u64`" "casts that cause loss of precision, e.g `x as f32` where `x: u64`"
} }
@ -247,7 +252,8 @@ declare_lint! {
/// y as u64 // will return 18446744073709551615 /// y as u64 // will return 18446744073709551615
/// ``` /// ```
declare_lint! { declare_lint! {
pub CAST_SIGN_LOSS, Allow, pub CAST_SIGN_LOSS,
Allow,
"casts from signed types to unsigned types, e.g `x as u32` where `x: i32`" "casts from signed types to unsigned types, e.g `x as u32` where `x: i32`"
} }
@ -266,8 +272,10 @@ declare_lint! {
/// fn as_u8(x: u64) -> u8 { x as u8 } /// fn as_u8(x: u64) -> u8 { x as u8 }
/// ``` /// ```
declare_lint! { declare_lint! {
pub CAST_POSSIBLE_TRUNCATION, Allow, pub CAST_POSSIBLE_TRUNCATION,
"casts that may cause truncation of the value, e.g `x as u8` where `x: u32`, or `x as i32` where `x: f32`" Allow,
"casts that may cause truncation of the value, e.g `x as u8` where `x: u32`, \
or `x as i32` where `x: f32`"
} }
/// **What it does:** Checks for casts from an unsigned type to a signed type of /// **What it does:** Checks for casts from an unsigned type to a signed type of
@ -288,8 +296,10 @@ declare_lint! {
/// u32::MAX as i32 // will yield a value of `-1` /// u32::MAX as i32 // will yield a value of `-1`
/// ``` /// ```
declare_lint! { declare_lint! {
pub CAST_POSSIBLE_WRAP, Allow, pub CAST_POSSIBLE_WRAP,
"casts that may cause wrapping around the value, e.g `x as i32` where `x: u32` and `x > i32::MAX`" Allow,
"casts that may cause wrapping around the value, e.g `x as i32` where `x: u32` \
and `x > i32::MAX`"
} }
/// Returns the size in bits of an integral type. /// Returns the size in bits of an integral type.
@ -494,8 +504,9 @@ impl LateLintPass for CastPass {
/// struct Foo { inner: Rc<Vec<Vec<Box<(u32, u32, u32, u32)>>>> } /// struct Foo { inner: Rc<Vec<Vec<Box<(u32, u32, u32, u32)>>>> }
/// ``` /// ```
declare_lint! { declare_lint! {
pub TYPE_COMPLEXITY, Warn, pub TYPE_COMPLEXITY,
"usage of very complex types; recommends factoring out parts into `type` definitions" Warn,
"usage of very complex types that might be better factored into `type` definitions"
} }
#[allow(missing_copy_implementations)] #[allow(missing_copy_implementations)]
@ -644,8 +655,9 @@ impl<'v> Visitor<'v> for TypeComplexityVisitor {
/// 'x' as u8 /// 'x' as u8
/// ``` /// ```
declare_lint! { declare_lint! {
pub CHAR_LIT_AS_U8, Warn, pub CHAR_LIT_AS_U8,
"Casting a character literal to u8" Warn,
"casting a character literal to u8"
} }
pub struct CharLitAsU8; pub struct CharLitAsU8;
@ -695,9 +707,9 @@ impl LateLintPass for CharLitAsU8 {
/// 100 > std::i32::MAX /// 100 > std::i32::MAX
/// ``` /// ```
declare_lint! { declare_lint! {
pub ABSURD_EXTREME_COMPARISONS, Warn, pub ABSURD_EXTREME_COMPARISONS,
"a comparison involving a maximum or minimum value involves a case that is always \ Warn,
true or always false" "a comparison with a maximum or minimum value that is always true or false"
} }
pub struct AbsurdExtremeComparisons; pub struct AbsurdExtremeComparisons;
@ -872,7 +884,8 @@ impl LateLintPass for AbsurdExtremeComparisons {
/// let x : u8 = ...; (x as u32) > 300 /// let x : u8 = ...; (x as u32) > 300
/// ``` /// ```
declare_lint! { declare_lint! {
pub INVALID_UPCAST_COMPARISONS, Allow, pub INVALID_UPCAST_COMPARISONS,
Allow,
"a comparison involving an upcast which is always true or false" "a comparison involving an upcast which is always true or false"
} }

13
clippy_lints/src/unicode.rs
View file

@ -14,7 +14,8 @@ use utils::{snippet, span_help_and_lint};
/// ///
/// **Example:** You don't see it, but there may be a zero-width space somewhere in this text. /// **Example:** You don't see it, but there may be a zero-width space somewhere in this text.
declare_lint! { declare_lint! {
pub ZERO_WIDTH_SPACE, Deny, pub ZERO_WIDTH_SPACE,
Deny,
"using a zero-width space in a string literal, which is confusing" "using a zero-width space in a string literal, which is confusing"
} }
@ -33,9 +34,10 @@ declare_lint! {
/// let x = "Hä?" /// let x = "Hä?"
/// ``` /// ```
declare_lint! { declare_lint! {
pub NON_ASCII_LITERAL, Allow, pub NON_ASCII_LITERAL,
"using any literal non-ASCII chars in a string literal; suggests \ Allow,
using the `\\u` escape instead" "using any literal non-ASCII chars in a string literal instead of \
using the `\\u` escape"
} }
/// **What it does:** Checks for string literals that contain Unicode in a form /// **What it does:** Checks for string literals that contain Unicode in a form
@ -50,7 +52,8 @@ declare_lint! {
/// **Example:** You may not see it, but “à” and “à” aren't the same string. The /// **Example:** You may not see it, but “à” and “à” aren't the same string. The
/// former when escaped is actually `"a\u{300}"` while the latter is `"\u{e0}"`. /// former when escaped is actually `"a\u{300}"` while the latter is `"\u{e0}"`.
declare_lint! { declare_lint! {
pub UNICODE_NOT_NFC, Allow, pub UNICODE_NOT_NFC,
Allow,
"using a unicode literal not in NFC normal form (see \ "using a unicode literal not in NFC normal form (see \
[unicode tr15](http://www.unicode.org/reports/tr15/) for further information)" [unicode tr15](http://www.unicode.org/reports/tr15/) for further information)"
} }

2
clippy_lints/src/unsafe_removed_from_name.rs
View file

@ -23,7 +23,7 @@ use utils::span_lint;
declare_lint! { declare_lint! {
pub UNSAFE_REMOVED_FROM_NAME, pub UNSAFE_REMOVED_FROM_NAME,
Warn, Warn,
"unsafe removed from name" "`unsafe` removed from API names on import"
} }
pub struct UnsafeNameRemoval; pub struct UnsafeNameRemoval;

2
clippy_lints/src/unused_label.rs
View file

@ -24,7 +24,7 @@ use utils::{in_macro, span_lint};
declare_lint! { declare_lint! {
pub UNUSED_LABEL, pub UNUSED_LABEL,
Warn, Warn,
"unused label" "unused labels"
} }
pub struct UnusedLabel; pub struct UnusedLabel;

5
clippy_lints/src/utils/internal_lints.rs
View file

@ -11,8 +11,9 @@ use syntax::ast::*;
/// ///
/// **Example:** Wrong ordering of the util::paths constants. /// **Example:** Wrong ordering of the util::paths constants.
declare_lint! { declare_lint! {
pub CLIPPY_LINTS_INTERNAL, Allow, pub CLIPPY_LINTS_INTERNAL,
"Various things that will negatively affect your clippy experience" Allow,
"various things that will negatively affect your clippy experience"
} }

2
util/update_lints.py
View file

@ -72,7 +72,7 @@ def gen_table(lints, link=None):
w_name = max(len(l[1]) for l in lints) w_name = max(len(l[1]) for l in lints)
w_desc = max(len(l[3]) for l in lints) w_desc = max(len(l[3]) for l in lints)
# header and underline # header and underline
yield '%-*s | default | meaning\n' % (w_name, 'name') yield '%-*s | default | triggers on\n' % (w_name, 'name')
yield '%s-|-%s-|-%s\n' % ('-' * w_name, '-' * 7, '-' * w_desc) yield '%s-|-%s-|-%s\n' % ('-' * w_name, '-' * 7, '-' * w_desc)
# one table row per lint # one table row per lint
for (_, name, default, meaning) in sorted(lints, key=lambda l: l[1]): for (_, name, default, meaning) in sorted(lints, key=lambda l: l[1]):