A collection of lints to catch common mistakes and improve your Rust code.
Table of contents:
Since this is a tool for helping the developer of a library or application write better code, it is recommended not to include clippy as a hard dependency. Options include using it as an optional dependency, as a cargo subcommand, or as an included feature during build. All of these options are detailed below.
As a general rule clippy will only work with the latest Rust nightly for now.
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 necessary, will stop the compilation process after
typechecking (and lints) have completed, which can significantly reduce the runtime).
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/dir/ -Z extra-plugins=clippy
Note: Be sure that clippy was compiled with the same version of rustc that cargo invokes here!
Note: This is not a recommended installation method.
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) }
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.
For convenience, cargo clippy automatically defines a cargo-clippy
features. This lets you set lints level and compile with or without clippy
transparently:
```rust
```
There are 206 lints included in this crate:
name | default | triggers on
-----------------------------------------------------------------------------------------------------------------------------|---------|----------------------------------------------------------------------------------------------------------------------------------
absurdextremecomparisons | warn | a comparison with a maximum or minimum value that is always true or false
almostswapped | warn | foo = bar; bar = foo sequence
approxconstant | warn | the approximate of a known float constant (in std::fXX::consts)
assignoppattern | warn | assigning the result of an operation on a variable to that same variable
assignops | allow | any compound assignment operation
badbitmask | warn | expressions of the form _ & mask == select that will only ever return true or false
blacklistedname | warn | usage of a blacklisted/placeholder name
blockinifconditionexpr | warn | braces that can be eliminated in conditions, e.g. if { true } ...
blockinifconditionstmt | warn | complex blocks in conditions, e.g. if { let x = true; x } ...
boolcomparison | warn | comparing a variable to a boolean, e.g. if x == true
borrowedbox | warn | a borrow of a boxed type
boxvec | warn | usage of Box<Vec<T>>, vector elements are already on the heap
boxedlocal | warn | using Box<T> where unnecessary
builtintypeshadow | warn | shadowing a builtin type
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, probably not intended
cmpnull | warn | comparing a pointer to a null pointer, suggesting to use .is_null() instead.
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 | functions that should be split up into multiple functions
deprecatedsemver | warn | use of #[deprecated(since = "x")] where x is not semver
derefaddrof | warn | use of *& or *&mut in an expression
derivehashxoreq | warn | deriving Hash but implementing PartialEq explicitly
divergingsubexpression | warn | whether an expression contains a diverging sub expression
docmarkdown | warn | presence of _, :: or camel-case outside backticks in documentation
doubleneg | warn | --x, which is a double negation of x and not a pre-decrement as in C/C++
doubleparens | warn | Warn on unnecessary double parentheses
dropcopy | warn | calls to std::mem::drop with a value that implements Copy
dropref | warn | calls to std::mem::drop with a reference instead of an owned value
duplicateunderscoreargument | warn | function arguments having names which only differ by an underscore
emptyenum | allow | enum with no variants
emptyloop | warn | empty loop {}, which should block or sleep
enumclikeunportablevariant | warn | C-like enums that are repr(isize/usize) and have values that don't fit into an i32
enumglobuse | allow | use items that import all variants of an enum
enumvariantnames | warn | 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)
evalorderdependence | warn | whether a variable read occurs before a write depends on sub-expression evaluation order
explimplcloneoncopy | warn | implementing Clone explicitly on Copy types
explicitcounterloop | warn | for-looping with an explicit counter when _.enumerate() would do
explicitintoiterloop | warn | for-looping over _.into_iter() when _ would do
explicititerloop | warn | for-looping over _.iter() or _.iter_mut() when &_ or &mut _ would do
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 instead of comparing difference with an epsilon
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
forgetcopy | warn | calls to std::mem::forget with a value that implements Copy
forgetref | warn | calls to std::mem::forget with a reference instead of an owned value
getunwrap | warn | using .get().unwrap() or .get_mut().unwrap() when using [] would work instead
identityop | warn | using identity operations, e.g. x + 0 or y / 1
ifletredundantpatternmatching | warn | use the proper utility function avoiding an if let
ifletsomeresult | warn | usage of ok() in if let Some(pat) statements is unnecessary, match on Ok(pat) instead
ifnotelse | allow | 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
inconsistentdigitgrouping | warn | integer literals with digits grouped inconsistently
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 | use of #[inline(always)]
integerarithmetic | allow | any integer arithmetic statement
invalidregex | deny | invalid regular expressions
invalidupcastcomparisons | allow | a comparison involving an upcast which is always true or false
itemsafterstatements | allow | blocks where an item comes after a statement
iterclonedcollect | warn | using .cloned().collect() on slice to create a Vec
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
iterskipnext | warn | using .skip(x).next() on an iterator
iteratorstepbyzero | warn | using Iterator::step_by(0), which produces an infinite iterator
largedigitgroups | warn | grouping digits into groups that are too large
largeenumvariant | warn | large size difference between variants on an enum
lenwithoutisempty | warn | traits or impls with a public len method but no corresponding is_empty method
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 | boolean expressions that contain terminals which can be eliminated
manualswap | warn | manual swap of two variables
manysinglecharnames | warn | too many single character bindings
mapclone | warn | using .map(|x| x.clone()) to clone an iterator or option's contents
mapentry | warn | use of contains_key followed by insert on a HashMap or BTreeMap
matchbool | warn | a match on a boolean expression instead of an if..else block
matchoverlappingarm | warn | a match with overlapping arms
matchrefpats | warn | a match or if let with all arms prefixed with & instead of deref-ing the match expression
matchsamearms | warn | match with identical arm bodies
matchwilderrarm | warn | a match with Err(_) arm and take drastic actions
memforget | allow | mem::forget usage on Drop types, 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
missingdocsinprivateitems | allow | detects missing documentation for public and private members
mixedcasehexliterals | warn | hex literals whose letter digits are not consistently upper- or lowercased
moduleinception | warn | modules that have the same name as their parent module
moduloone | warn | taking a number modulo 1, which always returns 0
mutfromref | warn | fns that create mutable refs from immutable ref args
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
naivebytecount | warn | use of naive <slice>.filter(|&x| x == y).count() to count byte values
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
needlessborrowedreference | warn | taking a needless borrowed reference
needlesscontinue | warn | continue statements that can be replaced by a rearrangement of code
needlesslifetimes | warn | using explicit lifetimes for references in function arguments when elision rules would allow omitting them
needlesspassbyvalue | warn | functions taking arguments by value, but not consuming them in its body
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 | multiplying integers with -1
neverloop | warn | any loop that will always break or return
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 instead of using the \\u escape
nonminimalbool | allow | 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
opref | warn | taking a reference to satisfy the type constraints on ==
optionmapunwrapor | allow | using Option.map(f).unwrap_or(a), which is more succinctly expressed as map_or(a, f)
optionmapunwraporelse | allow | 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 with a function call, which suggests *or_else
outofboundsindexing | deny | out of bounds constant indexing
overflowcheckconditional | warn | overflow checks inspired by C which are likely to panic
panicparams | warn | missing parameters in panic! calls
partialeqneimpl | warn | re-implementing PartialEq::ne
possiblemissingcomma | warn | possible missing comma in array
precedence | warn | operations where precedence may be unclear
printstdout | allow | printing on stdout
printwithnewline | warn | using print!() with a format string that ends in a newline
ptrarg | warn | fn arguments of the type &Vec<...> or &String, suggesting to use &[...] or &str instead, respectively
pubenumvariantnames | allow | enums where all variants share a prefix/postfix
rangezipwithlen | warn | zipping iterator with a range when enumerate() would do
redundantclosure | warn | redundant closures, i.e. |a| foo(a) (which can be written as just foo)
redundantclosurecall | warn | throwaway closures called in the expression they are defined
redundantpattern | warn | using name @ _ in a pattern
regexmacro | warn | use of regex!(_) instead of Regex::new(_)
resultunwrapused | allow | using Result.unwrap(), which might be better handled
reverserangeloop | warn | iteration 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 | rebinding a name without even using the original value
shortcircuitstatement | warn | using a short circuit boolean condition as a statement
shouldasserteq | warn | using assert macro for asserting equality
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 _ => {}) instead of if let
singlematchelse | allow | a match statement with a two arms where the second arm's pattern is a wildcard instead of if let
stringadd | allow | using x + .. where x is a String instead of push_str()
stringaddassign | allow | using x = x + .. where x is a String instead of push_str()
stringextendchars | warn | using x.extend(s.chars()) where s is a &str or String
stringlitasbytes | warn | calling as_bytes on a string literal instead of using a byte string literal
stutter | allow | 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 declared as ref, in a function argument or a let statement
transmuteptrtoref | warn | transmutes from a pointer to a reference type
trivialregex | warn | trivial regular expressions
typecomplexity | warn | usage of very complex types that might be better factored 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
unnecessarycast | warn | cast to the same type, e.g. x as i32 where x: i32
unnecessarymutpassed | warn | an argument passed as a mutable reference although the callee only demands an immutable reference
unnecessaryoperation | warn | outer expressions with no effect
unneededfieldpattern | warn | struct fields bound to a wildcard instead of using ..
unreadableliteral | warn | long integer literal without underscores
unsaferemovedfromname | warn | unsafe removed from API names on import
unseparatedliteralsuffix | allow | literals whose suffix is not separated by an underscore
unusedcollect | warn | collect()ing an iterator without using the result; this is usually better written as a for loop
unusedioamount | deny | unused written/read amount
unusedlabel | warn | unused labels
unusedlifetimes | warn | unused lifetimes in function definitions
usedebug | allow | use of Debug-based formatting
useself | allow | Unnecessary structure name repetition whereas Self is applicable
usedunderscorebinding | allow | using a binding which is prefixed with an underscore
uselessattribute | warn | use of lint attributes on extern crate items
uselessformat | warn | useless use of format!
uselessletifseq | warn | 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!
verbosebitmask | warn | expressions where a bit mask is less readable than the corresponding method call
whileletloop | warn | loop { if let { ... } else break }, which 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
zeroprefixedliteral | warn | integer literals starting with 0
zeroptr | warn | using 0 as *{const, mut} T
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!
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.