A collection of lints to catch common mistakes and improve your Rust code.
Table of contents:
There are 160 lints included in this crate:
name | default | meaning
---------------------------------------------------------------------------------------------------------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
absurdextremecomparisons | warn | a comparison involving a maximum or minimum value involves a case that is always true or always false
almostswapped | warn | foo = bar; bar = foo sequence
approxconstant | warn | the approximate of a known float constant (in std::f64::consts or std::f32::consts) is found; suggests to use the constant
assignoppattern | warn | assigning the result of an operation on a variable to that same variable
assignops | allow | any assignment operation
badbitmask | 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)
blacklistedname | warn | usage of a blacklisted/placeholder name
blockinifconditionexpr | warn | braces can be eliminated in conditions that are expressions, e.g if { true } ...
blockinifconditionstmt | warn | avoid complex blocks in conditions, instead move the block higher and bind it with 'let'; e.g: if { let x = true; x } ...
boolcomparison | warn | comparing a variable to a boolean, e.g. if x == true
boxvec | warn | usage of Box<Vec<T>>, vector elements are already on the heap
boxedlocal | warn | using Box<T> where unnecessary
castpossibletruncation | allow | casts that may cause truncation of the value, e.g x as u8 where x: u32, or x as i32 where x: f32
castpossiblewrap | allow | casts that may cause wrapping around the value, e.g x as i32 where x: u32 and x > i32::MAX
castprecisionloss | allow | casts that cause loss of precision, e.g x as f32 where x: u64
castsignloss | allow | casts from signed types to unsigned types, e.g x as u32 where x: i32
charlitasu8 | warn | Casting a character literal to u8
charsnextcmp | warn | using .chars().next() to check if a string starts with a char
clonedoubleref | warn | using clone on &&T
cloneoncopy | warn | using clone on a Copy type
cmpnan | deny | comparisons to NAN (which will always return false, which is probably not intended)
cmpowned | warn | creating owned instances for comparing with others, e.g. x == "foo".to_string()
collapsibleif | warn | ifs that can be collapsed (e.g. if x { if y { ... } } and else { if x { ... } })
crosspointertransmute | warn | transmutes that have to or from types that are a pointer to the other
cyclomaticcomplexity | warn | finds functions that should be split up into multiple functions
deprecatedsemver | warn | Warn on #[deprecated(since = "x")] where x is not semver
derivehashxoreq | warn | deriving Hash but implementing PartialEq explicitly
docmarkdown | warn | checks for the presence of _, :: or camel-case outside ticks in documentation
doubleneg | warn | --x is a double negation of x and not a pre-decrement as in C or C++
dropref | 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
duplicateunderscoreargument | warn | Function arguments having names which only differ by an underscore
emptyloop | warn | empty loop {} detected
enumclikeunportablevariant | warn | finds C-like enums that are repr(isize/usize) and have values that don't fit into an i32
enumglobuse | allow | finds use items that import all variants of an enum
enumvariantnames | warn | finds enums where all variants share a prefix/postfix
eqop | warn | equal operands on both sides of a comparison or bitwise combination (e.g. x == x)
explimplcloneoncopy | warn | implementing Clone explicitly on Copy types
explicitcounterloop | warn | for-looping with an explicit counter when _.enumerate() would do
explicititerloop | warn | for-looping over _.iter() or _.iter_mut() when &_ or &mut _ would do
extendfromslice | warn | .extend_from_slice(_) is a faster way to extend a Vec by a slice
filtermap | allow | using combinations of filter, map, filter_map and flat_map which can usually be written as a single method call
filternext | warn | using filter(p).next(), which is more succinctly expressed as .find(p)
floatarithmetic | allow | Any floating-point arithmetic statement
floatcmp | 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)
forkvmap | warn | looping on a map using iter when keys or values would do
forloopoveroption | warn | for-looping over an Option, which is more clearly expressed as an if let
forloopoverresult | warn | for-looping over a Result, which is more clearly expressed as an if let
identityop | warn | using identity operations, e.g. x + 0 or y / 1
ifnotelse | allow | finds if branches that could be swapped so no negation operation is necessary on the condition
ifsamethenelse | warn | if with the same *then* and *else* blocks
ifssamecond | warn | consecutive ifs with the same condition
indexingslicing | allow | indexing/slicing usage
ineffectivebitmask | warn | expressions where a bit mask will be rendered useless by a comparison, e.g. (x | 1) > 2
inlinealways | warn | #[inline(always)] is a bad idea in most cases
integerarithmetic | allow | Any integer arithmetic statement
invalidregex | deny | finds invalid regular expressions
invalidupcastcomparisons | allow | a comparison involving an upcast which is always true or false
itemsafterstatements | allow | finds blocks where an item comes after a statement
iternextloop | warn | for-looping over _.next() which is probably not intended
iternth | warn | using .iter().nth() on a standard library type with O(1) element access
lenwithoutisempty | warn | traits and impls that have .len() but not .is_empty()
lenzero | warn | checking .len() == 0 or .len() > 0 (or similar) when .is_empty() could be used instead
letandreturn | warn | creating a let-binding and then immediately returning it like let x = expr; x at the end of a block
letunitvalue | warn | creating a let binding to a value of unit type, which usually can't be used afterwards
linkedlist | warn | usage of LinkedList, usually a vector is faster, or a more specialized data structure like a VecDeque
logicbug | warn | checks for boolean expressions that contain terminals which can be eliminated
manualswap | warn | manual swap
manysinglecharnames | warn | too many single character bindings
mapclone | warn | using .map(|x| x.clone()) to clone an iterator or option's contents (recommends .cloned() instead)
mapentry | warn | use of contains_key followed by insert on a HashMap or BTreeMap
matchbool | warn | a match on boolean expression; recommends if..else block instead
matchoverlappingarm | warn | a match has overlapping arms
matchrefpats | warn | a match or if let has all arms prefixed with &; the match expression can be dereferenced instead
matchsamearms | warn | match with identical arm bodies
memforget | allow | mem::forget usage on Drop types is likely to cause memory leaks
minmax | warn | min(_, max(_, _)) (or vice versa) with bounds clamping the result to a constant
misrefactoredassignop | warn | having a variable on both sides of an assign op
moduloone | warn | taking a number modulo 1, which always returns 0
mutmut | allow | usage of double-mut refs, e.g. &mut &mut ...
mutexatomic | warn | using a mutex where an atomic value could be used instead
mutexinteger | allow | using a mutex for an integer type
needlessbool | warn | if-statements with plain booleans in the then- and else-clause, e.g. if p { true } else { false }
needlessborrow | warn | taking a reference that is going to be automatically dereferenced
needlesslifetimes | warn | using explicit lifetimes for references in function arguments when elision rules would allow omitting them
needlessrangeloop | warn | for-looping over a range of indices where an iterator over items would do
needlessreturn | warn | using a return statement like return expr; where an expression would suffice
needlessupdate | warn | using Foo { ..base } when there are no missing fields
negmultiply | warn | Warns on multiplying integers with -1
newretnoself | warn | not returning Self in a new method
newwithoutdefault | warn | fn new() -> Self method without Default implementation
newwithoutdefaultderive | warn | fn new() -> Self without #[derive]able Default implementation
noeffect | warn | statements with no effect
nonasciiliteral | allow | using any literal non-ASCII chars in a string literal; suggests using the \\u escape instead
nonminimalbool | allow | checks for boolean expressions that can be written more concisely
nonsensicalopenoptions | warn | nonsensical combination of options for opening a file
notunsafeptrargderef | warn | public functions dereferencing raw pointer arguments but not marked unsafe
okexpect | warn | using ok().expect(), which gives worse error messages than calling expect directly on the Result
optionmapunwrapor | warn | using Option.map(f).unwrap_or(a), which is more succinctly expressed as map_or(a, f)
optionmapunwraporelse | warn | using Option.map(f).unwrap_or_else(g), which is more succinctly expressed as map_or_else(g, f)
optionunwrapused | allow | using Option.unwrap(), which should at least get a better message using expect()
orfuncall | warn | using any *or method when the *or_else would do
outofboundsindexing | deny | out of bound constant indexing
overflowcheckconditional | warn | Using overflow checks which are likely to panic
panicparams | warn | missing parameters in panic!
precedence | warn | catches operations where precedence may be unclear
printstdout | allow | printing on stdout
ptrarg | warn | fn arguments of the type &Vec<...> or &String, suggesting to use &[...] or &str instead, respectively
rangestepbyzero | warn | using Range::stepby(0), which produces an infinite iterator
rangezipwithlen | warn | zipping iterator with a range when enumerate() would do
redundantclosure | warn | using redundant closures, i.e. |a| foo(a) (which can be written as just foo)
redundantclosurecall | warn | Closures should not be called in the expression they are defined
redundantpattern | warn | using name @ _ in a pattern
regexmacro | warn | finds use of regex!(_), suggests Regex::new(_) instead
resultunwrapused | allow | using Result.unwrap(), which might be better handled
reverserangeloop | warn | Iterating over an empty range, such as 10..0 or 5..5
searchissome | warn | using an iterator search followed by is_some(), which is more succinctly expressed as a call to any()
serdeapimisuse | warn | Various things that will negatively affect your serde experience
shadowreuse | allow | rebinding a name to an expression that re-uses the original value, e.g. let x = x + 1
shadowsame | allow | rebinding a name to itself, e.g. let mut x = &mut x
shadowunrelated | allow | The name is re-bound without even using the original value
shouldimplementtrait | warn | defining a method that should be implementing a std trait
similarnames | allow | similarly named items and bindings
singlecharpattern | warn | using a single-character str where a char could be used, e.g. _.split("x")
singlematch | warn | a match statement with a single nontrivial arm (i.e, where the other arm is _ => {}) is used; recommends if let instead
singlematchelse | allow | a match statement with a two arms where the second arm's pattern is a wildcard; recommends if let instead
stringadd | allow | using x + .. where x is a String; suggests using push_str() instead
stringaddassign | allow | using x = x + .. where x is a String; suggests using push_str() instead
stringlitasbytes | warn | calling as_bytes on a string literal; suggests using a byte string literal instead
stutter | allow | finds type names prefixed/postfixed with their containing module's name
suspiciousassignmentformatting | warn | suspicious formatting of *=, -= or !=
suspiciouselseformatting | warn | suspicious formatting of else if
temporaryassignment | warn | assignments to temporaries
temporarycstringasptr | warn | getting the inner pointer of a temporary CString
toomanyarguments | warn | functions with too many arguments
toplevelrefarg | 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 &.
transmuteptrtoref | warn | transmutes from a pointer to a reference type
trivialregex | warn | finds trivial regular expressions
typecomplexity | warn | usage of very complex types; recommends factoring out parts into type definitions
unicodenotnfc | allow | using a unicode literal not in NFC normal form (see unicode tr15 for further information)
unitcmp | warn | comparing unit values (which is always true or false, respectively)
unnecessarymutpassed | warn | an argument is passed as a mutable reference although the function/method only demands an immutable reference
unnecessaryoperation | warn | outer expressions with no effect
unneededfieldpattern | warn | Struct fields are bound to a wildcard instead of using ..
unsaferemovedfromname | warn | unsafe removed from name
unusedcollect | warn | collect()ing an iterator without using the result; this is usually better written as a for loop
unusedlabel | warn | unused label
unusedlifetimes | warn | unused lifetimes in function definitions
usedebug | allow | use Debug-based formatting
usedunderscorebinding | allow | using a binding which is prefixed with an underscore
uselessformat | warn | useless use of format!
uselessletifseq | warn | Checks for unidiomatic let mut declaration followed by initialization in if
uselesstransmute | warn | transmutes that have the same to and from types or could be a cast/coercion
uselessvec | warn | useless vec!
whileletloop | warn | loop { if let { ... } else break } can be written as a while let loop
whileletoniterator | warn | using a while-let loop instead of a for loop on an iterator
wrongpubselfconvention | allow | defining a public method named with an established prefix (like "into") that takes self with the wrong convention
wrongselfconvention | warn | defining a method named with an established prefix (like "into") that takes self with the wrong convention
wrongtransmute | warn | transmutes that are confusing at best, undefined behaviour at worst and always useless
zerodividedbyzero | warn | usage of 0.0 / 0.0 to obtain NaN instead of std::f32::NaN or std::f64::NaN
zerowidth_space | deny | using a zero-width space in a string literal, which is confusing
More to come, please file an issue if you have ideas!
As a general rule clippy will only work with the latest Rust nightly for now.
Since stable Rust is backwards compatible, you should be able to compile your stable programs with nightly Rust with clippy plugged in to circumvent this.
Add in your Cargo.toml:
toml
[dependencies]
clippy = "*"
You then need to add #![feature(plugin)] and #![plugin(clippy)] to the top
of your crate entry point (main.rs or lib.rs).
Sample main.rs:
```rust
fn main(){ let x = Some(1u8); match x { Some(y) => println!("{:?}", y), _ => () } } ```
Produces this warning:
terminal
src/main.rs:8:5: 11:6 warning: you seem to be trying to use match for destructuring a single type. Consider using `if let`, #[warn(single_match)] on by default
src/main.rs:8 match x {
src/main.rs:9 Some(y) => println!("{:?}", y),
src/main.rs:10 _ => ()
src/main.rs:11 }
src/main.rs:8:5: 11:6 help: Try
if let Some(y) = x { println!("{:?}", y) }
cargo clippy)An alternate way to use clippy is by installing clippy through cargo as a cargo subcommand.
terminal
cargo install clippy
Now you can run clippy by invoking cargo clippy, or
rustup run nightly cargo clippy directly from a directory that is usually
compiled with stable.
In case you are not using rustup, you need to set the environment flag
SYSROOT during installation so clippy knows where to find librustc and
similar crates.
terminal
SYSROOT=/path/to/rustc/sysroot cargo install clippy
To have cargo compile your crate with clippy without needing #![plugin(clippy)]
in your code, you can use:
terminal
cargo rustc -- -L /path/to/clippy_so -Z extra-plugins=clippy
Note: Be sure that clippy was compiled with the same version of rustc that cargo invokes here!
If you want to make clippy an optional dependency, you can do the following:
In your Cargo.toml:
```toml [dependencies] clippy = {version = "*", optional = true}
[features] default = [] ```
And, in your main.rs or lib.rs:
```rust
```
Then build by enabling the feature: cargo build --features "clippy"
Instead of adding the cfg_attr attributes you can also run clippy on demand:
cargo rustc --features clippy -- -Z no-trans -Z extra-plugins=clippy
(the -Z no trans, while not neccessary, will stop the compilation process after
typechecking (and lints) have completed, which can significantly reduce the runtime).
Some lints can be configured in a clippy.toml file. It contains basic variable = value mapping eg.
toml
blacklisted-names = ["toto", "tata", "titi"]
cyclomatic-complexity-threshold = 30
See the wiki for more information about which lints can be configured and the meaning of the variables.
You can also specify the path to the configuration file with:
```rust
```
To deactivate the “for further information visit wiki-link” message you can
define the CLIPPY_DISABLE_WIKI_LINKS environment variable.
You can add options to allow/warn/deny:
the whole set of Warn lints using the clippy lint group (#![deny(clippy)])
all lints using both the clippy and clippy_pedantic lint groups (#![deny(clippy)],
#![deny(clippy_pedantic)]). Note that clippy_pedantic contains some very aggressive
lints prone to false positives.
only some lints (#![deny(single_match, box_vec)], etc)
allow/warn/deny can be limited to a single function or module using #[allow(...)], etc
Note: deny produces errors instead of warnings.
clippy-service is a rust web initiative providing rust-clippy as a web service.
Both projects are independent and maintained by different people
(even if some clippy-service's contributions are authored by some rust-clippy members).
You can check out this great service at clippy.bashy.io.
Licensed under MPL. If you're having issues with the license, let me know and I'll try to change it to something more permissive.