squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Fix util/update_wiki.py warnings and be consistent in declare_lint! invocations

Browse source
This commit is contained in:
mcarton 2016-02-06 00:13:29 +01:00
parent 0494071ab7
commit 13f245f6c9
25 changed files with 341 additions and 166 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
src/attrs.rs
View file

@ -22,8 +22,10 @@ use utils::{in_macro, match_path, span_lint, BEGIN_UNWIND};
/// #[inline(always)]
/// fn not_quite_hot_code(..) { ... }
/// ```
declare_lint! { pub INLINE_ALWAYS, Warn,
"`#[inline(always)]` is a bad idea in most cases" }
declare_lint! {
pub INLINE_ALWAYS, Warn,
"`#[inline(always)]` is a bad idea in most cases"
}
/// **What it does:** This lint `Warn`s on `#[deprecated]` annotations with a `since` field that is not a valid semantic version..
///
@ -36,8 +38,10 @@ declare_lint! { pub INLINE_ALWAYS, Warn,
/// #[deprecated(since = "forever")]
/// fn something_else(..) { ... }
/// ```
declare_lint! { pub DEPRECATED_SEMVER, Warn,
"`Warn` on `#[deprecated(since = \"x\")]` where x is not semver" }
declare_lint! {
pub DEPRECATED_SEMVER, Warn,
"`Warn` on `#[deprecated(since = \"x\")]` where x is not semver"
}
#[derive(Copy,Clone)]
pub struct AttrPass;

6
src/cyclomatic_complexity.rs
View file

@ -18,8 +18,10 @@ use utils::{in_macro, LimitStack, span_help_and_lint};
/// **Known problems:** Sometimes it's hard to find a way to reduce the complexity
///
/// **Example:** No. You'll see it when you get the warning.
declare_lint! { pub CYCLOMATIC_COMPLEXITY, Warn,
"finds functions that should be split up into multiple functions" }
declare_lint! {
pub CYCLOMATIC_COMPLEXITY, Warn,
"finds functions that should be split up into multiple functions"
}
pub struct CyclomaticComplexity {
limit: LimitStack,

6
src/drop_ref.rs
View file

@ -18,9 +18,11 @@ use utils::{match_def_path, span_note_and_lint};
/// std::mem::drop(&lock_guard) //Should have been drop(lock_guard), mutex still locked
/// operation_that_requires_mutex_to_be_unlocked();
/// ```
declare_lint!(pub DROP_REF, Warn,
declare_lint! {
pub 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");
which will not call the `Drop::drop` method on the underlying value"
}
#[allow(missing_copy_implementations)]
pub struct DropRefPass;

6
src/enum_variants.rs
View file

@ -14,8 +14,10 @@ use utils::span_help_and_lint;
/// **Known problems:** None
///
/// **Example:** enum Cake { BlackForestCake, HummingbirdCake }
declare_lint! { pub ENUM_VARIANT_NAMES, Warn,
"finds enums where all variants share a prefix/postfix" }
declare_lint! {
pub ENUM_VARIANT_NAMES, Warn,
"finds enums where all variants share a prefix/postfix"
}
pub struct EnumVariantNames;

4
src/escape.rs
View file

@ -29,7 +29,9 @@ pub struct EscapePass;
/// println!("{}", *x);
/// }
/// ```
declare_lint!(pub BOXED_LOCAL, Warn, "using Box<T> where unnecessary");
declare_lint! {
pub BOXED_LOCAL, Warn, "using Box<T> where unnecessary"
}
fn is_non_trait_box(ty: ty::Ty) -> bool {
match ty.sty {

6
src/eta_reduction.rs
View file

@ -16,8 +16,10 @@ pub struct EtaPass;
/// **Known problems:** None
///
/// **Example:** `xs.map(|x| foo(x))` where `foo(_)` is a plain function that takes the exact argument type of `x`.
declare_lint!(pub REDUNDANT_CLOSURE, Warn,
"using redundant closures, i.e. `|a| foo(a)` (which can be written as just `foo`)");
declare_lint! {
pub REDUNDANT_CLOSURE, Warn,
"using redundant closures, i.e. `|a| foo(a)` (which can be written as just `foo`)"
}
impl LintPass for EtaPass {
fn get_lints(&self) -> LintArray {

6
src/identity_op.rs
View file

@ -12,8 +12,10 @@ use utils::{span_lint, snippet, in_macro};
/// **Known problems:** None
///
/// **Example:** `x / 1 + 0 * 1 - 0 | 0`
declare_lint! { pub IDENTITY_OP, Warn,
"using identity operations, e.g. `x + 0` or `y / 1`" }
declare_lint! {
pub IDENTITY_OP, Warn,
"using identity operations, e.g. `x + 0` or `y / 1`"
}
#[derive(Copy,Clone)]
pub struct IdentityOp;

6
src/items_after_statements.rs
View file

@ -27,7 +27,11 @@ use utils::in_macro;
/// foo(); // prints "foo"
/// }
/// ```
declare_lint! { pub ITEMS_AFTER_STATEMENTS, Warn, "finds blocks where an item comes after a statement" }
declare_lint! {
pub ITEMS_AFTER_STATEMENTS,
Warn,
"finds blocks where an item comes after a statement"
}
pub struct ItemsAfterStatemets;

14
src/len_zero.rs
View file

@ -18,9 +18,11 @@ use utils::{get_item_name, snippet, span_lint, walk_ptrs_ty};
/// **Known problems:** None
///
/// **Example:** `if x.len() == 0 { .. }`
declare_lint!(pub LEN_ZERO, Warn,
"checking `.len() == 0` or `.len() > 0` (or similar) when `.is_empty()` \
could be used instead");
declare_lint! {
pub LEN_ZERO, Warn,
"checking `.len() == 0` or `.len() > 0` (or similar) when `.is_empty()` \
could be used instead"
}
/// **What it does:** This lint checks for items that implement `.len()` but not `.is_empty()`. It is `Warn` by default.
///
@ -34,8 +36,10 @@ declare_lint!(pub LEN_ZERO, Warn,
/// fn len(&self) -> usize { .. }
/// }
/// ```
declare_lint!(pub LEN_WITHOUT_IS_EMPTY, Warn,
"traits and impls that have `.len()` but not `.is_empty()`");
declare_lint! {
pub LEN_WITHOUT_IS_EMPTY, Warn,
"traits and impls that have `.len()` but not `.is_empty()`"
}
#[derive(Copy,Clone)]
pub struct LenZero;

16
src/lifetimes.rs
View file

@ -15,9 +15,12 @@ use utils::{in_external_macro, span_lint};
/// **Known problems:** Potential false negatives: we bail out if the function has a `where` clause where lifetimes are mentioned.
///
/// **Example:** `fn in_and_out<'a>(x: &'a u8, y: u8) -> &'a u8 { x }`
declare_lint!(pub NEEDLESS_LIFETIMES, Warn,
"using explicit lifetimes for references in function arguments when elision rules \
would allow omitting them");
declare_lint! {
pub NEEDLESS_LIFETIMES,
Warn,
"using explicit lifetimes for references in function arguments when elision rules \
would allow omitting them"
}
/// **What it does:** This lint checks for lifetimes in generics that are never used anywhere else. It is `Warn` by default.
///
@ -26,8 +29,11 @@ declare_lint!(pub NEEDLESS_LIFETIMES, Warn,
/// **Known problems:** None
///
/// **Example:** `fn unused_lifetime<'a>(x: u8) { .. }`
declare_lint!(pub UNUSED_LIFETIMES, Warn,
"unused lifetimes in function definitions");
declare_lint! {
pub UNUSED_LIFETIMES,
Warn,
"unused lifetimes in function definitions"
}
#[derive(Copy,Clone)]
pub struct LifetimePass;

83
src/loops.rs
View file

@ -25,8 +25,11 @@ use utils::{BTREEMAP_PATH, HASHMAP_PATH, LL_PATH, OPTION_PATH, RESULT_PATH, VEC_
/// println!("{}", vec[i]);
/// }
/// ```
declare_lint!{ pub NEEDLESS_RANGE_LOOP, Warn,
"for-looping over a range of indices where an iterator over items would do" }
declare_lint! {
pub NEEDLESS_RANGE_LOOP,
Warn,
"for-looping over a range of indices where an iterator over items would do"
}
/// **What it does:** This lint checks for loops on `x.iter()` where `&x` will do, and suggest the latter. It is `Warn` by default.
///
@ -35,8 +38,11 @@ declare_lint!{ pub NEEDLESS_RANGE_LOOP, Warn,
/// **Known problems:** False negatives. We currently only warn on some known types.
///
/// **Example:** `for x in y.iter() { .. }` (where y is a `Vec` or slice)
declare_lint!{ pub EXPLICIT_ITER_LOOP, Warn,
"for-looping over `_.iter()` or `_.iter_mut()` when `&_` or `&mut _` would do" }
declare_lint! {
pub EXPLICIT_ITER_LOOP,
Warn,
"for-looping over `_.iter()` or `_.iter_mut()` when `&_` or `&mut _` would do"
}
/// **What it does:** This lint checks for loops on `x.next()`. It is `Warn` by default.
///
@ -45,8 +51,11 @@ declare_lint!{ pub EXPLICIT_ITER_LOOP, Warn,
/// **Known problems:** None
///
/// **Example:** `for x in y.next() { .. }`
declare_lint!{ pub ITER_NEXT_LOOP, Warn,
"for-looping over `_.next()` which is probably not intended" }
declare_lint! {
pub ITER_NEXT_LOOP,
Warn,
"for-looping over `_.next()` which is probably not intended"
}
/// **What it does:** This lint checks for `for` loops over `Option` values. It is `Warn` by default.
///
@ -55,8 +64,11 @@ declare_lint!{ pub ITER_NEXT_LOOP, Warn,
/// **Known problems:** None
///
/// **Example:** `for x in option { .. }`. This should be `if let Some(x) = option { .. }`.
declare_lint!{ pub FOR_LOOP_OVER_OPTION, Warn,
"for-looping over an `Option`, which is more clearly expressed as an `if let`" }
declare_lint! {
pub FOR_LOOP_OVER_OPTION,
Warn,
"for-looping over an `Option`, which is more clearly expressed as an `if let`"
}
/// **What it does:** This lint checks for `for` loops over `Result` values. It is `Warn` by default.
///
@ -65,8 +77,11 @@ declare_lint!{ pub FOR_LOOP_OVER_OPTION, Warn,
/// **Known problems:** None
///
/// **Example:** `for x in result { .. }`. This should be `if let Ok(x) = result { .. }`.
declare_lint!{ pub FOR_LOOP_OVER_RESULT, Warn,
"for-looping over a `Result`, which is more clearly expressed as an `if let`" }
declare_lint! {
pub FOR_LOOP_OVER_RESULT,
Warn,
"for-looping over a `Result`, which is more clearly expressed as an `if let`"
}
/// **What it does:** This lint detects `loop + match` combinations that are easier written as a `while let` loop. It is `Warn` by default.
///
@ -89,8 +104,11 @@ declare_lint!{ pub FOR_LOOP_OVER_RESULT, Warn,
/// // .. do something with x
/// }
/// ```
declare_lint!{ pub WHILE_LET_LOOP, Warn,
"`loop { if let { ... } else break }` can be written as a `while let` loop" }
declare_lint! {
pub WHILE_LET_LOOP,
Warn,
"`loop { if let { ... } else break }` can be written as a `while let` loop"
}
/// **What it does:** This lint checks for using `collect()` on an iterator without using the result. It is `Warn` by default.
///
@ -99,9 +117,12 @@ declare_lint!{ pub WHILE_LET_LOOP, Warn,
/// **Known problems:** None
///
/// **Example:** `vec.iter().map(|x| /* some operation returning () */).collect::<Vec<_>>();`
declare_lint!{ pub UNUSED_COLLECT, Warn,
"`collect()`ing an iterator without using the result; this is usually better \
written as a for loop" }
declare_lint! {
pub UNUSED_COLLECT,
Warn,
"`collect()`ing an iterator without using the result; this is usually better \
written as a for loop"
}
/// **What it does:** This lint checks for loops over ranges `x..y` where both `x` and `y` are constant and `x` is greater or equal to `y`, unless the range is reversed or has a negative `.step_by(_)`. It is `Warn` by default.
///
@ -110,8 +131,11 @@ declare_lint!{ pub UNUSED_COLLECT, Warn,
/// **Known problems:** The lint cannot catch loops over dynamically defined ranges. Doing this would require simulating all possible inputs and code paths through the program, which would be complex and error-prone.
///
/// **Examples**: `for x in 5..10-5 { .. }` (oops, stray `-`)
declare_lint!{ pub REVERSE_RANGE_LOOP, Warn,
"Iterating over an empty range, such as `10..0` or `5..5`" }
declare_lint! {
pub REVERSE_RANGE_LOOP,
Warn,
"Iterating over an empty range, such as `10..0` or `5..5`"
}
/// **What it does:** This lint checks `for` loops over slices with an explicit counter and suggests the use of `.enumerate()`. It is `Warn` by default.
///
@ -120,8 +144,11 @@ declare_lint!{ pub REVERSE_RANGE_LOOP, Warn,
/// **Known problems:** None.
///
/// **Example:** `for i in 0..v.len() { foo(v[i]); }` or `for i in 0..v.len() { bar(i, v[i]); }`
declare_lint!{ pub EXPLICIT_COUNTER_LOOP, Warn,
"for-looping with an explicit counter when `_.enumerate()` would do" }
declare_lint! {
pub EXPLICIT_COUNTER_LOOP,
Warn,
"for-looping with an explicit counter when `_.enumerate()` would do"
}
/// **What it does:** This lint checks for empty `loop` expressions. It is `Warn` by default.
///
@ -130,7 +157,11 @@ declare_lint!{ pub EXPLICIT_COUNTER_LOOP, Warn,
/// **Known problems:** None
///
/// **Example:** `loop {}`
declare_lint!{ pub EMPTY_LOOP, Warn, "empty `loop {}` detected" }
declare_lint! {
pub EMPTY_LOOP,
Warn,
"empty `loop {}` detected"
}
/// **What it does:** This lint checks for `while let` expressions on iterators. It is `Warn` by default.
///
@ -139,7 +170,11 @@ declare_lint!{ pub EMPTY_LOOP, Warn, "empty `loop {}` detected" }
/// **Known problems:** None
///
/// **Example:** `while let Some(val) = iter() { .. }`
declare_lint!{ pub WHILE_LET_ON_ITERATOR, Warn, "using a while-let loop instead of a for loop on an iterator" }
declare_lint! {
pub WHILE_LET_ON_ITERATOR,
Warn,
"using a while-let loop instead of a for loop on an iterator"
}
/// **What it does:** This warns when you iterate on a map (`HashMap` or `BTreeMap`) and ignore
/// either the keys or values.
@ -157,7 +192,11 @@ declare_lint!{ pub WHILE_LET_ON_ITERATOR, Warn, "using a while-let loop instead
/// ```rust
/// for k in map.keys() { .. }
/// ```
declare_lint!{ pub FOR_KV_MAP, Warn, "looping on a map using `iter` when `keys` or `values` would do" }
declare_lint! {
pub FOR_KV_MAP,
Warn,
"looping on a map using `iter` when `keys` or `values` would do"
}
#[derive(Copy, Clone)]
pub struct LoopsPass;

8
src/map_clone.rs
View file

@ -11,9 +11,11 @@ use utils::{walk_ptrs_ty, walk_ptrs_ty_depth};
/// **Known problems:** None
///
/// **Example:** `x.map(|e| e.clone());`
declare_lint!(pub MAP_CLONE, Warn,
"using `.map(|x| x.clone())` to clone an iterator or option's contents (recommends \
`.cloned()` instead)");
declare_lint! {
pub MAP_CLONE, Warn,
"using `.map(|x| x.clone())` to clone an iterator or option's contents (recommends \
`.cloned()` instead)"
}
#[derive(Copy, Clone)]
pub struct MapClonePass;

35
src/matches.rs
View file

@ -24,9 +24,11 @@ use utils::{match_type, snippet, span_lint, span_note_and_lint, span_lint_and_th
/// _ => ()
/// }
/// ```
declare_lint!(pub SINGLE_MATCH, Warn,
"a match statement with a single nontrivial arm (i.e, where the other arm \
is `_ => {}`) is used; recommends `if let` instead");
declare_lint! {
pub SINGLE_MATCH, Warn,
"a match statement with a single nontrivial arm (i.e, where the other arm \
is `_ => {}`) is used; recommends `if let` instead"
}
/// **What it does:** This lint checks for matches with a two arms where an `if let` will usually suffice. It is `Allow` by default.
///
@ -41,9 +43,11 @@ declare_lint!(pub SINGLE_MATCH, Warn,
/// _ => bar(other_ref),
/// }
/// ```
declare_lint!(pub SINGLE_MATCH_ELSE, Allow,
"a match statement with a two arms where the second arm's pattern is a wildcard; \
recommends `if let` instead");
declare_lint! {
pub SINGLE_MATCH_ELSE, Allow,
"a match statement with a two arms where the second arm's pattern is a wildcard; \
recommends `if let` instead"
}
/// **What it does:** This lint checks for matches where all arms match a reference, suggesting to remove the reference and deref the matched expression instead. It also checks for `if let &foo = bar` blocks. It is `Warn` by default.
///
@ -60,9 +64,11 @@ declare_lint!(pub SINGLE_MATCH_ELSE, Allow,
/// _ => frob(&x),
/// }
/// ```
declare_lint!(pub MATCH_REF_PATS, Warn,
"a match or `if let` has all arms prefixed with `&`; the match expression can be \
dereferenced instead");
declare_lint! {
pub MATCH_REF_PATS, Warn,
"a match or `if let` has all arms prefixed with `&`; the match expression can be \
dereferenced instead"
}
/// **What it does:** This lint checks for matches where match expression is a `bool`. It suggests to replace the expression with an `if...else` block. It is `Warn` by default.
///
@ -79,8 +85,10 @@ declare_lint!(pub MATCH_REF_PATS, Warn,
/// false => bar(),
/// }
/// ```
declare_lint!(pub MATCH_BOOL, Warn,
"a match on boolean expression; recommends `if..else` block instead");
declare_lint! {
pub MATCH_BOOL, Warn,
"a match on boolean expression; recommends `if..else` block instead"
}
/// **What it does:** This lint checks for overlapping match arms. It is `Warn` by default.
///
@ -98,8 +106,9 @@ declare_lint!(pub MATCH_BOOL, Warn,
/// _ => (),
/// }
/// ```
declare_lint!(pub MATCH_OVERLAPPING_ARM, Warn,
"a match has overlapping arms");
declare_lint! {
pub MATCH_OVERLAPPING_ARM, Warn, "a match has overlapping arms"
}
#[allow(missing_copy_implementations)]
pub struct MatchPass;

112
src/methods.rs
View file

@ -25,8 +25,10 @@ pub struct MethodsPass;
/// **Known problems:** None
///
/// **Example:** `x.unwrap()`
declare_lint!(pub OPTION_UNWRAP_USED, Allow,
"using `Option.unwrap()`, which should at least get a better message using `expect()`");
declare_lint! {
pub OPTION_UNWRAP_USED, Allow,
"using `Option.unwrap()`, which should at least get a better message using `expect()`"
}
/// **What it does:** This lint checks for `.unwrap()` calls on `Result`s. It is `Allow` by default.
///
@ -37,8 +39,10 @@ declare_lint!(pub OPTION_UNWRAP_USED, Allow,
/// **Known problems:** None
///
/// **Example:** `x.unwrap()`
declare_lint!(pub RESULT_UNWRAP_USED, Allow,
"using `Result.unwrap()`, which might be better handled");
declare_lint! {
pub RESULT_UNWRAP_USED, Allow,
"using `Result.unwrap()`, which might be better handled"
}
/// **What it does:** This lint checks for `.to_string()` method calls on values of type `&str`. It is `Warn` by default.
///
@ -47,8 +51,10 @@ declare_lint!(pub RESULT_UNWRAP_USED, Allow,
/// **Known problems:** None
///
/// **Example:** `s.to_string()` where `s: &str`
declare_lint!(pub STR_TO_STRING, Warn,
"using `to_string()` on a str, which should be `to_owned()`");
declare_lint! {
pub STR_TO_STRING, Warn,
"using `to_string()` on a str, which should be `to_owned()`"
}
/// **What it does:** This lint checks for `.to_string()` method calls on values of type `String`. It is `Warn` by default.
///
@ -58,8 +64,10 @@ declare_lint!(pub STR_TO_STRING, Warn,
/// **Known problems:** None
///
/// **Example:** `s.to_string()` where `s: String`
declare_lint!(pub STRING_TO_STRING, Warn,
"calling `String::to_string` which is inefficient");
declare_lint! {
pub STRING_TO_STRING, Warn,
"calling `String::to_string` which is inefficient"
}
/// **What it does:** This lint checks for methods that should live in a trait implementation of a `std` trait (see [llogiq's blog post](http://llogiq.github.io/2015/07/30/traits.html) for further information) instead of an inherent implementation. It is `Warn` by default.
///
@ -74,8 +82,10 @@ declare_lint!(pub STRING_TO_STRING, Warn,
/// fn add(&self, other: &X) -> X { .. }
/// }
/// ```
declare_lint!(pub SHOULD_IMPLEMENT_TRAIT, Warn,
"defining a method that should be implementing a std trait");
declare_lint! {
pub SHOULD_IMPLEMENT_TRAIT, Warn,
"defining a method that should be implementing a std trait"
}
/// **What it does:** This lint checks for methods with certain name prefixes and `Warn`s (by default) if the prefix doesn't match how self is taken. The actual rules are:
///
@ -98,9 +108,11 @@ declare_lint!(pub SHOULD_IMPLEMENT_TRAIT, Warn,
/// fn as_str(self) -> &str { .. }
/// }
/// ```
declare_lint!(pub WRONG_SELF_CONVENTION, Warn,
"defining a method named with an established prefix (like \"into_\") that takes \
`self` with the wrong convention");
declare_lint! {
pub WRONG_SELF_CONVENTION, Warn,
"defining a method named with an established prefix (like \"into_\") that takes \
`self` with the wrong convention"
}
/// **What it does:** This is the same as [`wrong_self_convention`](#wrong_self_convention), but for public items. This lint is `Allow` by default.
///
@ -114,9 +126,11 @@ declare_lint!(pub WRONG_SELF_CONVENTION, Warn,
/// pub fn as_str(self) -> &str { .. }
/// }
/// ```
declare_lint!(pub WRONG_PUB_SELF_CONVENTION, Allow,
"defining a public method named with an established prefix (like \"into_\") that takes \
`self` with the wrong convention");
declare_lint! {
pub WRONG_PUB_SELF_CONVENTION, Allow,
"defining a public method named with an established prefix (like \"into_\") that takes \
`self` with the wrong convention"
}
/// **What it does:** This lint `Warn`s on using `ok().expect(..)`.
///
@ -125,9 +139,11 @@ declare_lint!(pub WRONG_PUB_SELF_CONVENTION, Allow,
/// **Known problems:** None.
///
/// **Example:** `x.ok().expect("why did I do this again?")`
declare_lint!(pub OK_EXPECT, Warn,
"using `ok().expect()`, which gives worse error messages than \
calling `expect` directly on the Result");
declare_lint! {
pub OK_EXPECT, Warn,
"using `ok().expect()`, which gives worse error messages than \
calling `expect` directly on the Result"
}
/// **What it does:** This lint `Warn`s on `_.map(_).unwrap_or(_)`.
///
@ -136,9 +152,11 @@ declare_lint!(pub OK_EXPECT, Warn,
/// **Known problems:** None.
///
/// **Example:** `x.map(|a| a + 1).unwrap_or(0)`
declare_lint!(pub OPTION_MAP_UNWRAP_OR, Warn,
"using `Option.map(f).unwrap_or(a)`, which is more succinctly expressed as \
`map_or(a, f)`");
declare_lint! {
pub OPTION_MAP_UNWRAP_OR, Warn,
"using `Option.map(f).unwrap_or(a)`, which is more succinctly expressed as \
`map_or(a, f)`"
}
/// **What it does:** This lint `Warn`s on `_.map(_).unwrap_or_else(_)`.
///
@ -147,9 +165,11 @@ declare_lint!(pub OPTION_MAP_UNWRAP_OR, Warn,
/// **Known problems:** None.
///
/// **Example:** `x.map(|a| a + 1).unwrap_or_else(some_function)`
declare_lint!(pub 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)`");
declare_lint! {
pub 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)`"
}
/// **What it does:** This lint `Warn`s on `_.filter(_).next()`.
///
@ -158,8 +178,10 @@ declare_lint!(pub OPTION_MAP_UNWRAP_OR_ELSE, Warn,
/// **Known problems:** None.
///
/// **Example:** `iter.filter(|x| x == 0).next()`
declare_lint!(pub FILTER_NEXT, Warn,
"using `filter(p).next()`, which is more succinctly expressed as `.find(p)`");
declare_lint! {
pub FILTER_NEXT, Warn,
"using `filter(p).next()`, which is more succinctly expressed as `.find(p)`"
}
/// **What it does:** This lint `Warn`s on an iterator search (such as `find()`, `position()`, or
/// `rposition()`) followed by a call to `is_some()`.
@ -169,9 +191,11 @@ declare_lint!(pub FILTER_NEXT, Warn,
/// **Known problems:** None.
///
/// **Example:** `iter.find(|x| x == 0).is_some()`
declare_lint!(pub SEARCH_IS_SOME, Warn,
"using an iterator search followed by `is_some()`, which is more succinctly \
expressed as a call to `any()`");
declare_lint! {
pub SEARCH_IS_SOME, Warn,
"using an iterator search followed by `is_some()`, which is more succinctly \
expressed as a call to `any()`"
}
/// **What it does:** This lint `Warn`s on using `.chars().next()` on a `str` to check if it
/// starts with a given char.
@ -181,8 +205,10 @@ declare_lint!(pub SEARCH_IS_SOME, Warn,
/// **Known problems:** None.
///
/// **Example:** `name.chars().next() == Some('_')`
declare_lint!(pub CHARS_NEXT_CMP, Warn,
"using `.chars().next()` to check if a string starts with a char");
declare_lint! {
pub CHARS_NEXT_CMP, Warn,
"using `.chars().next()` to check if a string starts with a char"
}
/// **What it does:** This lint checks for calls to `.or(foo(..))`, `.unwrap_or(foo(..))`, etc., and
/// suggests to use `or_else`, `unwrap_or_else`, etc., or `unwrap_or_default` instead.
@ -203,8 +229,10 @@ declare_lint!(pub CHARS_NEXT_CMP, Warn,
///
/// **Known problems:** If the function as side-effects, not calling it will change the semantic of
/// the program, but you shouldn't rely on that anyway.
declare_lint!(pub OR_FUN_CALL, Warn,
"using any `*or` method when the `*or_else` would do");
declare_lint! {
pub OR_FUN_CALL, Warn,
"using any `*or` method when the `*or_else` would do"
}
/// **What it does:** This lint `Warn`s on using `.extend(s)` on a `vec` to extend the vec by a slice.
///
@ -213,8 +241,10 @@ declare_lint!(pub OR_FUN_CALL, Warn,
/// **Known problems:** None.
///
/// **Example:** `my_vec.extend(&xs)`
declare_lint!(pub EXTEND_FROM_SLICE, Warn,
"`.extend_from_slice(_)` is a faster way to extend a Vec by a slice");
declare_lint! {
pub EXTEND_FROM_SLICE, Warn,
"`.extend_from_slice(_)` is a faster way to extend a Vec by a slice"
}
/// **What it does:** This lint warns on using `.clone()` on a `Copy` type.
///
@ -224,8 +254,9 @@ declare_lint!(pub EXTEND_FROM_SLICE, Warn,
/// **Known problems:** None.
///
/// **Example:** `42u64.clone()`
declare_lint!(pub CLONE_ON_COPY, Warn,
"using `clone` on a `Copy` type");
declare_lint! {
pub CLONE_ON_COPY, Warn, "using `clone` on a `Copy` type"
}
/// **What it does:** This lint warns on using `.clone()` on an `&&T`
///
@ -244,8 +275,9 @@ declare_lint!(pub CLONE_ON_COPY, Warn,
/// }
/// ```
///
declare_lint!(pub CLONE_DOUBLE_REF, Warn,
"using `clone` on `&&T`");
declare_lint! {
pub CLONE_DOUBLE_REF, Warn, "using `clone` on `&&T`"
}
impl LintPass for MethodsPass {
fn get_lints(&self) -> LintArray {

7
src/minmax.rs
View file

@ -15,9 +15,10 @@ use self::MinMax::{Min, Max};
/// **Known problems:** None
///
/// **Example:** `min(0, max(100, x))` 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`.
declare_lint!(pub MIN_MAX, Warn,
"`min(_, max(_, _))` (or vice versa) with bounds clamping the result \
to a constant");
declare_lint! {
pub MIN_MAX, Warn,
"`min(_, max(_, _))` (or vice versa) with bounds clamping the result to a constant"
}
#[allow(missing_copy_implementations)]
pub struct MinMaxPass;

10
src/misc.rs
View file

@ -22,10 +22,12 @@ use utils::{span_help_and_lint, walk_ptrs_ty, is_integer_literal, implements_tra
/// **Known problems:** If the argument is dereferenced within the function, removing the `ref` will lead to errors. This can be fixed by removing the dereferences, e.g. changing `*x` to `x` within the function.
///
/// **Example:** `fn foo(ref x: u8) -> bool { .. }`
declare_lint!(pub 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 `&`.");
declare_lint! {
pub 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 `&`."
}
#[allow(missing_copy_implementations)]
pub struct TopLevelRefPass;

12
src/misc_early.rs
View file

@ -15,8 +15,10 @@ use utils::{span_lint, span_help_and_lint};
/// **Known problems:** None.
///
/// **Example:** `let { a: _, b: ref b, c: _ } = ..`
declare_lint!(pub UNNEEDED_FIELD_PATTERN, Warn,
"Struct fields are bound to a wildcard instead of using `..`");
declare_lint! {
pub UNNEEDED_FIELD_PATTERN, Warn,
"Struct fields are bound to a wildcard instead of using `..`"
}
/// **What it does:** This lint `Warn`s on function arguments having the similar names differing by an underscore
///
@ -25,8 +27,10 @@ declare_lint!(pub UNNEEDED_FIELD_PATTERN, Warn,
/// **Known problems:** None.
///
/// **Example:** `fn foo(a: i32, _a: i32) {}`
declare_lint!(pub DUPLICATE_UNDERSCORE_ARGUMENT, Warn,
"Function arguments having names which only differ by an underscore");
declare_lint! {
pub DUPLICATE_UNDERSCORE_ARGUMENT, Warn,
"Function arguments having names which only differ by an underscore"
}
#[derive(Copy, Clone)]
pub struct MiscEarly;

9
src/mut_mut.rs
View file

@ -11,9 +11,12 @@ use utils::{in_external_macro, span_lint};
/// **Known problems:** None
///
/// **Example:** `let x = &mut &mut y;`
declare_lint!(pub MUT_MUT, Allow,
"usage of double-mut refs, e.g. `&mut &mut ...` (either copy'n'paste error, \
or shows a fundamental misunderstanding of references)");
declare_lint! {
pub MUT_MUT,
Allow,
"usage of double-mut refs, e.g. `&mut &mut ...` (either copy'n'paste error, \
or shows a fundamental misunderstanding of references)"
}
#[derive(Copy,Clone)]
pub struct MutMut;

4
src/panic.rs
View file

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

8
src/precedence.rs
View file

@ -15,9 +15,11 @@ use utils::{span_lint, snippet};
/// **Examples:**
/// * `1 << 2 + 3` equals 32, while `(1 << 2) + 3` equals 7
/// * `-1i32.abs()` equals -1, while `(-1i32).abs()` equals 1
declare_lint!(pub PRECEDENCE, Warn,
"catches operations where precedence may be unclear. See the wiki for a \
list of cases caught");
declare_lint! {
pub PRECEDENCE, Warn,
"catches operations where precedence may be unclear. See the wiki for a \
list of cases caught"
}
#[derive(Copy,Clone)]
pub struct Precedence;

15
src/returns.rs
View file

@ -13,8 +13,11 @@ use utils::{span_lint, span_lint_and_then, snippet_opt, match_path_ast, in_exter
/// **Known problems:** None
///
/// **Example:** `fn foo(x: usize) { return x; }`
declare_lint!(pub NEEDLESS_RETURN, Warn,
"using a return statement like `return expr;` where an expression would suffice");
declare_lint! {
pub NEEDLESS_RETURN, Warn,
"using a return statement like `return expr;` where an expression would suffice"
}
/// **What it does:** This lint checks for `let`-bindings, which are subsequently returned. It is `Warn` by default.
///
/// **Why is this bad?** It is just extraneous code. Remove it to make your code more rusty.
@ -22,9 +25,11 @@ declare_lint!(pub NEEDLESS_RETURN, Warn,
/// **Known problems:** None
///
/// **Example:** `{ let x = ..; x }`
declare_lint!(pub LET_AND_RETURN, Warn,
"creating a let-binding and then immediately returning it like `let x = expr; x` at \
the end of a block");
declare_lint! {
pub LET_AND_RETURN, Warn,
"creating a let-binding and then immediately returning it like `let x = expr; x` at \
the end of a block"
}
#[derive(Copy, Clone)]
pub struct ReturnPass;

20
src/shadow.rs
View file

@ -16,8 +16,11 @@ use utils::{is_from_for_desugar, in_external_macro, snippet, span_lint, span_not
/// **Known problems:** This lint, as the other shadowing related lints, currently only catches very simple patterns.
///
/// **Example:** `let x = &x;`
declare_lint!(pub SHADOW_SAME, Allow,
"rebinding a name to itself, e.g. `let mut x = &mut x`");
declare_lint! {
pub SHADOW_SAME, Allow,
"rebinding a name to itself, e.g. `let mut x = &mut x`"
}
/// **What it does:** This lint checks for bindings that shadow other bindings already in scope, while reusing the original value. It is `Allow` by default.
///
/// **Why is this bad?** Not too much, in fact it's a common pattern in Rust code. Still, some argue that name shadowing like this hurts readability, because a value may be bound to different things depending on position in the code.
@ -25,9 +28,12 @@ declare_lint!(pub SHADOW_SAME, Allow,
/// **Known problems:** This lint, as the other shadowing related lints, currently only catches very simple patterns.
///
/// **Example:** `let x = x + 1;`
declare_lint!(pub SHADOW_REUSE, Allow,
declare_lint! {
pub SHADOW_REUSE, Allow,
"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:** This lint checks for bindings that shadow other bindings already in scope, either without a initialization or with one that does not even use the original value. This lint is `Warn` by default.
///
/// **Why is this bad?** Name shadowing can hurt readability, especially in large code bases, because it is easy to lose track of the active binding at any place in the code. This can be alleviated by either giving more specific names to bindings ore introducing more scopes to contain the bindings.
@ -35,8 +41,10 @@ declare_lint!(pub SHADOW_REUSE, Allow,
/// **Known problems:** This lint, as the other shadowing related lints, currently only catches very simple patterns.
///
/// **Example:** `let x = y; let x = z; // shadows the earlier binding`
declare_lint!(pub SHADOW_UNRELATED, Allow,
"The name is re-bound without even using the original value");
declare_lint! {
pub SHADOW_UNRELATED, Allow,
"The name is re-bound without even using the original value"
}
#[derive(Copy, Clone)]
pub struct ShadowPass;

71
src/types.rs
View file

@ -22,8 +22,10 @@ pub struct TypePass;
/// **Known problems:** None
///
/// **Example:** `struct X { values: Box<Vec<Foo>> }`
declare_lint!(pub BOX_VEC, Warn,
"usage of `Box<Vec<T>>`, vector elements are already on the heap");
declare_lint! {
pub BOX_VEC, Warn,
"usage of `Box<Vec<T>>`, vector elements are already on the heap"
}
/// **What it does:** This lint checks for usage of any `LinkedList`, suggesting to use a `Vec` or a `VecDeque` (formerly called `RingBuf`). It is `Warn` by default.
///
@ -36,9 +38,11 @@ declare_lint!(pub BOX_VEC, Warn,
/// **Known problems:** False positives – the instances where using a `LinkedList` makes sense are few and far between, but they can still happen.
///
/// **Example:** `let x = LinkedList::new();`
declare_lint!(pub LINKEDLIST, Warn,
"usage of LinkedList, usually a vector is faster, or a more specialized data \
structure like a VecDeque");
declare_lint! {
pub LINKEDLIST, Warn,
"usage of LinkedList, usually a vector is faster, or a more specialized data \
structure like a VecDeque"
}
impl LintPass for TypePass {
fn get_lints(&self) -> LintArray {
@ -81,8 +85,10 @@ pub struct LetPass;
/// **Known problems:** None
///
/// **Example:** `let x = { 1; };`
declare_lint!(pub LET_UNIT_VALUE, Warn,
"creating a let binding to a value of unit type, which usually can't be used afterwards");
declare_lint! {
pub LET_UNIT_VALUE, Warn,
"creating a let binding to a value of unit type, which usually can't be used afterwards"
}
fn check_let_unit(cx: &LateContext, decl: &Decl) {
if let DeclLocal(ref local) = decl.node {
@ -122,8 +128,10 @@ impl LateLintPass for LetPass {
/// **Known problems:** None
///
/// **Example:** `if { foo(); } == { bar(); } { baz(); }` is equal to `{ foo(); bar(); baz(); }`
declare_lint!(pub UNIT_CMP, Warn,
"comparing unit values (which is always `true` or `false`, respectively)");
declare_lint! {
pub UNIT_CMP, Warn,
"comparing unit values (which is always `true` or `false`, respectively)"
}
#[allow(missing_copy_implementations)]
pub struct UnitCmp;
@ -169,8 +177,11 @@ pub struct CastPass;
/// **Known problems:** None
///
/// **Example:** `let x = u64::MAX; x as f64`
declare_lint!(pub CAST_PRECISION_LOSS, Allow,
"casts that cause loss of precision, e.g `x as f32` where `x: u64`");
declare_lint! {
pub CAST_PRECISION_LOSS, Allow,
"casts that cause loss of precision, e.g `x as f32` where `x: u64`"
}
/// **What it does:** This lint checks for casts from a signed to an unsigned numerical type. In this case, negative values wrap around to large positive values, which can be quite surprising in practice. However, as the cast works as defined, this lint is `Allow` by default.
///
/// **Why is this bad?** Possibly surprising results. You can activate this lint as a one-time check to see where numerical wrapping can arise.
@ -178,8 +189,11 @@ declare_lint!(pub CAST_PRECISION_LOSS, Allow,
/// **Known problems:** None
///
/// **Example:** `let y : i8 = -1; y as u64` will return 18446744073709551615
declare_lint!(pub CAST_SIGN_LOSS, Allow,
"casts from signed types to unsigned types, e.g `x as u32` where `x: i32`");
declare_lint! {
pub CAST_SIGN_LOSS, Allow,
"casts from signed types to unsigned types, e.g `x as u32` where `x: i32`"
}
/// **What it does:** This lint checks for on casts between numerical types that may truncate large values. This is expected behavior, so the cast is `Allow` by default.
///
/// **Why is this bad?** In some problem domains, it is good practice to avoid truncation. This lint can be activated to help assess where additional checks could be beneficial.
@ -187,8 +201,11 @@ declare_lint!(pub CAST_SIGN_LOSS, Allow,
/// **Known problems:** None
///
/// **Example:** `fn as_u8(x: u64) -> u8 { x as u8 }`
declare_lint!(pub CAST_POSSIBLE_TRUNCATION, Allow,
"casts that may cause truncation of the value, e.g `x as u8` where `x: u32`, or `x as i32` where `x: f32`");
declare_lint! {
pub CAST_POSSIBLE_TRUNCATION, 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:** This lint checks for casts from an unsigned type to a signed type of the same size. Performing such a cast is a 'no-op' for the compiler, i.e. nothing is changed at the bit level, and the binary representation of the value is reinterpreted. This can cause wrapping if the value is too big for the target signed type. However, the cast works as defined, so this lint is `Allow` by default.
///
/// **Why is this bad?** While such a cast is not bad in itself, the results can be surprising when this is not the intended behavior, as demonstrated by the example below.
@ -196,8 +213,10 @@ declare_lint!(pub CAST_POSSIBLE_TRUNCATION, Allow,
/// **Known problems:** None
///
/// **Example:** `u32::MAX as i32` will yield a value of `-1`.
declare_lint!(pub CAST_POSSIBLE_WRAP, Allow,
"casts that may cause wrapping around the value, e.g `x as i32` where `x: u32` and `x > i32::MAX`");
declare_lint! {
pub CAST_POSSIBLE_WRAP, 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.
/// Will return 0 if the type is not an int or uint variant
@ -393,8 +412,10 @@ impl LateLintPass for CastPass {
/// **Known problems:** None
///
/// **Example:** `struct Foo { inner: Rc<Vec<Vec<Box<(u32, u32, u32, u32)>>>> }`
declare_lint!(pub TYPE_COMPLEXITY, Warn,
"usage of very complex types; recommends factoring out parts into `type` definitions");
declare_lint! {
pub TYPE_COMPLEXITY, Warn,
"usage of very complex types; recommends factoring out parts into `type` definitions"
}
#[allow(missing_copy_implementations)]
pub struct TypeComplexityPass;
@ -525,8 +546,10 @@ impl<'v> Visitor<'v> for TypeComplexityVisitor {
/// **Known problems:** None
///
/// **Example:** `'x' as u8`
declare_lint!(pub CHAR_LIT_AS_U8, Warn,
"Casting a character literal to u8");
declare_lint! {
pub CHAR_LIT_AS_U8, Warn,
"Casting a character literal to u8"
}
pub struct CharLitAsU8;
@ -565,8 +588,10 @@ impl LateLintPass for CharLitAsU8 {
/// **Known problems:** None
///
/// **Example:** `vec.len() <= 0`
declare_lint!(pub ABSURD_UNSIGNED_COMPARISONS, Warn,
"testing whether an unsigned integer is non-positive");
declare_lint! {
pub ABSURD_UNSIGNED_COMPARISONS, Warn,
"testing whether an unsigned integer is non-positive"
}
pub struct AbsurdUnsignedComparisons;

24
src/unicode.rs
View file

@ -15,8 +15,11 @@ use utils::{snippet, span_help_and_lint};
/// **Known problems:** None
///
/// **Example:** You don't see it, but there may be a zero-width space somewhere in this text.
declare_lint!{ pub ZERO_WIDTH_SPACE, Deny,
"using a zero-width space in a string literal, which is confusing" }
declare_lint! {
pub ZERO_WIDTH_SPACE, Deny,
"using a zero-width space in a string literal, which is confusing"
}
/// **What it does:** This lint checks for non-ascii characters in string literals. It is `Allow` by default.
///
/// **Why is this bad?** Yeah, we know, the 90's called and wanted their charset back. Even so, there still are editors and other programs out there that don't work well with unicode. So if the code is meant to be used internationally, on multiple operating systems, or has other portability requirements, activating this lint could be useful.
@ -24,9 +27,12 @@ declare_lint!{ pub ZERO_WIDTH_SPACE, Deny,
/// **Known problems:** None
///
/// **Example:** `let x = "Hä?"`
declare_lint!{ pub NON_ASCII_LITERAL, Allow,
"using any literal non-ASCII chars in a string literal; suggests \
using the \\u escape instead" }
declare_lint! {
pub NON_ASCII_LITERAL, Allow,
"using any literal non-ASCII chars in a string literal; suggests \
using the \\u escape instead"
}
/// **What it does:** This lint checks for string literals that contain unicode in a form that is not equal to its [NFC-recomposition](http://www.unicode.org/reports/tr15/#Norm_Forms). This lint is `Allow` by default.
///
/// **Why is this bad?** If such a string is compared to another, the results may be surprising.
@ -34,9 +40,11 @@ declare_lint!{ pub NON_ASCII_LITERAL, Allow,
/// **Known problems** None
///
/// **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}".
declare_lint!{ pub UNICODE_NOT_NFC, Allow,
"using a unicode literal not in NFC normal form (see \
http://www.unicode.org/reports/tr15/ for further information)" }
declare_lint! {
pub UNICODE_NOT_NFC, Allow,
"using a unicode literal not in NFC normal form (see \
http://www.unicode.org/reports/tr15/ for further information)"
}
#[derive(Copy, Clone)]

7
src/zero_div_zero.rs
View file

@ -16,8 +16,11 @@ pub struct ZeroDivZeroPass;
/// **Known problems:** None
///
/// **Example** `0.0f32 / 0.0`
declare_lint!(pub ZERO_DIVIDED_BY_ZERO, Warn,
"usage of `0.0 / 0.0` to obtain NaN instead of std::f32::NaN or std::f64::NaN");
declare_lint! {
pub ZERO_DIVIDED_BY_ZERO,
Warn,
"usage of `0.0 / 0.0` to obtain NaN instead of std::f32::NaN or std::f64::NaN"
}
impl LintPass for ZeroDivZeroPass {
fn get_lints(&self) -> LintArray {