Hello fellow Rustacean! Great to see your interest in compiler internals and lints!
+**First**: if you're unsure or afraid of _anything_, just ask or submit the issue or pull request anyway. You won't be yelled at for giving it your best effort. The worst that can happen is that you'll be politely asked to change something. We appreciate any sort of contributions, and don't want a wall of rules to get in the way of that.
+
Clippy welcomes contributions from everyone. There are many ways to contribute to Clippy and the following document explains how
you can contribute and how to get started.
If you have any questions about contributing or need help with anything, feel free to ask questions on issues or
All contributors are expected to follow the [Rust Code of Conduct](http://www.rust-lang.org/conduct.html).
+* [Getting started](#getting-started)
+ * [Finding something to fix/improve](#finding-something-to-fiximprove)
+* [Writing code](#writing-code)
+ * [Author lint](#author-lint)
+ * [Documentation](#documentation)
+ * [Running test suite](#running-test-suite)
+ * [Testing manually](#testing-manually)
+ * [How Clippy works](#how-clippy-works)
+ * [Fixing nightly build failures](#fixing-nightly-build-failures)
+* [Contributions](#contributions)
+
## Getting started
High level approach:
lot of methods that are useful, though one of the most useful would be `expr_ty` (gives the type of
an AST expression). `match_def_path()` in Clippy's `utils` module can also be useful.
-### Writing code
+## Writing code
Compiling clippy from scratch can take almost a minute or more depending on your machine.
However, since Rust 1.24.0 incremental compilation is enabled by default and compile times for small changes should be quick.
of this.
-#### Author lint
+### Author lint
There is also the internal `author` lint to generate clippy code that detects the offending pattern. It does not work for all of the Rust syntax, but can give a good starting point.
```rust
// ./tests/ui/my_lint.rs
-
-// The custom_attribute needs to be enabled for the author lint to work
-#![feature(plugin, custom_attribute)]
-
fn main() {
- #[clippy(author)]
+ #[clippy::author]
let arr: [i32; 1] = [7]; // Replace line with the code you want to match
}
```
If the command was executed successfully, you can copy the code over to where you are implementing your lint.
-#### Documentation
+### Documentation
Please document your lint with a doc comment akin to the following:
### Running test suite
-Clippy uses UI tests. UI tests check that the output of the compiler is exactly as expected.
-Of course there's little sense in writing the output yourself or copying it around.
-Therefore you can simply run `tests/ui/update-all-references.sh` (after running
-`cargo test`) and check whether the output looks as you expect with `git diff`. Commit all
-`*.stderr` files, too.
+Use `cargo test` to run the whole testsuite.
If you don't want to wait for all tests to finish, you can also execute a single test file by using `TESTNAME` to specify the test to run:
TESTNAME=ui/empty_line_after_outer_attr cargo test --test compile-test
```
+Clippy uses UI tests. UI tests check that the output of the compiler is exactly as expected.
+Of course there's little sense in writing the output yourself or copying it around.
+Therefore you should use `tests/ui/update-all-references.sh` (after running
+`cargo test`) and check whether the output looks as you expect with `git diff`. Commit all
+`*.stderr` files, too.
+
### Testing manually
Manually testing against an example file is useful if you have added some
`println!`s and test suite output becomes unreadable. To try clippy with your
local modifications, run `cargo run --bin clippy-driver -- -L ./target/debug input.rs` from the
-working copy root. Your test file, here `input.rs`, needs to have clippy
-enabled as a plugin:
-
-```rust
-#![feature(plugin)]
-#![plugin(clippy)]
-```
+working copy root.
### How Clippy works
That's why the `else_if_without_else` example uses the `register_early_lint_pass` function. Because the [actual lint logic][else_if_without_else] does not depend on any type information.
+### Fixing nightly build failures
+
+Clippy will sometimes break with new nightly version releases. This is expected because Clippy still depends on nightly Rust. Most of the times we have to adapt to the changes and only very rarely there's an actual bug in rust.
+
+In order to find out why Clippy does not work properly with a new nightly version, you can use the [rust-toolstate commit history][toolstate_commit_history].
+You will then have to look for the last commit that contains `test-pass -> build-fail` or `test-pass` -> `test-fail` for the `clippy-driver` component. [Here][toolstate_commit] is an example.
+
+The commit message contains a link to the PR. The PRs are usually small enough to discover the breaking API change and if they are bigger, they likely include some discussion that may help you to fix Clippy.
+
+Fixing nightly build failures is also a good way to learn about actual rustc internals.
+
## Contributions
Contributions to Clippy should be made in the form of GitHub pull requests. Each pull request will
[reg_late_lint_pass]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_plugin/registry/struct.Registry.html#method.register_late_lint_pass
[early_lint_pass]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc/lint/trait.EarlyLintPass.html
[late_lint_pass]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc/lint/trait.LateLintPass.html
+[toolstate_commit_history]: https://github.com/rust-lang-nursery/rust-toolstate/commits/master
+[toolstate_commit]: https://github.com/rust-lang-nursery/rust-toolstate/commit/6ce0459f6bfa7c528ae1886492a3e0b5ef0ee547
projects / rust.git / blobdiff