[](https://travis-ci.org/rust-lang-nursery/rust-clippy)
[](https://ci.appveyor.com/project/rust-lang-libs/rust-clippy)
[](https://crates.io/crates/clippy)
-[](#license)
+[](#license)
A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code.
-[There are 273 lints included in this crate!](https://rust-lang-nursery.github.io/rust-clippy/master/index.html)
+[There are 279 lints included in this crate!](https://rust-lang-nursery.github.io/rust-clippy/master/index.html)
We have a bunch of lint categories to allow you to choose how much Clippy is supposed to ~~annoy~~ help you:
-* `clippy` (everything that has no false positives)
-* `clippy_pedantic` (everything)
-* `clippy_nursery` (new lints that aren't quite ready yet)
-* `clippy_style` (code that should be written in a more idiomatic way)
-* `clippy_complexity` (code that does something simple but in a complex way)
-* `clippy_perf` (code that can be written in a faster way)
-* `clippy_cargo` (checks against the cargo manifest)
-* **`clippy_correctness`** (code that is just outright wrong or very very useless)
+* `clippy::all` (everything that has no false positives)
+* `clippy::pedantic` (everything)
+* `clippy::nursery` (new lints that aren't quite ready yet)
+* `clippy::style` (code that should be written in a more idiomatic way)
+* `clippy::complexity` (code that does something simple but in a complex way)
+* `clippy::perf` (code that can be written in a faster way)
+* `clippy::cargo` (checks against the cargo manifest)
+* **`clippy::correctness`** (code that is just outright wrong or very very useless)
More to come, please [file an issue](https://github.com/rust-lang-nursery/rust-clippy/issues) if you have ideas!
#### Step 1: Install rustup
You can install [rustup](http://rustup.rs/) on supported platforms. This will help
-us install clippy and its dependencies.
+us install Clippy and its dependencies.
If you already have rustup installed, update to ensure you have the latest
rustup and compiler:
rustup update
```
-#### Step 2: Install nightly toolchain
+#### Step 2: Install Clippy
-As a general rule Clippy will only work with the *latest* Rust nightly for now.
-
-To install Rust nightly with [rustup](https://rustup.rs/):
+Once you have rustup and the latest stable release (at least Rust 1.29) installed, run the following command:
```terminal
-rustup install nightly
+rustup component add clippy-preview
```
-#### Step 3: Install clippy
-
-Once you have rustup and the nightly toolchain installed, run the following command:
-
-```terminal
-rustup component add clippy-preview --toolchain=nightly
-```
+Now you can run Clippy by invoking `cargo clippy`.
-Now you can run Clippy by invoking `cargo +nightly clippy`.
+If it says that it can't find the `clippy` subcommand, please run `rustup self update`
### Running Clippy from the command line without installing it
*[Note](https://github.com/rust-lang-nursery/rust-clippy/wiki#a-word-of-warning):*
Be sure that Clippy was compiled with the same version of rustc that cargo invokes here!
+### Travis CI
+
+You can add Clippy to Travis CI in the same way you use it locally:
+
+```yml
+language: rust
+rust:
+ - stable
+ - beta
+before_script:
+ - rustup component add clippy-preview
+script:
+ - cargo clippy
+ # if you want the build job to fail when encountering warnings, use
+ - cargo clippy -- -D warnings
+ # in order to also check tests and none-default crate features, use
+ - cargo clippy --all-targets --all-features -- -D warnings
+ - cargo test
+ # etc.
+```
+
## Configuration
-Some lints can be configured in a TOML file named with `clippy.toml` or `.clippy.toml`. It contains basic `variable = value` mapping eg.
+Some lints can be configured in a TOML file named `clippy.toml` or `.clippy.toml`. It contains a basic `variable = value` mapping eg.
```toml
blacklisted-names = ["toto", "tata", "titi"]
### Allowing/denying lints
-You can add options to `allow`/`warn`/`deny`:
+You can add options to your code to `allow`/`warn`/`deny` Clippy lints:
-* the whole set of `Warn` lints using the `clippy` lint group (`#![deny(clippy)]`)
+* the whole set of `Warn` lints using the `clippy` lint group (`#![deny(clippy::all)]`)
-* all lints using both the `clippy` and `clippy_pedantic` lint groups (`#![deny(clippy)]`,
- `#![deny(clippy_pedantic)]`). Note that `clippy_pedantic` contains some very aggressive
+* all lints using both the `clippy` and `clippy::pedantic` lint groups (`#![deny(clippy::all)]`,
+ `#![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)
+* only some lints (`#![deny(clippy::single_match, clippy::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`
-feature. This lets you set lint levels and compile with or without Clippy
-transparently:
-
+Note: To use the new `clippy::lint_name` syntax, `#![feature(tool_lints)]` has to be activated
+currently. If you want to compile your code with the stable toolchain you can use a `cfg_attr` to
+activate the `tool_lints` feature:
```rust
-#[cfg_attr(feature = "cargo-clippy", allow(needless_lifetimes))]
+#![cfg_attr(feature = "cargo-clippy", feature(tool_lints))]
+#![cfg_attr(feature = "cargo-clippy", allow(clippy::lint_name))]
```
-## Updating rustc
-
-Sometimes, rustc moves forward without Clippy catching up. Therefore updating
-rustc may leave Clippy a non-functional state until we fix the resulting
-breakage.
+For this to work you have to use Clippy on the nightly toolchain: `cargo +nightly clippy`. If you
+want to use Clippy with the stable toolchain, you can stick to the old unscoped method to
+enable/disable Clippy lints until `tool_lints` are stable:
+```rust
+#![cfg_attr(feature = "cargo-clippy", allow(clippy_lint))]
+```
-You can use the [rust-update](rust-update) script to update rustc only if
-Clippy would also update correctly.
+If you do not want to include your lint levels in your code, you can globally enable/disable lints by passing extra flags to clippy during the run: `cargo clippy -- -A lint_name` will run clippy with `lint_name` disabled and `cargo clippy -- -W lint_name` will run it with that enabled. On newer compilers you may need to use `clippy::lint_name` instead.
## License
-Licensed under [MPL](https://www.mozilla.org/MPL/2.0/).
-If you're having issues with the license, let me know and I'll try to change it to something more permissive.
+Copyright 2014-2018 The Rust Project Developers
+
+Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+<LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+option. All files in the project carrying such notice may not be
+copied, modified, or distributed except according to those terms.
projects / rust.git / blobdiff