# Using Git
<!-- toc -->
The Rust project uses [Git] to manage its source code. In order to
contribute, you'll need some familiarity with its features so that your changes
can be incorporated into the compiler.
The goal of this page is to cover some of the more common questions and
problems new contributors face. Although some Git basics will be covered here,
if you find that this is still a little too fast for you, it might make sense
to first read some introductions to Git, such as the Beginner and Getting
started sections of [this tutorial from Atlassian][atlassian-git]. GitHub also
provides [documentation] and [guides] for beginners, or you can consult the
more in depth [book from Git].
This guide is incomplete. If you run into trouble with git that this page doesn't help with,
please [open an issue] so we can document how to fix it.
## Prerequisites
We'll assume that you've installed Git, forked [rust-lang/rust], and cloned the
forked repo to your PC. We'll use the command line interface to interact
with Git; there are also a number of GUIs and IDE integrations that can
generally do the same things.
If you've cloned your fork, then you will be able to reference it with `origin`
in your local repo. It may be helpful to also set up a remote for the official
rust-lang/rust repo via
```console
git remote add upstream https://github.com/rust-lang/rust.git
```
if you're using HTTPS, or
```console
git remote add upstream git@github.com:rust-lang/rust.git
```
if you're using SSH.
**NOTE:** This page is dedicated to workflows for `rust-lang/rust`, but will likely be
useful when contributing to other repositories in the Rust project.
## Standard Process
Below is the normal procedure that you're likely to use for most minor changes
and PRs:
1. Ensure that you're making your changes on top of master:
`git checkout master`.
2. Get the latest changes from the Rust repo: `git pull upstream master --ff-only`.
(see [No-Merge Policy][no-merge-policy] for more info about this).
3. Make a new branch for your change: `git checkout -b issue-12345-fix`.
4. Make some changes to the repo and test them.
5. Stage your changes via `git add src/changed/file.rs src/another/change.rs`
and then commit them with `git commit`. Of course, making intermediate commits
may be a good idea as well. Avoid `git add .`, as it makes it too easy to
unintentionally commit changes that should not be committed, such as submodule
updates. You can use `git status` to check if there are any files you forgot
to stage.
6. Push your changes to your fork: `git push --set-upstream origin issue-12345-fix`
(After adding commits, you can use `git push` and after rebasing or
pulling-and-rebasing, you can use `git push --force-with-lease`).
7. [Open a PR][ghpullrequest] from your fork to `rust-lang/rust`'s master branch.
If you end up needing to rebase and are hitting conflicts, see [Rebasing](#rebasing).
If you want to track upstream while working on long-running feature/issue, see
[Keeping things up to date][no-merge-policy].
If your reviewer requests changes, the procedure for those changes looks much
the same, with some steps skipped:
1. Ensure that you're making changes to the most recent version of your code:
`git checkout issue-12345-fix`.
2. Make, stage, and commit your additional changes just like before.
3. Push those changes to your fork: `git push`.
## Troubleshooting git issues
You don't need to clone `rust-lang/rust` from scratch if it's out of date!
Even if you think you've messed it up beyond repair, there are ways to fix
the git state that don't require downloading the whole repository again.
Here are some common issues you might run into:
### I made a merge commit by accident.
Git has two ways to update your branch with the newest changes: merging and rebasing.
Rust [uses rebasing][no-merge-policy]. If you make a merge commit, it's not too hard to fix:
`git rebase -i upstream/master`.
See [Rebasing](#rebasing) for more about rebasing.