<!DOCTYPE HTML>
<html lang="en" class="light sidebar-visible" dir="ltr">
    <head>
        <!-- Book generated using mdBook -->
        <meta charset="UTF-8">
        <title>Using Git - Rust Compiler Development Guide</title>


        <!-- Custom HTML head -->

        <meta name="description" content="A guide to developing the Rust compiler (rustc)">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <meta name="theme-color" content="#ffffff">

        <link rel="icon" href="favicon-de23e50b.svg">
        <link rel="shortcut icon" href="favicon-8114d1fc.png">
        <link rel="stylesheet" href="css/variables-8adf115d.css">
        <link rel="stylesheet" href="css/general-2459343d.css">
        <link rel="stylesheet" href="css/chrome-ae938929.css">
        <link rel="stylesheet" href="css/print-9e4910d8.css" media="print">

        <!-- Fonts -->
        <link rel="stylesheet" href="fonts/fonts-9644e21d.css">

        <!-- Highlight.js Stylesheets -->
        <link rel="stylesheet" id="mdbook-highlight-css" href="highlight-493f70e1.css">
        <link rel="stylesheet" id="mdbook-tomorrow-night-css" href="tomorrow-night-4c0ae647.css">
        <link rel="stylesheet" id="mdbook-ayu-highlight-css" href="ayu-highlight-3fdfc3ac.css">

        <!-- Custom theme stylesheets -->


        <!-- Provide site root and default themes to javascript -->
        <script>
            const path_to_root = "";
            const default_light_theme = "light";
            const default_dark_theme = "navy";
            window.path_to_searchindex_js = "searchindex-5c5c123b.js";
        </script>
        <!-- Start loading toc.js asap -->
        <script src="toc-daec3032.js"></script>
    </head>
    <body>
    <div id="mdbook-help-container">
        <div id="mdbook-help-popup">
            <h2 class="mdbook-help-title">Keyboard shortcuts</h2>
            <div>
                <p>Press <kbd>←</kbd> or <kbd>→</kbd> to navigate between chapters</p>
                <p>Press <kbd>S</kbd> or <kbd>/</kbd> to search in the book</p>
                <p>Press <kbd>?</kbd> to show this help</p>
                <p>Press <kbd>Esc</kbd> to hide this help</p>
            </div>
        </div>
    </div>
    <div id="mdbook-body-container">
        <!-- Work around some values being stored in localStorage wrapped in quotes -->
        <script>
            try {
                let theme = localStorage.getItem('mdbook-theme');
                let sidebar = localStorage.getItem('mdbook-sidebar');

                if (theme.startsWith('"') && theme.endsWith('"')) {
                    localStorage.setItem('mdbook-theme', theme.slice(1, theme.length - 1));
                }

                if (sidebar.startsWith('"') && sidebar.endsWith('"')) {
                    localStorage.setItem('mdbook-sidebar', sidebar.slice(1, sidebar.length - 1));
                }
            } catch (e) { }
        </script>

        <!-- Set the theme before any content is loaded, prevents flash -->
        <script>
            const default_theme = window.matchMedia("(prefers-color-scheme: dark)").matches ? default_dark_theme : default_light_theme;
            let theme;
            try { theme = localStorage.getItem('mdbook-theme'); } catch(e) { }
            if (theme === null || theme === undefined) { theme = default_theme; }
            const html = document.documentElement;
            html.classList.remove('light')
            html.classList.add(theme);
            html.classList.add("js");
        </script>

        <input type="checkbox" id="mdbook-sidebar-toggle-anchor" class="hidden">

        <!-- Hide / unhide sidebar before it is displayed -->
        <script>
            let sidebar = null;
            const sidebar_toggle = document.getElementById("mdbook-sidebar-toggle-anchor");
            if (document.body.clientWidth >= 1080) {
                try { sidebar = localStorage.getItem('mdbook-sidebar'); } catch(e) { }
                sidebar = sidebar || 'visible';
            } else {
                sidebar = 'hidden';
                sidebar_toggle.checked = false;
            }
            if (sidebar === 'visible') {
                sidebar_toggle.checked = true;
            } else {
                html.classList.remove('sidebar-visible');
            }
        </script>

        <nav id="mdbook-sidebar" class="sidebar" aria-label="Table of contents">
            <!-- populated by js -->
            <mdbook-sidebar-scrollbox class="sidebar-scrollbox"></mdbook-sidebar-scrollbox>
            <noscript>
                <iframe class="sidebar-iframe-outer" src="toc.html"></iframe>
            </noscript>
            <div id="mdbook-sidebar-resize-handle" class="sidebar-resize-handle">
                <div class="sidebar-resize-indicator"></div>
            </div>
        </nav>

        <div id="mdbook-page-wrapper" class="page-wrapper">

            <div class="page">
                <div id="mdbook-menu-bar-hover-placeholder"></div>
                <div id="mdbook-menu-bar" class="menu-bar sticky">
                    <div class="left-buttons">
                        <label id="mdbook-sidebar-toggle" class="icon-button" for="mdbook-sidebar-toggle-anchor" title="Toggle Table of Contents" aria-label="Toggle Table of Contents" aria-controls="mdbook-sidebar">
                            <span class=fa-svg><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M0 96C0 78.3 14.3 64 32 64H416c17.7 0 32 14.3 32 32s-14.3 32-32 32H32C14.3 128 0 113.7 0 96zM0 256c0-17.7 14.3-32 32-32H416c17.7 0 32 14.3 32 32s-14.3 32-32 32H32c-17.7 0-32-14.3-32-32zM448 416c0 17.7-14.3 32-32 32H32c-17.7 0-32-14.3-32-32s14.3-32 32-32H416c17.7 0 32 14.3 32 32z"/></svg></span>
                        </label>
                        <button id="mdbook-theme-toggle" class="icon-button" type="button" title="Change theme" aria-label="Change theme" aria-haspopup="true" aria-expanded="false" aria-controls="mdbook-theme-list">
                            <span class=fa-svg><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M371.3 367.1c27.3-3.9 51.9-19.4 67.2-42.9L600.2 74.1c12.6-19.5 9.4-45.3-7.6-61.2S549.7-4.4 531.1 9.6L294.4 187.2c-24 18-38.2 46.1-38.4 76.1L371.3 367.1zm-19.6 25.4l-116-104.4C175.9 290.3 128 339.6 128 400c0 3.9 .2 7.8 .6 11.6c1.8 17.5-10.2 36.4-27.8 36.4H96c-17.7 0-32 14.3-32 32s14.3 32 32 32H240c61.9 0 112-50.1 112-112c0-2.5-.1-5-.2-7.5z"/></svg></span>
                        </button>
                        <ul id="mdbook-theme-list" class="theme-popup" aria-label="Themes" role="menu">
                            <li role="none"><button role="menuitem" class="theme" id="mdbook-theme-default_theme">Auto</button></li>
                            <li role="none"><button role="menuitem" class="theme" id="mdbook-theme-light">Light</button></li>
                            <li role="none"><button role="menuitem" class="theme" id="mdbook-theme-rust">Rust</button></li>
                            <li role="none"><button role="menuitem" class="theme" id="mdbook-theme-coal">Coal</button></li>
                            <li role="none"><button role="menuitem" class="theme" id="mdbook-theme-navy">Navy</button></li>
                            <li role="none"><button role="menuitem" class="theme" id="mdbook-theme-ayu">Ayu</button></li>
                        </ul>
                        <button id="mdbook-search-toggle" class="icon-button" type="button" title="Search (`/`)" aria-label="Toggle Searchbar" aria-expanded="false" aria-keyshortcuts="/ s" aria-controls="mdbook-searchbar">
                            <span class=fa-svg><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M416 208c0 45.9-14.9 88.3-40 122.7L502.6 457.4c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0L330.7 376c-34.4 25.2-76.8 40-122.7 40C93.1 416 0 322.9 0 208S93.1 0 208 0S416 93.1 416 208zM208 352c79.5 0 144-64.5 144-144s-64.5-144-144-144S64 128.5 64 208s64.5 144 144 144z"/></svg></span>
                        </button>
                    </div>

                    <h1 class="menu-title">Rust Compiler Development Guide</h1>

                    <div class="right-buttons">
                        <a href="print.html" title="Print this book" aria-label="Print this book">
                            <span class=fa-svg id="print-button"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M128 0C92.7 0 64 28.7 64 64v96h64V64H354.7L384 93.3V160h64V93.3c0-17-6.7-33.3-18.7-45.3L400 18.7C388 6.7 371.7 0 354.7 0H128zM384 352v32 64H128V384 368 352H384zm64 32h32c17.7 0 32-14.3 32-32V256c0-35.3-28.7-64-64-64H64c-35.3 0-64 28.7-64 64v96c0 17.7 14.3 32 32 32H64v64c0 35.3 28.7 64 64 64H384c35.3 0 64-28.7 64-64V384zm-16-88c-13.3 0-24-10.7-24-24s10.7-24 24-24s24 10.7 24 24s-10.7 24-24 24z"/></svg></span>
                        </a>
                        <a href="https://github.com/rust-lang/rustc-dev-guide" title="Git repository" aria-label="Git repository">
                            <span class=fa-svg><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 496 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M165.9 397.4c0 2-2.3 3.6-5.2 3.6-3.3.3-5.6-1.3-5.6-3.6 0-2 2.3-3.6 5.2-3.6 3-.3 5.6 1.3 5.6 3.6zm-31.1-4.5c-.7 2 1.3 4.3 4.3 4.9 2.6 1 5.6 0 6.2-2s-1.3-4.3-4.3-5.2c-2.6-.7-5.5.3-6.2 2.3zm44.2-1.7c-2.9.7-4.9 2.6-4.6 4.9.3 2 2.9 3.3 5.9 2.6 2.9-.7 4.9-2.6 4.6-4.6-.3-1.9-3-3.2-5.9-2.9zM244.8 8C106.1 8 0 113.3 0 252c0 110.9 69.8 205.8 169.5 239.2 12.8 2.3 17.3-5.6 17.3-12.1 0-6.2-.3-40.4-.3-61.4 0 0-70 15-84.7-29.8 0 0-11.4-29.1-27.8-36.6 0 0-22.9-15.7 1.6-15.4 0 0 24.9 2 38.6 25.8 21.9 38.6 58.6 27.5 72.9 20.9 2.3-16 8.8-27.1 16-33.7-55.9-6.2-112.3-14.3-112.3-110.5 0-27.5 7.6-41.3 23.6-58.9-2.6-6.5-11.1-33.3 2.6-67.9 20.9-6.5 69 27 69 27 20-5.6 41.5-8.5 62.8-8.5s42.8 2.9 62.8 8.5c0 0 48.1-33.6 69-27 13.7 34.7 5.2 61.4 2.6 67.9 16 17.7 25.8 31.5 25.8 58.9 0 96.5-58.9 104.2-114.8 110.5 9.2 7.9 17 22.9 17 46.4 0 33.7-.3 75.4-.3 83.6 0 6.5 4.6 14.4 17.3 12.1C428.2 457.8 496 362.9 496 252 496 113.3 383.5 8 244.8 8zM97.2 352.9c-1.3 1-1 3.3.7 5.2 1.6 1.6 3.9 2.3 5.2 1 1.3-1 1-3.3-.7-5.2-1.6-1.6-3.9-2.3-5.2-1zm-10.8-8.1c-.7 1.3.3 2.9 2.3 3.9 1.6 1 3.6.7 4.3-.7.7-1.3-.3-2.9-2.3-3.9-2-.6-3.6-.3-4.3.7zm32.4 35.6c-1.6 1.3-1 4.3 1.3 6.2 2.3 2.3 5.2 2.6 6.5 1 1.3-1.3.7-4.3-1.3-6.2-2.2-2.3-5.2-2.6-6.5-1zm-11.4-14.7c-1.6 1-1.6 3.6 0 5.9 1.6 2.3 4.3 3.3 5.6 2.3 1.6-1.3 1.6-3.9 0-6.2-1.4-2.3-4-3.3-5.6-2z"/></svg></span>
                        </a>
                        <a href="https://github.com/rust-lang/rustc-dev-guide/edit/main/src/git.md" title="Suggest an edit" aria-label="Suggest an edit" rel="edit">
                            <span class=fa-svg id="git-edit-button"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M421.7 220.3l-11.3 11.3-22.6 22.6-205 205c-6.6 6.6-14.8 11.5-23.8 14.1L30.8 511c-8.4 2.5-17.5 .2-23.7-6.1S-1.5 489.7 1 481.2L38.7 353.1c2.6-9 7.5-17.2 14.1-23.8l205-205 22.6-22.6 11.3-11.3 33.9 33.9 62.1 62.1 33.9 33.9zM96 353.9l-9.3 9.3c-.9 .9-1.6 2.1-2 3.4l-25.3 86 86-25.3c1.3-.4 2.5-1.1 3.4-2l9.3-9.3H112c-8.8 0-16-7.2-16-16V353.9zM453.3 19.3l39.4 39.4c25 25 25 65.5 0 90.5l-14.5 14.5-22.6 22.6-11.3 11.3-33.9-33.9-62.1-62.1L314.3 67.7l11.3-11.3 22.6-22.6 14.5-14.5c25-25 65.5-25 90.5 0z"/></svg></span>
                        </a>

                    </div>
                </div>

                <div id="mdbook-search-wrapper" class="hidden">
                    <form id="mdbook-searchbar-outer" class="searchbar-outer">
                        <div class="search-wrapper">
                            <input type="search" id="mdbook-searchbar" name="searchbar" placeholder="Search this book ..." aria-controls="mdbook-searchresults-outer" aria-describedby="searchresults-header">
                            <div class="spinner-wrapper">
                                <span class=fa-svg id="fa-spin"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M304 48c0-26.5-21.5-48-48-48s-48 21.5-48 48s21.5 48 48 48s48-21.5 48-48zm0 416c0-26.5-21.5-48-48-48s-48 21.5-48 48s21.5 48 48 48s48-21.5 48-48zM48 304c26.5 0 48-21.5 48-48s-21.5-48-48-48s-48 21.5-48 48s21.5 48 48 48zm464-48c0-26.5-21.5-48-48-48s-48 21.5-48 48s21.5 48 48 48s48-21.5 48-48zM142.9 437c18.7-18.7 18.7-49.1 0-67.9s-49.1-18.7-67.9 0s-18.7 49.1 0 67.9s49.1 18.7 67.9 0zm0-294.2c18.7-18.7 18.7-49.1 0-67.9S93.7 56.2 75 75s-18.7 49.1 0 67.9s49.1 18.7 67.9 0zM369.1 437c18.7 18.7 49.1 18.7 67.9 0s18.7-49.1 0-67.9s-49.1-18.7-67.9 0s-18.7 49.1 0 67.9z"/></svg></span>
                            </div>
                        </div>
                    </form>
                    <div id="mdbook-searchresults-outer" class="searchresults-outer hidden">
                        <div id="mdbook-searchresults-header" class="searchresults-header"></div>
                        <ul id="mdbook-searchresults">
                        </ul>
                    </div>
                </div>

                <!-- Apply ARIA attributes after the sidebar and the sidebar toggle button are added to the DOM -->
                <script>
                    document.getElementById('mdbook-sidebar-toggle').setAttribute('aria-expanded', sidebar === 'visible');
                    document.getElementById('mdbook-sidebar').setAttribute('aria-hidden', sidebar !== 'visible');
                    Array.from(document.querySelectorAll('#mdbook-sidebar a')).forEach(function(link) {
                        link.setAttribute('tabIndex', sidebar === 'visible' ? 0 : -1);
                    });
                </script>

                <div id="mdbook-content" class="content">
                    <main>
                        <h1 id="using-git"><a class="header" href="#using-git">Using Git</a></h1>
<p>The Rust project uses <a href="https://git-scm.com">Git</a> 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.</p>
<p>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 <a href="https://www.atlassian.com/git/tutorials/what-is-version-control">this tutorial from Atlassian</a>.
GitHub also provides <a href="https://docs.github.com/en/get-started/quickstart/set-up-git">documentation</a> and <a href="https://guides.github.com/introduction/git-handbook/">guides</a> for beginners, or you can consult the
more in depth <a href="https://git-scm.com/book/en/v2/">book from Git</a>.</p>
<p>This guide is incomplete.
If you run into trouble with git that this page doesn’t help with,
please <a href="https://github.com/rust-lang/rustc-dev-guide/issues/new">open an issue</a> so we can document how to fix it.</p>
<h2 id="prerequisites"><a class="header" href="#prerequisites">Prerequisites</a></h2>
<p>We’ll assume that you’ve installed Git, forked <a href="https://github.com/rust-lang/rust">rust-lang/rust</a>, 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.</p>
<p>If you’ve cloned your fork, then you will be able to reference it with <code>origin</code> in your local repo.
It may be helpful to also set up a remote for the official rust-lang/rust repo via</p>
<pre><code class="language-console">git remote add upstream https://github.com/rust-lang/rust.git
</code></pre>
<p>if you’re using HTTPS, or</p>
<pre><code class="language-console">git remote add upstream git@github.com:rust-lang/rust.git
</code></pre>
<p>if you’re using SSH.</p>
<p><strong>NOTE:</strong> This page is dedicated to workflows for <code>rust-lang/rust</code>, but will likely be
useful when contributing to other repositories in the Rust project.</p>
<h2 id="standard-process"><a class="header" href="#standard-process">Standard Process</a></h2>
<p>Below is the normal procedure that you’re likely to use for most minor changes and PRs:</p>
<ol>
<li>Ensure that you’re making your changes on top of <code>main</code>: <code>git checkout main</code>.</li>
<li>Get the latest changes from the Rust repo: <code>git pull upstream main --ff-only</code>.
(see <a href="#keeping-things-up-to-date">No-Merge Policy</a> for more info about this).</li>
<li>Make a new branch for your change: <code>git checkout -b issue-12345-fix</code>.</li>
<li>Make some changes to the repo and test them.</li>
<li>Stage your changes via <code>git add src/changed/file.rs src/another/change.rs</code>
and then commit them with <code>git commit</code>.
Of course, making intermediate commits may be a good idea as well.
Avoid <code>git add .</code>, as it makes it too easy to
unintentionally commit changes that should not be committed, such as submodule updates.
You can use <code>git status</code> to check if there are any files you forgot to stage.</li>
<li>Push your changes to your fork: <code>git push --set-upstream origin issue-12345-fix</code>
(After adding commits, you can use <code>git push</code> and after rebasing or
pulling-and-rebasing, you can use <code>git push --force-with-lease</code>).</li>
<li><a href="https://guides.github.com/activities/forking/#making-a-pull-request">Open a PR</a> from your fork to <code>rust-lang/rust</code>’s <code>main</code> branch.</li>
</ol>
<p>If you end up needing to rebase and are hitting conflicts, see <a href="#rebasing">Rebasing</a>.
If you want to track upstream while working on long-running feature/issue, see
<a href="#keeping-things-up-to-date">Keeping things up to date</a>.</p>
<p>If your reviewer requests changes, the procedure for those changes looks much
the same, with some steps skipped:</p>
<ol>
<li>Ensure that you’re making changes to the most recent version of your code:
<code>git checkout issue-12345-fix</code>.</li>
<li>Make, stage, and commit your additional changes just like before.</li>
<li>Push those changes to your fork: <code>git push</code>.</li>
</ol>
<h2 id="troubleshooting-git-issues"><a class="header" href="#troubleshooting-git-issues">Troubleshooting git issues</a></h2>
<p>You don’t need to clone <code>rust-lang/rust</code> 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:</p>
<h3 id="i-made-a-merge-commit-by-accident"><a class="header" href="#i-made-a-merge-commit-by-accident">I made a merge commit by accident.</a></h3>
<p>Git has two ways to update your branch with the newest changes: merging and rebasing.
Rust <a href="#keeping-things-up-to-date">uses rebasing</a>.
If you make a merge commit, it’s not too hard to fix: <code>git rebase -i upstream/main</code>.</p>
<p>See <a href="#rebasing">Rebasing</a> for more about rebasing.</p>
<h3 id="i-deleted-my-fork-on-github"><a class="header" href="#i-deleted-my-fork-on-github">I deleted my fork on GitHub!</a></h3>
<p>This is not a problem from git’s perspective.
If you run <code>git remote -v</code>,
it will say something like this:</p>
<pre><code class="language-console">$ git remote -v
origin  git@github.com:jyn514/rust.git (fetch)
origin  git@github.com:jyn514/rust.git (push)
upstream        https://github.com/rust-lang/rust (fetch)
upstream        https://github.com/rust-lang/rust (fetch)
</code></pre>
<p>If you renamed your fork, you can change the URL like this:</p>
<pre><code class="language-console">git remote set-url origin &lt;URL&gt;
</code></pre>
<p>where the <code>&lt;URL&gt;</code> is your new fork.</p>
<h3 id="i-changed-a-submodule-by-accident"><a class="header" href="#i-changed-a-submodule-by-accident">I changed a submodule by accident</a></h3>
<p>Usually people notice this when rustbot posts a comment on github that <code>cargo</code> has been modified:</p>
<p><img src="./img/rustbot-submodules.png" alt="rustbot submodule comment"></p>
<p>You might also notice conflicts in the web UI:</p>
<p><img src="./img/submodule-conflicts.png" alt="conflict in src/tools/cargo"></p>
<p>The most common cause is that you rebased after a change and ran <code>git add .</code> without first running
<code>x</code> to update the submodules.
Alternatively, you might have run <code>cargo fmt</code> instead of <code>x fmt</code>
and modified files in a submodule, then committed the changes.</p>
<p>To fix it, do the following things (if you changed a submodule other than cargo,
replace <code>src/tools/cargo</code> with the path to that submodule):</p>
<ol>
<li>See which commit has the accidental changes: <code>git log --stat -n1 src/tools/cargo</code></li>
<li>Revert the changes to that commit: <code>git checkout &lt;my-commit&gt;~ src/tools/cargo</code>.
Type <code>~</code> literally but replace <code>&lt;my-commit&gt;</code> with the output from step 1.</li>
<li>Tell git to commit the changes: <code>git commit --fixup &lt;my-commit&gt;</code></li>
<li>Repeat steps 1-3 for all the submodules you modified.
<ul>
<li>If you modified the submodule in several different commits, you will need to repeat steps 1-3
for each commit you modified.
You’ll know when to stop when the <code>git log</code> command shows a commit
that’s not authored by you.</li>
</ul>
</li>
<li>Squash your changes into the existing commits: <code>git rebase --autosquash -i upstream/main</code></li>
<li><a href="#standard-process">Push your changes</a>.</li>
</ol>
<h3 id="i-see-error-cannot-rebase-when-i-try-to-rebase"><a class="header" href="#i-see-error-cannot-rebase-when-i-try-to-rebase">I see “error: cannot rebase” when I try to rebase</a></h3>
<p>These are two common errors to see when rebasing:</p>
<pre><code class="language-console">error: cannot rebase: Your index contains uncommitted changes.
error: Please commit or stash them.
</code></pre>
<pre><code class="language-console">error: cannot rebase: You have unstaged changes.
error: Please commit or stash them.
</code></pre>
<p>(See <a href="https://git-scm.com/book/en/v2/Getting-Started-What-is-Git%3F#_the_three_states">https://git-scm.com/book/en/v2/Getting-Started-What-is-Git%3F#_the_three_states</a> for the difference between the two.)</p>
<p>This means you have made changes since the last time you made a commit.
To be able to rebase, either
commit your changes, or make a temporary commit called a “stash” to have them still not be committed
when you finish rebasing.
You may want to configure git to make this “stash” automatically, which
will prevent the “cannot rebase” error in nearly all cases:</p>
<pre><code class="language-console">git config --global rebase.autostash true
</code></pre>
<p>See <a href="https://git-scm.com/book/en/v2/Git-Tools-Stashing-and-Cleaning">https://git-scm.com/book/en/v2/Git-Tools-Stashing-and-Cleaning</a> for more info about stashing.</p>
<h3 id="i-see-untracked-files-srcstdarch"><a class="header" href="#i-see-untracked-files-srcstdarch">I see ‘Untracked Files: src/stdarch’?</a></h3>
<p>This is left over from the move to the <code>library/</code> directory.
Unfortunately, <code>git rebase</code> does not follow renames for submodules, so you
have to delete the directory yourself:</p>
<pre><code class="language-console">rm -r src/stdarch
</code></pre>
<h3 id="i-see--head"><a class="header" href="#i-see--head">I see <code>&lt;&lt;&lt; HEAD</code>?</a></h3>
<p>You were probably in the middle of a rebase or merge conflict.
See <a href="#rebasing-and-conflicts">Conflicts</a> for how to fix the conflict.
If you don’t care about the changes
and just want to get a clean copy of the repository back, you can use <code>git reset</code>:</p>
<pre><code class="language-console"># WARNING: this throws out any local changes you've made! Consider resolving the conflicts instead.
git reset --hard main
</code></pre>
<h3 id="failed-to-push-some-refs"><a class="header" href="#failed-to-push-some-refs">failed to push some refs</a></h3>
<p><code>git push</code> will not work properly and say something like this:</p>
<pre><code class="language-console"> ! [rejected]        issue-xxxxx -&gt; issue-xxxxx (non-fast-forward)
error: failed to push some refs to 'https://github.com/username/rust.git'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. Integrate the remote changes (e.g.
hint: 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.
</code></pre>
<p>The advice this gives is incorrect!
Because of Rust’s <a href="#no-merge-policy">“no-merge” policy</a>, the merge commit created by <code>git pull</code>
will not be allowed in the final PR, in addition to defeating the point of the rebase!
Use <code>git push --force-with-lease</code> instead.</p>
<h3 id="git-is-trying-to-rebase-commits-i-didnt-write"><a class="header" href="#git-is-trying-to-rebase-commits-i-didnt-write">Git is trying to rebase commits I didn’t write?</a></h3>
<p>If you see many commits in your rebase list, or merge commits, or commits by other people that you
didn’t write, it likely means you’re trying to rebase over the wrong branch.
For example, you may
have a <code>rust-lang/rust</code> remote <code>upstream</code>, but ran <code>git rebase origin/main</code> instead of <code>git rebase upstream/main</code>.
The fix is to abort the rebase and use the correct branch instead:</p>
<pre><code class="language-console">git rebase --abort
git rebase --interactive upstream/main
</code></pre>
<details><summary>Click here to see an example of rebasing over the wrong branch</summary>
<p><img src="img/other-peoples-commits.png" alt="Interactive rebase over the wrong branch"></p>
</details>
<h3 id="quick-note-about-submodules"><a class="header" href="#quick-note-about-submodules">Quick note about submodules</a></h3>
<p>When updating your local repository with <code>git pull</code>, you may notice that sometimes
Git says you have modified some files that you have never edited.
For example,
running <code>git status</code> gives you something like (note the <code>new commits</code> mention):</p>
<pre><code class="language-console">On branch main
Your branch is up to date with 'origin/main'.

Changes not staged for commit:
  (use "git add &lt;file&gt;..." to update what will be committed)
  (use "git restore &lt;file&gt;..." to discard changes in working directory)
	modified:   src/llvm-project (new commits)
	modified:   src/tools/cargo (new commits)

no changes added to commit (use "git add" and/or "git commit -a")
</code></pre>
<p>These changes are not changes to files: they are changes to submodules (more on this <a href="#git-submodules">later</a>).
To get rid of those:</p>
<pre><code class="language-console">git submodule update
</code></pre>
<p>Some submodules are not actually needed; for example, <code>src/llvm-project</code> doesn’t need to be checked
out if you’re using <code>download-ci-llvm</code>.
To avoid having to keep fetching its history, you can use
<code>git submodule deinit -f src/llvm-project</code>, which will also avoid it showing as modified again.</p>
<h2 id="rebasing-and-conflicts"><a class="header" href="#rebasing-and-conflicts">Rebasing and Conflicts</a></h2>
<p>When you edit your code locally, you are making changes to the version of
rust-lang/rust that existed when you created your feature branch.
As such, when you submit your PR, it is possible that some of the changes that have been made
to rust-lang/rust since then are in conflict with the changes you’ve made.
When this happens, you need to resolve the conflicts before your changes can be merged.
To do that, you need to rebase your work on top of rust-lang/rust.</p>
<h3 id="rebasing"><a class="header" href="#rebasing">Rebasing</a></h3>
<p>To rebase your feature branch on top of the newest version of the <code>main</code> branch
of rust-lang/rust, checkout your branch, and then run this command:</p>
<pre><code class="language-console">git pull --rebase https://github.com/rust-lang/rust.git main
</code></pre>
<blockquote>
<p>If you are met with the following error:</p>
<pre><code class="language-console">error: cannot pull with rebase: Your index contains uncommitted changes.
error: please commit or stash them.
</code></pre>
<p>it means that you have some uncommitted work in your working tree. In that
case, run <code>git stash</code> before rebasing, and then <code>git stash pop</code> after you
have rebased and fixed all conflicts.</p>
</blockquote>
<p>When you rebase a branch on main, all the changes on your branch are
reapplied to the most recent version of <code>main</code>.
In other words, Git tries to
pretend that the changes you made to the old version of <code>main</code> were instead
made to the new version of <code>main</code>.
During this process, you should expect to encounter at least one “rebase conflict”.
This happens when Git’s attempt to
reapply the changes fails because your changes conflicted with other changes that have been made.
You can tell that this happened because you’ll see lines in the output that look like</p>
<pre><code class="language-console">CONFLICT (content): Merge conflict in file.rs
</code></pre>
<p>When you open these files, you’ll see sections of the form</p>
<pre><code class="language-console">&lt;&lt;&lt;&lt;&lt;&lt;&lt; HEAD
Original code
=======
Your code
&gt;&gt;&gt;&gt;&gt;&gt;&gt; 8fbf656... Commit fixes 12345
</code></pre>
<p>This represents the lines in the file that Git could not figure out how to rebase.
The section between <code>&lt;&lt;&lt;&lt;&lt;&lt;&lt; HEAD</code> and <code>=======</code> has the code from
<code>main</code>, while the other side has your version of the code.
You’ll need to decide how to deal with the conflict.
You may want to keep your changes,
keep the changes on <code>main</code>, or combine the two.</p>
<p>Generally, resolving the conflict consists of two steps: First, fix the particular conflict.
Edit the file to make the changes you want and remove the
<code>&lt;&lt;&lt;&lt;&lt;&lt;&lt;</code>, <code>=======</code> and <code>&gt;&gt;&gt;&gt;&gt;&gt;&gt;</code> lines in the process.
Second, check the surrounding code.
If there was a conflict, its likely there are some logical errors lying around too!
It’s a good idea to run <code>x check</code> here to make sure there are no glaring errors.</p>
<p>Once you’re all done fixing the conflicts, you need to stage the files that had
conflicts in them via <code>git add</code>.
Afterwards, run <code>git rebase --continue</code> to let
Git know that you’ve resolved the conflicts and it should finish the rebase.</p>
<p>Once the rebase has succeeded, you’ll want to update the associated branch on
your fork with <code>git push --force-with-lease</code>.</p>
<h3 id="keeping-things-up-to-date"><a class="header" href="#keeping-things-up-to-date">Keeping things up to date</a></h3>
<p>The <a href="#rebasing">above section</a> is a specific
guide on rebasing work and dealing with merge conflicts.
Here is some general advice about how to keep your local repo up-to-date with upstream changes:</p>
<p>Using <code>git pull upstream main</code> while on your local <code>main</code> branch regularly will keep it up-to-date.
You will also want to keep your feature branches up-to-date as well.
After pulling, you can checkout the feature branches and rebase them:</p>
<pre><code class="language-console">git checkout main
git pull upstream main --ff-only # to make certain there are no merge commits
git rebase main feature_branch
git push --force-with-lease # (set origin to be the same as local)
</code></pre>
<p>To avoid merges as per the <a href="#no-merge-policy">No-Merge Policy</a>, you may want to use
<code>git config pull.ff only</code> (this will apply the config only to the local repo)
to ensure that Git doesn’t create merge commits when <code>git pull</code>ing, without
needing to pass <code>--ff-only</code> or <code>--rebase</code> every time.</p>
<p>You can also <code>git push --force-with-lease</code> from main to double-check that your
feature branches are in sync with their state on the GitHub side.</p>
<h2 id="advanced-rebasing"><a class="header" href="#advanced-rebasing">Advanced Rebasing</a></h2>
<h3 id="squash-your-commits"><a class="header" href="#squash-your-commits">Squash your commits</a></h3>
<p>“Squashing” commits into each other causes them to be merged into a single commit.
Both the upside and downside of this is that it simplifies the history.
On the one hand, you lose track of the steps in which changes were made, but
the history becomes easier to work with.</p>
<p>The easiest way to squash your commits in a PR on the <code>rust-lang/rust</code> repository is to use the <code>@bors squash</code> command in a comment on the PR.
By default, <a href="https://github.com/rust-lang/bors">bors</a> combines all commit messages of the PR into the squashed commit message.
To customize the commit message, use <code>@bors squash msg="&lt;commit message&gt;"</code>.
For example, <code>@bors squash msg="Improve diagnostics for missing lifetime parameter"</code>.</p>
<p>If you want to squash commits using local git operations, read on below.</p>
<p>If there are no conflicts and you are just squashing to clean up the history,
use <code>git rebase --interactive --keep-base main</code>.
This keeps the fork point of your PR the same, making it easier to review the diff of what happened
across your rebases.</p>
<p>Squashing can also be useful as part of conflict resolution.
If your branch contains multiple consecutive rewrites of the same code, or if
the rebase conflicts are extremely severe, you can use
<code>git rebase --interactive main</code> to gain more control over the process.
This allows you to choose to skip commits, edit the commits that you do not skip,
change the order in which they are applied, or “squash” them into each other.</p>
<p>Alternatively, you can sacrifice the commit history like this:</p>
<pre><code class="language-console"># squash all the changes into one commit so you only have to worry about conflicts once
git rebase --interactive --keep-base main  # and squash all changes along the way
git rebase main
# fix all merge conflicts
git rebase --continue
</code></pre>
<p>You also may want to squash just the last few commits together, possibly
because they only represent “fixups” and not real changes.
For example,
<code>git rebase --interactive HEAD~2</code> will allow you to edit the two commits only.</p>
<h3 id="git-range-diff"><a class="header" href="#git-range-diff"><code>git range-diff</code></a></h3>
<p>After completing a rebase, and before pushing up your changes, you may want to
review the changes between your old branch and your new one.
You can do that with <code>git range-diff main @{upstream} HEAD</code>.</p>
<p>The first argument to <code>range-diff</code>, <code>main</code> in this case, is the base revision
that you’re comparing your old and new branch against.
The second argument is
the old version of your branch; in this case, <code>@upstream</code> means the version that
you’ve pushed to GitHub, which is the same as what people will see in your pull request.
Finally, the third argument to <code>range-diff</code> is the <em>new</em> version of
your branch; in this case, it is <code>HEAD</code>, which is the commit that is currently
checked-out in your local repo.</p>
<p>Note that you can also use the equivalent, abbreviated form <code>git range-diff main @{u} HEAD</code>.</p>
<p>Unlike in regular Git diffs, you’ll see a <code>-</code> or <code>+</code> next to another <code>-</code> or <code>+</code>
in the range-diff output.
The marker on the left indicates a change between the
old branch and the new branch, and the marker on the right indicates a change you’ve committed.
So, you can think of a range-diff as a “diff of diffs” since
it shows you the differences between your old diff and your new diff.</p>
<p>Here’s an example of <code>git range-diff</code> output (taken from <a href="https://git-scm.com/docs/git-range-diff#_examples">Git’s docs</a>):</p>
<pre><code class="language-console">-:  ------- &gt; 1:  0ddba11 Prepare for the inevitable!
1:  c0debee = 2:  cab005e Add a helpful message at the start
2:  f00dbal ! 3:  decafe1 Describe a bug
    @@ -1,3 +1,3 @@
     Author: A U Thor &lt;author@example.com&gt;

    -TODO: Describe a bug
    +Describe a bug
    @@ -324,5 +324,6
      This is expected.

    -+What is unexpected is that it will also crash.
    ++Unexpectedly, it also crashes. This is a bug, and the jury is
    ++still out there how to fix it best. See ticket #314 for details.

      Contact
3:  bedead &lt; -:  ------- TO-UNDO
</code></pre>
<p>(Note that <code>git range-diff</code> output in your terminal will probably be easier to
read than in this example because it will have colors.)</p>
<p>Another feature of <code>git range-diff</code> is that, unlike <code>git diff</code>, it will also diff commit messages.
This feature can be useful when amending several commit
messages so you can make sure you changed the right parts.</p>
<p><code>git range-diff</code> is a very useful command, but note that it can take some time
to get used to its output format.
You may also find Git’s documentation on the
command useful, especially their <a href="https://git-scm.com/docs/git-range-diff#_examples">“Examples” section</a>.</p>
<h2 id="no-merge-policy"><a class="header" href="#no-merge-policy">No-Merge Policy</a></h2>
<p>The rust-lang/rust repo uses what is known as a “rebase workflow”.
This means that merge commits in PRs are not accepted.
As a result, if you are running
<code>git merge</code> locally, chances are good that you should be rebasing instead.
Of course, this is not always true; if your merge will just be a fast-forward,
like the merges that <code>git pull</code> usually performs, then no merge commit is
created and you have nothing to worry about.
Running <code>git config merge.ff only</code> (this will apply the config to the local repo)
once will ensure that all the merges you perform are of this type, so that you
cannot make a mistake.</p>
<p>There are a number of reasons for this decision, and like all others, it is a tradeoff.
The main advantage is the generally linear commit history.
This greatly simplifies bisecting and makes the history and commit log much easier
to follow and understand.</p>
<h2 id="tips-for-reviewing"><a class="header" href="#tips-for-reviewing">Tips for reviewing</a></h2>
<p><strong>NOTE</strong>: This section is for <em>reviewing</em> PRs, not authoring them.</p>
<h3 id="hiding-whitespace"><a class="header" href="#hiding-whitespace">Hiding whitespace</a></h3>
<p>GitHub has a button for disabling whitespace changes that may be useful.
You can also use <code>git diff -w origin/main</code> to view changes locally.</p>
<p><img src="./img/github-whitespace-changes.png" alt="hide whitespace"></p>
<h3 id="fetching-prs"><a class="header" href="#fetching-prs">Fetching PRs</a></h3>
<p>To checkout PRs locally, you can use <code>git fetch upstream pull/NNNNN/head &amp;&amp; git checkout FETCH_HEAD</code>.</p>
<p>You can also use github’s cli tool.
GitHub shows a button on PRs where you can copy-paste the command to check it out locally.
See <a href="https://cli.github.com/">https://cli.github.com/</a> for more info.</p>
<p><img src="./img/github-cli.png" alt="gh suggestion"></p>
<h3 id="using-github-dev"><a class="header" href="#using-github-dev">Using GitHub dev</a></h3>
<p>As an alternative to the GitHub web UI, GitHub Dev provides a web-based editor for browsing
repository and PRs.
It can be opened by replacing <code>github.com</code> with <code>github.dev</code> in the URL
or by pressing <code>.</code> on a GitHub page.
See <a href="https://docs.github.com/en/codespaces/the-githubdev-web-based-editor">the docs for github.dev editor</a>
for more details.</p>
<h3 id="moving-large-sections-of-code"><a class="header" href="#moving-large-sections-of-code">Moving large sections of code</a></h3>
<p>Git and GitHub’s default diff view for large moves <em>within</em> a file is quite poor; it will show each
line as deleted and each line as added, forcing you to compare each line yourself.
Git has an option to show moved lines in a different color:</p>
<pre><code class="language-console">git log -p --color-moved=dimmed-zebra --color-moved-ws=allow-indentation-change
</code></pre>
<p>See <a href="https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---color-movedltmodegt">the docs for <code>--color-moved</code></a> for more info.</p>
<h3 id="range-diff"><a class="header" href="#range-diff">range-diff</a></h3>
<p>See <a href="#git-range-diff">the relevant section for PR authors</a>.
This can be useful for comparing code
that was force-pushed to make sure there are no unexpected changes.</p>
<h3 id="ignoring-changes-to-specific-files"><a class="header" href="#ignoring-changes-to-specific-files">Ignoring changes to specific files</a></h3>
<p>Many large files in the repo are autogenerated.
To view a diff that ignores changes to those files,
you can use the following syntax (e.g. Cargo.lock):</p>
<pre><code class="language-console">git log -p ':!Cargo.lock'
</code></pre>
<p>Arbitrary patterns are supported (e.g. <code>:!compiler/*</code>). Patterns use the same syntax as
<code>.gitignore</code>, with <code>:</code> prepended to indicate a pattern.</p>
<h2 id="git-submodules"><a class="header" href="#git-submodules">Git submodules</a></h2>
<p><strong>NOTE</strong>: submodules are a nice thing to know about, but it <em>isn’t</em> an absolute
prerequisite to contribute to <code>rustc</code>.
If you are using Git for the first time,
you might want to get used to the main concepts of Git before reading this section.</p>
<p>The <code>rust-lang/rust</code> repository uses <a href="https://git-scm.com/book/en/v2/Git-Tools-Submodules">Git submodules</a> as a way to use other
Rust projects from within the <code>rust</code> repo.
Examples include Rust’s fork of
<code>llvm-project</code>, <code>cargo</code>, and libraries like <code>stdarch</code> and <code>backtrace</code>.</p>
<p>Those projects are developed and maintained in a separate Git (and GitHub)
repository, and they have their own Git history/commits, issue tracker and PRs.
Submodules allow us to create some sort of embedded sub-repository inside the
<code>rust</code> repository and use them like they were directories in the <code>rust</code> repository.</p>
<p>Take <code>llvm-project</code> for example.
<code>llvm-project</code> is maintained in the <a href="https://github.com/rust-lang/llvm-project"><code>rust-lang/llvm-project</code></a>
repository, but it is used in <code>rust-lang/rust</code> by the compiler for code generation and optimization.
We bring it in <code>rust</code> as a submodule, in the <code>src/llvm-project</code> folder.</p>
<p>The contents of submodules are ignored by Git: submodules are in some sense isolated
from the rest of the repository.
However, if you try to <code>cd src/llvm-project</code> and then run <code>git status</code>:</p>
<pre><code class="language-console">HEAD detached at 9567f08afc943
nothing to commit, working tree clean
</code></pre>
<p>As far as git is concerned, you are no longer in the <code>rust</code> repo, but in the <code>llvm-project</code> repo.
You will notice that we are in “detached HEAD” state, i.e. not on a branch but on a
particular commit.</p>
<p>This is because, like any dependency, we want to be able to control which version to use.
Submodules allow us to do just that: every submodule is “pinned” to a certain
commit, which doesn’t change unless modified manually.
If you use <code>git checkout &lt;commit&gt;</code>
in the <code>llvm-project</code> directory and go back to the <code>rust</code> directory, you can stage this
change like any other, e.g. by running <code>git add src/llvm-project</code>. (Note that if
you <em>don’t</em> stage the change to commit, then you run the risk that running
<code>x</code> will just undo your change by switching back to the previous commit when
it automatically “updates” the submodules.)</p>
<p>This version selection is usually done by the maintainers of the project, and
looks like <a href="https://github.com/rust-lang/rust/pull/99464/files">this</a>.</p>
<p>Git submodules take some time to get used to, so don’t worry if it isn’t perfectly clear yet.
You will rarely have to use them directly and, again, you don’t need
to know everything about submodules to contribute to Rust.
Just know that they exist and that they correspond to some sort of embedded subrepository dependency
that Git can nicely and fairly conveniently handle for us.</p>
<h3 id="hard-resetting-submodules"><a class="header" href="#hard-resetting-submodules">Hard-resetting submodules</a></h3>
<p>Sometimes you might run into (when you run <code>git status</code>)</p>
<pre><code class="language-console">Changes not staged for commit:
  (use "git add &lt;file&gt;..." to update what will be committed)
  (use "git restore &lt;file&gt;..." to discard changes in working directory)
  (commit or discard the untracked or modified content in submodules)
        modified:   src/llvm-project (new commits, modified content)
</code></pre>
<p>and when you try to run <code>git submodule update</code> it breaks horribly with errors like</p>
<pre><code class="language-console">error: RPC failed; curl 92 HTTP/2 stream 7 was not closed cleanly: CANCEL (err 8)
error: 2782 bytes of body are still expected
fetch-pack: unexpected disconnect while reading sideband packet
fatal: early EOF
fatal: fetch-pack: invalid index-pack output
fatal: Fetched in submodule path 'src/llvm-project', but it did not contain 5a5152f653959d14d68613a3a8a033fb65eec021. Direct fetching of that commit failed.
</code></pre>
<p>If you see <code>(new commits, modified content)</code> you can run</p>
<pre><code class="language-console">git submodule foreach git reset --hard
</code></pre>
<p>and then try <code>git submodule update</code> again.</p>
<h3 id="deinit-git-submodules"><a class="header" href="#deinit-git-submodules">Deinit git submodules</a></h3>
<p>If that doesn’t work, you can try to deinit all git submodules…</p>
<pre><code class="language-console">git submodule deinit -f --all
</code></pre>
<p>Unfortunately sometimes your local git submodules configuration can become
completely messed up for some reason.</p>
<h3 id="overcoming-fatal-not-a-git-repository-submodulegitmodulessubmodule"><a class="header" href="#overcoming-fatal-not-a-git-repository-submodulegitmodulessubmodule">Overcoming <code>fatal: not a git repository: &lt;submodule&gt;/../../.git/modules/&lt;submodule&gt;</code></a></h3>
<p>Sometimes, for some forsaken reason, you might run into</p>
<pre><code class="language-console">fatal: not a git repository: src/gcc/../../.git/modules/src/gcc
</code></pre>
<p>In this situation, for the given submodule path, i.e. <code>&lt;submodule_path&gt; = src/gcc</code> in this example, you need to:</p>
<ol>
<li><code>rm -rf &lt;submodule_path&gt;/.git</code></li>
<li><code>rm -rf .git/modules/&lt;submodule_path&gt;/config</code></li>
<li><code>rm -rf .gitconfig.lock</code> if somehow the <code>.gitconfig</code> lock is orphaned.</li>
</ol>
<p>Then do something like <code>./x fmt</code> to have bootstrap manage the submodule checkouts for you.</p>
<h2 id="ignoring-commits-during-git-blame"><a class="header" href="#ignoring-commits-during-git-blame">Ignoring commits during <code>git blame</code></a></h2>
<p>Some commits contain large reformatting changes that don’t otherwise change functionality.
They can be instructed to be ignored by <code>git blame</code> through
<a href="https://github.com/rust-lang/rust/blob/HEAD/.git-blame-ignore-revs"><code>.git-blame-ignore-revs</code></a>:</p>
<ol>
<li>Configure <code>git blame</code> to use <code>.git-blame-ignore-revs</code> as the list of commits to ignore: <code>git config blame.ignorerevsfile .git-blame-ignore-revs</code></li>
<li>Add suitable commits that you wish to be ignored by <code>git blame</code>.</li>
</ol>
<p>Please include a comment for the commit that you add to <code>.git-blame-ignore-revs</code> so people can
easily figure out <em>why</em> a commit is ignored.</p>

                    </main>

                    <nav class="nav-wrapper" aria-label="Page navigation">
                        <!-- Mobile navigation buttons -->
                            <a rel="prev" href="compiler-team.html" class="mobile-nav-chapters previous" title="Previous chapter" aria-label="Previous chapter" aria-keyshortcuts="Left">
                                <span class=fa-svg><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M41.4 233.4c-12.5 12.5-12.5 32.8 0 45.3l160 160c12.5 12.5 32.8 12.5 45.3 0s12.5-32.8 0-45.3L109.3 256 246.6 118.6c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0l-160 160z"/></svg></span>
                            </a>

                            <a rel="next prefetch" href="rustbot.html" class="mobile-nav-chapters next" title="Next chapter" aria-label="Next chapter" aria-keyshortcuts="Right">
                                <span class=fa-svg><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M278.6 233.4c12.5 12.5 12.5 32.8 0 45.3l-160 160c-12.5 12.5-32.8 12.5-45.3 0s-12.5-32.8 0-45.3L210.7 256 73.4 118.6c-12.5-12.5-12.5-32.8 0-45.3s32.8-12.5 45.3 0l160 160z"/></svg></span>
                            </a>

                        <div style="clear: both"></div>
                    </nav>
                </div>
            </div>

            <nav class="nav-wide-wrapper" aria-label="Page navigation">
                    <a rel="prev" href="compiler-team.html" class="nav-chapters previous" title="Previous chapter" aria-label="Previous chapter" aria-keyshortcuts="Left">
                        <span class=fa-svg><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M41.4 233.4c-12.5 12.5-12.5 32.8 0 45.3l160 160c12.5 12.5 32.8 12.5 45.3 0s12.5-32.8 0-45.3L109.3 256 246.6 118.6c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0l-160 160z"/></svg></span>
                    </a>

                    <a rel="next prefetch" href="rustbot.html" class="nav-chapters next" title="Next chapter" aria-label="Next chapter" aria-keyshortcuts="Right">
                        <span class=fa-svg><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M278.6 233.4c12.5 12.5 12.5 32.8 0 45.3l-160 160c-12.5 12.5-32.8 12.5-45.3 0s-12.5-32.8 0-45.3L210.7 256 73.4 118.6c-12.5-12.5-12.5-32.8 0-45.3s32.8-12.5 45.3 0l160 160z"/></svg></span>
                    </a>
            </nav>

        </div>

        <template id=fa-eye><span class=fa-svg><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M288 32c-80.8 0-145.5 36.8-192.6 80.6C48.6 156 17.3 208 2.5 243.7c-3.3 7.9-3.3 16.7 0 24.6C17.3 304 48.6 356 95.4 399.4C142.5 443.2 207.2 480 288 480s145.5-36.8 192.6-80.6c46.8-43.5 78.1-95.4 93-131.1c3.3-7.9 3.3-16.7 0-24.6c-14.9-35.7-46.2-87.7-93-131.1C433.5 68.8 368.8 32 288 32zM432 256c0 79.5-64.5 144-144 144s-144-64.5-144-144s64.5-144 144-144s144 64.5 144 144zM288 192c0 35.3-28.7 64-64 64c-11.5 0-22.3-3-31.6-8.4c-.2 2.8-.4 5.5-.4 8.4c0 53 43 96 96 96s96-43 96-96s-43-96-96-96c-2.8 0-5.6 .1-8.4 .4c5.3 9.3 8.4 20.1 8.4 31.6z"/></svg></span></template>
        <template id=fa-eye-slash><span class=fa-svg><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M38.8 5.1C28.4-3.1 13.3-1.2 5.1 9.2S-1.2 34.7 9.2 42.9l592 464c10.4 8.2 25.5 6.3 33.7-4.1s6.3-25.5-4.1-33.7L525.6 386.7c39.6-40.6 66.4-86.1 79.9-118.4c3.3-7.9 3.3-16.7 0-24.6c-14.9-35.7-46.2-87.7-93-131.1C465.5 68.8 400.8 32 320 32c-68.2 0-125 26.3-169.3 60.8L38.8 5.1zM223.1 149.5C248.6 126.2 282.7 112 320 112c79.5 0 144 64.5 144 144c0 24.9-6.3 48.3-17.4 68.7L408 294.5c5.2-11.8 8-24.8 8-38.5c0-53-43-96-96-96c-2.8 0-5.6 .1-8.4 .4c5.3 9.3 8.4 20.1 8.4 31.6c0 10.2-2.4 19.8-6.6 28.3l-90.3-70.8zm223.1 298L373 389.9c-16.4 6.5-34.3 10.1-53 10.1c-79.5 0-144-64.5-144-144c0-6.9 .5-13.6 1.4-20.2L83.1 161.5C60.3 191.2 44 220.8 34.5 243.7c-3.3 7.9-3.3 16.7 0 24.6c14.9 35.7 46.2 87.7 93 131.1C174.5 443.2 239.2 480 320 480c47.8 0 89.9-12.9 126.2-32.5z"/></svg></span></template>
        <template id=fa-copy><span class=fa-svg><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M502.6 70.63l-61.25-61.25C435.4 3.371 427.2 0 418.7 0H255.1c-35.35 0-64 28.66-64 64l.0195 256C192 355.4 220.7 384 256 384h192c35.2 0 64-28.8 64-64V93.25C512 84.77 508.6 76.63 502.6 70.63zM464 320c0 8.836-7.164 16-16 16H255.1c-8.838 0-16-7.164-16-16L239.1 64.13c0-8.836 7.164-16 16-16h128L384 96c0 17.67 14.33 32 32 32h47.1V320zM272 448c0 8.836-7.164 16-16 16H63.1c-8.838 0-16-7.164-16-16L47.98 192.1c0-8.836 7.164-16 16-16H160V128H63.99c-35.35 0-64 28.65-64 64l.0098 256C.002 483.3 28.66 512 64 512h192c35.2 0 64-28.8 64-64v-32h-47.1L272 448z"/></svg></span></template>
        <template id=fa-play><span class=fa-svg><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 384 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M73 39c-14.8-9.1-33.4-9.4-48.5-.9S0 62.6 0 80V432c0 17.4 9.4 33.4 24.5 41.9s33.7 8.1 48.5-.9L361 297c14.3-8.7 23-24.2 23-41s-8.7-32.2-23-41L73 39z"/></svg></span></template>
        <template id=fa-clock-rotate-left><span class=fa-svg><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M75 75L41 41C25.9 25.9 0 36.6 0 57.9V168c0 13.3 10.7 24 24 24H134.1c21.4 0 32.1-25.9 17-41l-30.8-30.8C155 85.5 203 64 256 64c106 0 192 86 192 192s-86 192-192 192c-40.8 0-78.6-12.7-109.7-34.4c-14.5-10.1-34.4-6.6-44.6 7.9s-6.6 34.4 7.9 44.6C151.2 495 201.7 512 256 512c141.4 0 256-114.6 256-256S397.4 0 256 0C185.3 0 121.3 28.7 75 75zm181 53c-13.3 0-24 10.7-24 24V256c0 6.4 2.5 12.5 7 17l72 72c9.4 9.4 24.6 9.4 33.9 0s9.4-24.6 0-33.9l-65-65V152c0-13.3-10.7-24-24-24z"/></svg></span></template>



        <script>
            window.playground_copyable = true;
        </script>


        <script src="elasticlunr-ef4e11c1.min.js"></script>
        <script src="mark-09e88c2c.min.js"></script>
        <script src="searcher-c2a407aa.js"></script>

        <script src="clipboard-1626706a.min.js"></script>
        <script src="highlight-abc7f01d.js"></script>
        <script src="book-a0b12cfe.js"></script>

        <!-- Custom JS scripts -->
        <script src="mermaid-cc85ecea.min.js"></script>
        <script src="mermaid-init-4533fb11.js"></script>



    </div>
    </body>
</html>
