Syncing changes between Clippy and
Clippy currently gets built with a pinned nightly version.
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.
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
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
This process is described in detail in the following sections. For general
subtrees in the Rust repository see Rust's
Patching git-subtree to work with big repos
Currently, there's a bug in
git-subtree that prevents it from working properly
rust-lang/rust repo. There's an open PR to fix that, but it's
stale. Before continuing with the following steps, we need to manually apply
that fix to our local copy of
You can get the patched version of
git-subtree from here.
Put this file under
/usr/lib/git-core (making a backup of the previous file)
and make sure it has the proper permissions:
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 sudo chown --reference=/usr/lib/git-core/git-subtree~ /usr/lib/git-core/git-subtree
Note: The first time running
git subtree pusha 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
ulimitcommand from the same session you call git subtree.
Note: If you are a Debian user,
dashis 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
bashinstead. You can do this by editing the first line of the
git-subtreescript and changing
You may want to define remotes, so you don't have to type out the remote
addresses on every sync. You can do this with the following commands (these
commands still have to be run inside the
# 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 a local remote $ git remote add clippy-local /path/to/rust-clippy
Note: The following sections assume that you have set those remotes with the above remote names.
Performing the sync from
rust-lang/rust to Clippy
Here is a TL;DR version of the sync process (all of the following commands have
to be run inside the
rust-lang/rustrepository or make sure it is up to date.
Checkout the commit from the latest available nightly. You can get it using
Sync the changes to the rust-copy of Clippy to your Clippy fork:
# Be sure to either use a net-new branch, e.g. `sync-from-rust`, or delete the branch beforehand # because changes cannot be fast forwarded and you have to run this command again. git subtree push -P src/tools/clippy clippy-local sync-from-rust
Note: Most of the time you have to create a merge commit in the
rust-clippyrepo (this has to be done in the Clippy repo, not in the rust-copy of Clippy):
git fetch upstream # assuming upstream is the rust-lang/rust remote git checkout sync-from-rust git merge upstream/master --no-ff
Note: This is one of the few instances where a merge commit is allowed in a PR.
Bump the nightly version in the Clippy repository by changing the date in the rust-toolchain file to the current date and committing it with the message:
git commit -m "Bump nightly version -> YYYY-MM-DD"
Open a PR to
rust-lang/rust-clippyand wait for it to get merged (to accelerate the process ping the
@rust-lang/clippyteam in your PR and/or ask them in the Zulip stream.)
Performing the sync from Clippy to
All of the following commands have to be run inside the
- Make sure you have checked out the latest
- Sync the
rust-lang/rust-clippymaster to the rust-copy of Clippy:
git checkout -b sync-from-clippy git subtree pull -P src/tools/clippy clippy-upstream master
- Open a PR to