2018-07-05 12:37:50 +02:00
|
|
|
# Contributing to Clippy
|
2015-08-11 15:03:56 +02:00
|
|
|
|
|
|
|
Hello fellow Rustacean! Great to see your interest in compiler internals and lints!
|
|
|
|
|
2020-01-21 16:39:58 +01:00
|
|
|
**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.
|
2018-05-14 19:11:56 +02:00
|
|
|
|
2020-01-21 16:39:58 +01:00
|
|
|
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
|
2020-09-16 17:06:43 +02:00
|
|
|
anything, feel free to ask questions on issues or visit the `#clippy` on [Zulip].
|
2018-04-17 08:33:22 +02:00
|
|
|
|
2020-03-10 21:40:53 +01:00
|
|
|
All contributors are expected to follow the [Rust Code of Conduct].
|
2018-04-17 08:33:22 +02:00
|
|
|
|
2020-05-28 21:42:01 +02:00
|
|
|
- [Contributing to Clippy](#contributing-to-clippy)
|
|
|
|
- [Getting started](#getting-started)
|
2020-12-01 01:26:02 +01:00
|
|
|
- [High level approach](#high-level-approach)
|
2020-05-28 21:42:01 +02:00
|
|
|
- [Finding something to fix/improve](#finding-something-to-fiximprove)
|
|
|
|
- [Writing code](#writing-code)
|
|
|
|
- [Getting code-completion for rustc internals to work](#getting-code-completion-for-rustc-internals-to-work)
|
|
|
|
- [How Clippy works](#how-clippy-works)
|
|
|
|
- [Fixing build failures caused by Rust](#fixing-build-failures-caused-by-rust)
|
2020-12-01 01:26:02 +01:00
|
|
|
- [Patching git-subtree to work with big repos](#patching-git-subtree-to-work-with-big-repos)
|
|
|
|
- [Performing the sync](#performing-the-sync)
|
|
|
|
- [Syncing back changes in Clippy to [`rust-lang/rust`]](#syncing-back-changes-in-clippy-to-rust-langrust)
|
|
|
|
- [Defining remotes](#defining-remotes)
|
2020-05-28 21:42:01 +02:00
|
|
|
- [Issue and PR triage](#issue-and-pr-triage)
|
|
|
|
- [Bors and Homu](#bors-and-homu)
|
|
|
|
- [Contributions](#contributions)
|
2018-04-27 08:52:16 +02:00
|
|
|
|
2020-09-16 17:06:43 +02:00
|
|
|
[Zulip]: https://rust-lang.zulipchat.com/#narrow/stream/clippy
|
2020-03-10 21:40:53 +01:00
|
|
|
[Rust Code of Conduct]: https://www.rust-lang.org/policies/code-of-conduct
|
|
|
|
|
2015-08-11 15:03:56 +02:00
|
|
|
## Getting started
|
|
|
|
|
2020-08-07 23:21:14 +02:00
|
|
|
**Note: If this is your first time contributing to Clippy, you should
|
|
|
|
first read the [Basics docs](doc/basics.md).**
|
|
|
|
|
|
|
|
### High level approach
|
2017-08-07 17:33:27 +02:00
|
|
|
|
|
|
|
1. Find something to fix/improve
|
|
|
|
2. Change code (likely some file in `clippy_lints/src/`)
|
2020-08-07 23:21:14 +02:00
|
|
|
3. Follow the instructions in the [Basics docs](doc/basics.md) to get set up
|
2020-03-08 21:57:42 +01:00
|
|
|
4. Run `cargo test` in the root directory and wiggle code until it passes
|
|
|
|
5. Open a PR (also can be done after 2. if you run into problems)
|
2017-08-07 17:33:27 +02:00
|
|
|
|
|
|
|
### Finding something to fix/improve
|
|
|
|
|
2020-04-04 17:02:05 +02:00
|
|
|
All issues on Clippy are mentored, if you want help with a bug just ask
|
|
|
|
@Manishearth, @flip1995, @phansch or @yaahc.
|
2015-08-11 15:03:56 +02:00
|
|
|
|
2020-03-10 21:40:53 +01:00
|
|
|
Some issues are easier than others. The [`good first issue`] label can be used to find the easy issues.
|
|
|
|
If you want to work on an issue, please leave a comment so that we can assign it to you!
|
2015-08-11 15:03:56 +02:00
|
|
|
|
2020-03-10 21:40:53 +01:00
|
|
|
There are also some abandoned PRs, marked with [`S-inactive-closed`].
|
2018-12-27 17:34:17 +01:00
|
|
|
Pretty often these PRs are nearly completed and just need some extra steps
|
|
|
|
(formatting, addressing review comments, ...) to be merged. If you want to
|
|
|
|
complete such a PR, please leave a comment in the PR and open a new one based
|
|
|
|
on it.
|
|
|
|
|
2020-03-10 21:40:53 +01:00
|
|
|
Issues marked [`T-AST`] involve simple matching of the syntax tree structure,
|
|
|
|
and are generally easier than [`T-middle`] issues, which involve types
|
2015-08-11 15:03:56 +02:00
|
|
|
and resolved paths.
|
|
|
|
|
2020-03-10 21:40:53 +01:00
|
|
|
[`T-AST`] issues will generally need you to match against a predefined syntax structure.
|
|
|
|
To figure out how this syntax structure is encoded in the AST, it is recommended to run
|
|
|
|
`rustc -Z ast-json` on an example of the structure and compare with the [nodes in the AST docs].
|
2020-03-10 22:35:46 +01:00
|
|
|
Usually the lint will end up to be a nested series of matches and ifs, [like so][deep-nesting].
|
|
|
|
But we can make it nest-less by using [if_chain] macro, [like this][nest-less].
|
2015-08-11 15:03:56 +02:00
|
|
|
|
2020-10-27 15:32:38 +01:00
|
|
|
[`E-medium`] issues are generally pretty easy too, though it's recommended you work on an [`good first issue`]
|
2020-10-29 16:24:29 +01:00
|
|
|
first. Sometimes they are only somewhat involved code wise, but not difficult per-se.
|
2020-12-09 17:20:38 +01:00
|
|
|
Note that [`E-medium`] issues may require some knowledge of Clippy internals or some
|
|
|
|
debugging to find the actual problem behind the issue.
|
2018-04-01 15:31:25 +02:00
|
|
|
|
2020-03-10 21:40:53 +01:00
|
|
|
[`T-middle`] issues can be more involved and require verifying types. The [`ty`] module contains a
|
2015-08-11 15:03:56 +02:00
|
|
|
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.
|
|
|
|
|
2020-03-10 21:40:53 +01:00
|
|
|
[`good first issue`]: https://github.com/rust-lang/rust-clippy/labels/good%20first%20issue
|
|
|
|
[`S-inactive-closed`]: https://github.com/rust-lang/rust-clippy/pulls?q=is%3Aclosed+label%3AS-inactive-closed
|
|
|
|
[`T-AST`]: https://github.com/rust-lang/rust-clippy/labels/T-AST
|
|
|
|
[`T-middle`]: https://github.com/rust-lang/rust-clippy/labels/T-middle
|
|
|
|
[`E-medium`]: https://github.com/rust-lang/rust-clippy/labels/E-medium
|
2020-04-04 17:01:42 +02:00
|
|
|
[`ty`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty
|
2020-03-10 10:50:06 +01:00
|
|
|
[nodes in the AST docs]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast/ast/
|
2020-03-10 22:35:46 +01:00
|
|
|
[deep-nesting]: https://github.com/rust-lang/rust-clippy/blob/557f6848bd5b7183f55c1e1522a326e9e1df6030/clippy_lints/src/mem_forget.rs#L29-L43
|
|
|
|
[if_chain]: https://docs.rs/if_chain/*/if_chain
|
|
|
|
[nest-less]: https://github.com/rust-lang/rust-clippy/blob/557f6848bd5b7183f55c1e1522a326e9e1df6030/clippy_lints/src/bit_mask.rs#L124-L150
|
2020-03-10 10:50:06 +01:00
|
|
|
|
2018-04-27 08:52:16 +02:00
|
|
|
## Writing code
|
2017-08-07 17:33:27 +02:00
|
|
|
|
2020-04-04 17:02:05 +02:00
|
|
|
Have a look at the [docs for writing lints][adding_lints] for more details.
|
2015-08-14 11:30:39 +02:00
|
|
|
|
2018-11-28 14:39:25 +01:00
|
|
|
If you want to add a new lint or change existing ones apart from bugfixing, it's
|
2019-01-20 22:25:36 +01:00
|
|
|
also a good idea to give the [stability guarantees][rfc_stability] and
|
2018-11-28 08:11:28 +01:00
|
|
|
[lint categories][rfc_lint_cats] sections of the [Clippy 1.0 RFC][clippy_rfc] a
|
|
|
|
quick read.
|
2018-04-02 14:38:28 +02:00
|
|
|
|
2020-03-10 21:40:53 +01:00
|
|
|
[adding_lints]: https://github.com/rust-lang/rust-clippy/blob/master/doc/adding_lints.md
|
|
|
|
[clippy_rfc]: https://github.com/rust-lang/rfcs/blob/master/text/2476-clippy-uno.md
|
|
|
|
[rfc_stability]: https://github.com/rust-lang/rfcs/blob/master/text/2476-clippy-uno.md#stability-guarantees
|
|
|
|
[rfc_lint_cats]: https://github.com/rust-lang/rfcs/blob/master/text/2476-clippy-uno.md#lint-audit-and-categories
|
|
|
|
|
2020-05-28 21:42:01 +02:00
|
|
|
## Getting code-completion for rustc internals to work
|
|
|
|
|
2020-07-22 16:39:58 +02:00
|
|
|
Unfortunately, [`rust-analyzer`][ra_homepage] does not (yet?) understand how Clippy uses compiler-internals
|
|
|
|
using `extern crate` and it also needs to be able to read the source files of the rustc-compiler which are not
|
|
|
|
available via a `rustup` component at the time of writing.
|
|
|
|
To work around this, you need to have a copy of the [rustc-repo][rustc_repo] available which can be obtained via
|
|
|
|
`git clone https://github.com/rust-lang/rust/`.
|
|
|
|
Then you can run a `cargo dev` command to automatically make Clippy use the rustc-repo via path-dependencies
|
|
|
|
which rust-analyzer will be able to understand.
|
|
|
|
Run `cargo dev ra-setup --repo-path <repo-path>` where `<repo-path>` is an absolute path to the rustc repo
|
|
|
|
you just cloned.
|
|
|
|
The command will add path-dependencies pointing towards rustc-crates inside the rustc repo to
|
2020-05-28 21:42:01 +02:00
|
|
|
Clippys `Cargo.toml`s and should allow rust-analyzer to understand most of the types that Clippy uses.
|
|
|
|
Just make sure to remove the dependencies again before finally making a pull request!
|
|
|
|
|
|
|
|
[ra_homepage]: https://rust-analyzer.github.io/
|
|
|
|
[rustc_repo]: https://github.com/rust-lang/rust/
|
|
|
|
|
2018-12-21 08:11:06 +01:00
|
|
|
## How Clippy works
|
2018-04-21 11:42:28 +02:00
|
|
|
|
2020-03-10 10:50:06 +01:00
|
|
|
[`clippy_lints/src/lib.rs`][lint_crate_entry] imports all the different lint modules and registers in the [`LintStore`].
|
|
|
|
For example, the [`else_if_without_else`][else_if_without_else] lint is registered like this:
|
2018-04-21 11:42:28 +02:00
|
|
|
|
|
|
|
```rust
|
|
|
|
// ./clippy_lints/src/lib.rs
|
|
|
|
|
|
|
|
// ...
|
|
|
|
pub mod else_if_without_else;
|
|
|
|
// ...
|
|
|
|
|
2020-03-10 10:50:06 +01:00
|
|
|
pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf: &Conf) {
|
2018-04-21 11:42:28 +02:00
|
|
|
// ...
|
2020-03-10 10:50:06 +01:00
|
|
|
store.register_early_pass(|| box else_if_without_else::ElseIfWithoutElse);
|
2018-04-21 11:42:28 +02:00
|
|
|
// ...
|
|
|
|
|
2020-03-10 10:50:06 +01:00
|
|
|
store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
|
2018-04-21 11:42:28 +02:00
|
|
|
// ...
|
2020-03-10 10:50:06 +01:00
|
|
|
LintId::of(&else_if_without_else::ELSE_IF_WITHOUT_ELSE),
|
2018-04-21 11:42:28 +02:00
|
|
|
// ...
|
|
|
|
]);
|
|
|
|
}
|
|
|
|
```
|
|
|
|
|
2020-03-10 10:50:06 +01:00
|
|
|
The [`rustc_lint::LintStore`][`LintStore`] provides two methods to register lints:
|
|
|
|
[register_early_pass][reg_early_pass] and [register_late_pass][reg_late_pass]. Both take an object
|
2020-01-21 16:39:58 +01:00
|
|
|
that implements an [`EarlyLintPass`][early_lint_pass] or [`LateLintPass`][late_lint_pass] respectively. This is done in
|
|
|
|
every single lint. It's worth noting that the majority of `clippy_lints/src/lib.rs` is autogenerated by `cargo dev
|
2020-03-10 10:50:06 +01:00
|
|
|
update_lints`. When you are writing your own lint, you can use that script to save you some time.
|
2018-04-21 11:42:28 +02:00
|
|
|
|
|
|
|
```rust
|
|
|
|
// ./clippy_lints/src/else_if_without_else.rs
|
|
|
|
|
2020-02-11 04:37:25 +01:00
|
|
|
use rustc_lint::{EarlyLintPass, EarlyContext};
|
2018-04-21 11:42:28 +02:00
|
|
|
|
|
|
|
// ...
|
|
|
|
|
|
|
|
pub struct ElseIfWithoutElse;
|
|
|
|
|
|
|
|
// ...
|
|
|
|
|
|
|
|
impl EarlyLintPass for ElseIfWithoutElse {
|
|
|
|
// ... the functions needed, to make the lint work
|
|
|
|
}
|
|
|
|
```
|
|
|
|
|
2020-01-21 16:39:58 +01:00
|
|
|
The difference between `EarlyLintPass` and `LateLintPass` is that the methods of the `EarlyLintPass` trait only provide
|
|
|
|
AST information. The methods of the `LateLintPass` trait are executed after type checking and contain type information
|
|
|
|
via the `LateContext` parameter.
|
2018-04-21 11:42:28 +02:00
|
|
|
|
2020-03-10 21:40:53 +01:00
|
|
|
That's why the `else_if_without_else` example uses the `register_early_pass` function. Because the
|
|
|
|
[actual lint logic][else_if_without_else] does not depend on any type information.
|
2020-03-10 10:50:06 +01:00
|
|
|
|
2020-03-10 21:40:53 +01:00
|
|
|
[lint_crate_entry]: https://github.com/rust-lang/rust-clippy/blob/master/clippy_lints/src/lib.rs
|
|
|
|
[else_if_without_else]: https://github.com/rust-lang/rust-clippy/blob/4253aa7137cb7378acc96133c787e49a345c2b3c/clippy_lints/src/else_if_without_else.rs
|
2020-03-10 10:50:06 +01:00
|
|
|
[`LintStore`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/struct.LintStore.html
|
2020-03-10 21:40:53 +01:00
|
|
|
[reg_early_pass]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/struct.LintStore.html#method.register_early_pass
|
|
|
|
[reg_late_pass]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/struct.LintStore.html#method.register_late_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
|
2020-03-10 10:50:06 +01:00
|
|
|
|
2020-12-09 17:20:38 +01:00
|
|
|
## Syncing changes between Clippy and [`rust-lang/rust`]
|
2018-05-12 10:33:35 +02:00
|
|
|
|
2020-11-29 18:08:47 +01:00
|
|
|
Clippy currently gets built with a pinned nightly version.
|
2020-05-03 15:59:57 +02:00
|
|
|
|
2020-11-29 18:08:47 +01:00
|
|
|
In the `rust-lang/rust` repository, where rustc resides, there's a copy of Clippy
|
|
|
|
that compiler hackers modify from time to time to adapt to changes in the unstable
|
|
|
|
API of the compiler.
|
2020-05-03 15:59:57 +02:00
|
|
|
|
2020-12-09 17:20:38 +01:00
|
|
|
We need to sync these changes back to this repository periodically, and the changes
|
|
|
|
made to this repository in the meantime also need to be synced to the `rust-lang/rust` repository.
|
2020-11-29 18:08:47 +01:00
|
|
|
|
2020-12-09 17:20:38 +01:00
|
|
|
To avoid flooding the `rust-lang/rust` PR queue, this two-way sync process is done
|
|
|
|
in a bi-weekly basis if there's no urgent changes. This is done starting on the day of
|
|
|
|
the Rust stable release and then every other week. That way we guarantee that we keep
|
|
|
|
this repo up to date with the latest compiler API, and every feature in Clippy is available
|
|
|
|
for 2 weeks in nightly, before it can get to beta. For reference, the first sync
|
|
|
|
following this cadence was performed the 2020-08-27.
|
|
|
|
|
|
|
|
This process is described in detail in the following sections. For general information
|
|
|
|
about `subtree`s in the Rust repository see [Rust's `CONTRIBUTING.md`][subtree].
|
2020-05-03 15:59:57 +02:00
|
|
|
|
2020-08-23 11:29:06 +02:00
|
|
|
### Patching git-subtree to work with big repos
|
|
|
|
|
|
|
|
Currently there's a bug in `git-subtree` that prevents it from working properly
|
2020-08-23 22:20:55 +02:00
|
|
|
with the [`rust-lang/rust`] repo. There's an open PR to fix that, but it's stale.
|
2020-08-23 11:29:06 +02:00
|
|
|
Before continuing with the following steps, we need to manually apply that fix to
|
|
|
|
our local copy of `git-subtree`.
|
|
|
|
|
|
|
|
You can get the patched version of `git-subtree` from [here][gitgitgadget-pr].
|
|
|
|
Put this file under `/usr/lib/git-core` (taking a backup of the previous file)
|
|
|
|
and make sure it has the proper permissions:
|
|
|
|
|
|
|
|
```bash
|
|
|
|
sudo cp --backup /path/to/patched/git-subtree.sh /usr/lib/git-core/git-subtree
|
|
|
|
sudo chmod --reference=/usr/lib/git-core/git-subtree~ /usr/lib/git-core/git-subtree
|
2020-08-23 22:20:55 +02:00
|
|
|
sudo chown --reference=/usr/lib/git-core/git-subtree~ /usr/lib/git-core/git-subtree
|
2020-08-23 11:29:06 +02:00
|
|
|
```
|
|
|
|
|
|
|
|
_Note:_ The first time running `git subtree push` a cache has to be built. This
|
|
|
|
involves going through the complete Clippy history once. For this you have to
|
|
|
|
increase the stack limit though, which you can do with `ulimit -s 60000`.
|
|
|
|
Make sure to run the `ulimit` command from the same session you call git subtree.
|
|
|
|
|
|
|
|
_Note:_ If you are a Debian user, `dash` is the shell used by default for scripts instead of `sh`.
|
|
|
|
This shell has a hardcoded recursion limit set to 1000. In order to make this process work,
|
|
|
|
you need to force the script to run `bash` instead. You can do this by editing the first
|
|
|
|
line of the `git-subtree` script and changing `sh` to `bash`.
|
|
|
|
|
2020-12-09 17:20:38 +01:00
|
|
|
### Performing the sync from [`rust-lang/rust`] to Clippy
|
2020-08-23 11:29:06 +02:00
|
|
|
|
2020-05-17 01:38:01 +02:00
|
|
|
Here is a TL;DR version of the sync process (all of the following commands have
|
|
|
|
to be run inside the `rust` directory):
|
2020-05-03 15:59:57 +02:00
|
|
|
|
2020-12-09 17:20:38 +01:00
|
|
|
1. Clone the [`rust-lang/rust`] repository or make sure it is up to date.
|
|
|
|
2. Checkout the commit from the latest available nightly. You can get it using `rustup check`.
|
|
|
|
3. Sync the changes to the rust-copy of Clippy to your Clippy fork:
|
2020-05-03 15:59:57 +02:00
|
|
|
```bash
|
|
|
|
# Make sure to change `your-github-name` to your github name in the following command
|
|
|
|
git subtree push -P src/tools/clippy git@github.com:your-github-name/rust-clippy sync-from-rust
|
|
|
|
```
|
2020-08-23 11:29:06 +02:00
|
|
|
|
2020-05-17 01:38:01 +02:00
|
|
|
_Note:_ This will directly push to the remote repository. You can also push
|
|
|
|
to your local copy by replacing the remote address with `/path/to/rust-clippy`
|
|
|
|
directory.
|
2020-05-19 16:36:14 +02:00
|
|
|
|
|
|
|
_Note:_ Most of the time you have to create a merge commit in the
|
|
|
|
`rust-clippy` repo (this has to be done in the Clippy repo, not in the
|
|
|
|
rust-copy of Clippy):
|
|
|
|
```bash
|
2020-05-25 17:11:07 +02:00
|
|
|
git fetch origin && git fetch upstream
|
2020-05-19 16:36:14 +02:00
|
|
|
git checkout sync-from-rust
|
|
|
|
git merge upstream/master
|
|
|
|
```
|
2020-12-09 17:20:38 +01:00
|
|
|
4. Open a PR to `rust-lang/rust-clippy` and wait for it to get merged (to
|
2020-05-03 15:59:57 +02:00
|
|
|
accelerate the process ping the `@rust-lang/clippy` team in your PR and/or
|
2020-09-16 17:06:43 +02:00
|
|
|
~~annoy~~ ask them in the [Zulip] stream.)
|
2020-08-23 11:29:06 +02:00
|
|
|
|
2020-12-09 17:20:38 +01:00
|
|
|
### Performing the sync from Clippy to [`rust-lang/rust`]
|
2020-08-23 22:20:55 +02:00
|
|
|
|
|
|
|
All of the following commands have to be run inside the `rust` directory.
|
2020-08-23 11:29:06 +02:00
|
|
|
|
|
|
|
1. Make sure Clippy itself is up-to-date by following the steps outlined in the previous
|
|
|
|
section if necessary.
|
|
|
|
|
|
|
|
2. Sync the `rust-lang/rust-clippy` master to the rust-copy of Clippy:
|
2020-05-03 15:59:57 +02:00
|
|
|
```bash
|
|
|
|
git checkout -b sync-from-clippy
|
|
|
|
git subtree pull -P src/tools/clippy https://github.com/rust-lang/rust-clippy master
|
|
|
|
```
|
2020-08-23 11:29:06 +02:00
|
|
|
3. Open a PR to [`rust-lang/rust`]
|
2020-05-03 15:59:57 +02:00
|
|
|
|
2020-08-23 11:29:06 +02:00
|
|
|
### Defining remotes
|
|
|
|
|
|
|
|
You may want to define remotes, so you don't have to type out the remote
|
2020-05-17 01:38:01 +02:00
|
|
|
addresses on every sync. You can do this with the following commands (these
|
|
|
|
commands still have to be run inside the `rust` directory):
|
|
|
|
|
|
|
|
```bash
|
|
|
|
# Set clippy-upstream remote for pulls
|
|
|
|
$ git remote add clippy-upstream https://github.com/rust-lang/rust-clippy
|
|
|
|
# Make sure to not push to the upstream repo
|
|
|
|
$ git remote set-url --push clippy-upstream DISABLED
|
|
|
|
# Set clippy-origin remote to your fork for pushes
|
|
|
|
$ git remote add clippy-origin git@github.com:your-github-name/rust-clippy
|
|
|
|
# Set a local remote
|
|
|
|
$ git remote add clippy-local /path/to/rust-clippy
|
|
|
|
```
|
|
|
|
|
|
|
|
You can then sync with the remote names from above, e.g.:
|
|
|
|
|
|
|
|
```bash
|
|
|
|
$ git subtree push -P src/tools/clippy clippy-local sync-from-rust
|
|
|
|
```
|
|
|
|
|
2020-05-19 15:18:16 +02:00
|
|
|
[gitgitgadget-pr]: https://github.com/gitgitgadget/git/pull/493
|
2020-07-09 15:07:15 +02:00
|
|
|
[subtree]: https://rustc-dev-guide.rust-lang.org/contributing.html#external-dependencies-subtree
|
2020-03-10 21:40:53 +01:00
|
|
|
[`rust-lang/rust`]: https://github.com/rust-lang/rust
|
|
|
|
|
2018-12-02 09:33:23 +01:00
|
|
|
## Issue and PR triage
|
|
|
|
|
|
|
|
Clippy is following the [Rust triage procedure][triage] for issues and pull
|
|
|
|
requests.
|
|
|
|
|
|
|
|
However, we are a smaller project with all contributors being volunteers
|
|
|
|
currently. Between writing new lints, fixing issues, reviewing pull requests and
|
|
|
|
responding to issues there may not always be enough time to stay on top of it
|
|
|
|
all.
|
|
|
|
|
|
|
|
Our highest priority is fixing [crashes][l-crash] and [bugs][l-bug]. We don't
|
|
|
|
want Clippy to crash on your code and we want it to be as reliable as the
|
|
|
|
suggestions from Rust compiler errors.
|
|
|
|
|
2018-12-10 07:33:11 +01:00
|
|
|
## Bors and Homu
|
|
|
|
|
|
|
|
We use a bot powered by [Homu][homu] to help automate testing and landing of pull
|
|
|
|
requests in Clippy. The bot's username is @bors.
|
|
|
|
|
|
|
|
You can find the Clippy bors queue [here][homu_queue].
|
|
|
|
|
|
|
|
If you have @bors permissions, you can find an overview of the available
|
|
|
|
commands [here][homu_instructions].
|
|
|
|
|
2020-04-04 23:39:24 +02:00
|
|
|
[triage]: https://forge.rust-lang.org/release/triage-procedure.html
|
2020-10-22 01:51:03 +02:00
|
|
|
[l-crash]: https://github.com/rust-lang/rust-clippy/labels/L-crash
|
|
|
|
[l-bug]: https://github.com/rust-lang/rust-clippy/labels/L-bug
|
2020-03-10 21:40:53 +01:00
|
|
|
[homu]: https://github.com/rust-lang/homu
|
2020-12-01 01:26:02 +01:00
|
|
|
[homu_instructions]: https://bors.rust-lang.org/
|
|
|
|
[homu_queue]: https://bors.rust-lang.org/queue/clippy
|
2020-03-10 21:40:53 +01:00
|
|
|
|
2015-08-11 15:03:56 +02:00
|
|
|
## Contributions
|
|
|
|
|
|
|
|
Contributions to Clippy should be made in the form of GitHub pull requests. Each pull request will
|
|
|
|
be reviewed by a core contributor (someone with permission to land patches) and either landed in the
|
|
|
|
main tree or given feedback for changes that would be required.
|
|
|
|
|
2020-03-10 21:40:53 +01:00
|
|
|
All code in this repository is under the [Apache-2.0] or the [MIT] license.
|
2015-08-12 00:02:20 +02:00
|
|
|
|
2015-08-11 15:05:05 +02:00
|
|
|
<!-- adapted from https://github.com/servo/servo/blob/master/CONTRIBUTING.md -->
|
2018-04-21 11:42:28 +02:00
|
|
|
|
2020-03-10 21:40:53 +01:00
|
|
|
[Apache-2.0]: https://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
[MIT]: https://opensource.org/licenses/MIT
|