Merge pull request #4284 from rust-lang/rustup-2025-04-22

Automatic Rustup
2025-04-22 05:26:48 +00:00 · 2025-04-22 05:26:48 +00:00 · a57f0a4170
parent 78eada8353 1ede17d264
commit a57f0a4170
34 changed files with 561 additions and 117 deletions
--- a/README.md
+++ b/README.md
@ -43,13 +43,13 @@ rustdocs][rustdocs].
 To build a local static HTML site, install [`mdbook`](https://github.com/rust-lang/mdBook) with:

 ```
-> cargo install mdbook mdbook-linkcheck2 mdbook-toc mdbook-mermaid
+cargo install mdbook mdbook-linkcheck2 mdbook-toc mdbook-mermaid
 ```

 and execute the following command in the root of the repository:

 ```
-> mdbook build --open
+mdbook build --open
 ```

 The build files are found in the `book/html` directory.
@ -61,8 +61,8 @@ checking is **not** run by default locally, though it is in CI. To enable it
 locally, set the environment variable `ENABLE_LINKCHECK=1` like in the
 following example.

-```console
-$ ENABLE_LINKCHECK=1 mdbook serve
+```
+ENABLE_LINKCHECK=1 mdbook serve
 ```

 ### Table of Contents
@ -86,14 +86,14 @@ Older versions of `josh-proxy` may not round trip commits losslessly so it is im
 1) Checkout a new branch that will be used to create a PR into `rust-lang/rustc-dev-guide`
 2) Run the pull command
    ```
-    $ cargo run --manifest-path josh-sync/Cargo.toml rustc-pull
+    cargo run --manifest-path josh-sync/Cargo.toml rustc-pull
    ```
 3) Push the branch to your fork and create a PR into `rustc-dev-guide`

 ### Push changes from this repository into `rust-lang/rust`
 1) Run the push command to create a branch named `<branch-name>` in a `rustc` fork under the `<gh-username>` account
    ```
-    $ cargo run --manifest-path josh-sync/Cargo.toml rustc-push <branch-name> <gh-username>
+    cargo run --manifest-path josh-sync/Cargo.toml rustc-push <branch-name> <gh-username>
    ```
 2) Create a PR from `<branch-name>` into `rust-lang/rust`

@ -106,5 +106,5 @@ You may observe "Nothing to pull" even if you *know* rustc-pull has something to
 To minimize the likelihood of this happening, you may wish to keep a separate *minimal* git config that *only* has `[user]` entries from global git config, then repoint system git to use the minimal git config instead. E.g.

 ```
-$ GIT_CONFIG_GLOBAL=/path/to/minimal/gitconfig GIT_CONFIG_SYSTEM='' cargo +stable run --manifest-path josh-sync/Cargo.toml -- rustc-pull
+GIT_CONFIG_GLOBAL=/path/to/minimal/gitconfig GIT_CONFIG_SYSTEM='' cargo +stable run --manifest-path josh-sync/Cargo.toml -- rustc-pull
 ```
--- a/2
+++ b/2
@ -1 +1 @@
-25a615bf829b9f6d6f22da537e3851043f92e5f2
+b8005bff3248cfc6e327faf4fa631ac49bb49ba9
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@ -10,9 +10,9 @@
 - [How to build and run the compiler](./building/how-to-build-and-run.md)
    - [Quickstart](./building/quickstart.md)
    - [Prerequisites](./building/prerequisites.md)
-    - [Suggested Workflows](./building/suggested.md)
+    - [Suggested workflows](./building/suggested.md)
    - [Distribution artifacts](./building/build-install-distribution-artifacts.md)
-    - [Building Documentation](./building/compiler-documenting.md)
+    - [Building documentation](./building/compiler-documenting.md)
    - [Rustdoc overview](./rustdoc.md)
    - [Adding a new target](./building/new-target.md)
    - [Optimized build](./building/optimized-build.md)
@ -42,11 +42,11 @@
    - [with the linux perf tool](./profiling/with_perf.md)
    - [with Windows Performance Analyzer](./profiling/wpa_profiling.md)
    - [with the Rust benchmark suite](./profiling/with_rustc_perf.md)
- [crates.io Dependencies](./crates-io.md)
+- [crates.io dependencies](./crates-io.md)

 # Contributing to Rust

- [Contribution Procedures](./contributing.md)
+- [Contribution procedures](./contributing.md)
 - [About the compiler team](./compiler-team.md)
 - [Using Git](./git.md)
 - [Mastering @rustbot](./rustbot.md)
@ -56,7 +56,7 @@
 - [Stabilizing Features](./stabilization_guide.md)
 - [Feature Gates](./feature-gates.md)
 - [Coding conventions](./conventions.md)
- [Procedures for Breaking Changes](./bug-fix-procedure.md)
+- [Procedures for breaking changes](./bug-fix-procedure.md)
 - [Using external repositories](./external-repos.md)
 - [Fuzzing](./fuzzing.md)
 - [Notification groups](notification-groups/about.md)
@ -81,6 +81,7 @@
 - [How Bootstrap does it](./building/bootstrapping/how-bootstrap-does-it.md)
 - [Writing tools in Bootstrap](./building/bootstrapping/writing-tools-in-bootstrap.md)
 - [Debugging bootstrap](./building/bootstrapping/debugging-bootstrap.md)
+- [cfg(bootstrap) in dependencies](./building/bootstrapping/bootstrap-in-dependencies.md)

 # High-level Compiler Architecture

@ -88,29 +89,35 @@
 - [Overview of the compiler](./overview.md)
 - [The compiler source code](./compiler-src.md)
 - [Queries: demand-driven compilation](./query.md)
-    - [The Query Evaluation Model in Detail](./queries/query-evaluation-model-in-detail.md)
+    - [The Query Evaluation Model in detail](./queries/query-evaluation-model-in-detail.md)
    - [Incremental compilation](./queries/incremental-compilation.md)
-    - [Incremental compilation In Detail](./queries/incremental-compilation-in-detail.md)
-    - [Debugging and Testing](./incrcomp-debugging.md)
+    - [Incremental compilation in detail](./queries/incremental-compilation-in-detail.md)
+    - [Debugging and testing](./incrcomp-debugging.md)
    - [Salsa](./queries/salsa.md)
- [Memory Management in Rustc](./memory.md)
- [Serialization in Rustc](./serialization.md)
- [Parallel Compilation](./parallel-rustc.md)
+- [Memory management in rustc](./memory.md)
+- [Serialization in rustc](./serialization.md)
+- [Parallel compilation](./parallel-rustc.md)
 - [Rustdoc internals](./rustdoc-internals.md)
    - [Search](./rustdoc-internals/search.md)
 	- [The `rustdoc` test suite](./rustdoc-internals/rustdoc-test-suite.md)
+- [Autodiff internals](./autodiff/internals.md)
+    - [Installation](./autodiff/installation.md)
+    - [How to debug](./autodiff/debugging.md)
+    - [Autodiff flags](./autodiff/flags.md)
+    - [Current limitations](./autodiff/limitations.md)
+
 # Source Code Representation

 - [Prologue](./part-3-intro.md)
 - [Syntax and the AST](./syntax-intro.md)
-    - [Lexing and Parsing](./the-parser.md)
+    - [Lexing and parsing](./the-parser.md)
    - [Macro expansion](./macro-expansion.md)
    - [Name resolution](./name-resolution.md)
    - [Attributes](./attributes.md)
-    - [`#[test]` Implementation](./test-implementation.md)
-    - [Panic Implementation](./panic-implementation.md)
-    - [AST Validation](./ast-validation.md)
-    - [Feature Gate Checking](./feature-gate-ck.md)
+    - [`#[test]` implementation](./test-implementation.md)
+    - [Panic implementation](./panic-implementation.md)
+    - [AST validation](./ast-validation.md)
+    - [Feature gate checking](./feature-gate-ck.md)
    - [Lang Items](./lang-items.md)
 - [The HIR (High-level IR)](./hir.md)
    - [Lowering AST to HIR](./ast-lowering.md)
@ -129,7 +136,7 @@
    - [Example: Type checking](./rustc-driver/interacting-with-the-ast.md)
    - [Example: Getting diagnostics](./rustc-driver/getting-diagnostics.md)
    - [Remarks on perma-unstable features](./rustc-driver/remarks-on-perma-unstable-features.md)
- [Errors and Lints](diagnostics.md)
+- [Errors and lints](diagnostics.md)
    - [Diagnostic and subdiagnostic structs](./diagnostics/diagnostic-structs.md)
    - [Translation](./diagnostics/translation.md)
    - [`LintStore`](./diagnostics/lintstore.md)
@ -175,14 +182,14 @@
 - [Type checking](./type-checking.md)
    - [Method Lookup](./method-lookup.md)
    - [Variance](./variance.md)
-    - [Coherence Checking](./coherence.md)
-    - [Opaque Types](./opaque-types-type-alias-impl-trait.md)
+    - [Coherence checking](./coherence.md)
+    - [Opaque types](./opaque-types-type-alias-impl-trait.md)
        - [Inference details](./opaque-types-impl-trait-inference.md)
        - [Return Position Impl Trait In Trait](./return-position-impl-trait-in-trait.md)
        - [Region inference restrictions][opaque-infer]
 - [Const condition checking](./effects.md)
 - [Pattern and Exhaustiveness Checking](./pat-exhaustive-checking.md)
- [Unsafety Checking](./unsafety-checking.md)
+- [Unsafety checking](./unsafety-checking.md)
 - [MIR dataflow](./mir/dataflow.md)
 - [Drop elaboration](./mir/drop-elaboration.md)
 - [The borrow checker](./borrow_check.md)
--- a/src/about-this-guide.md
+++ b/src/about-this-guide.md
@ -3,33 +3,41 @@
 This guide is meant to help document how rustc – the Rust compiler – works,
 as well as to help new contributors get involved in rustc development.

-There are seven parts to this guide:
+There are several parts to this guide:

-1. [Building `rustc`][p1]:
+1. [Building and debugging `rustc`][p1]:
   Contains information that should be useful no matter how you are contributing,
   about building, debugging, profiling, etc.
-2. [Contributing to `rustc`][p2]:
+1. [Contributing to Rust][p2]:
   Contains information that should be useful no matter how you are contributing,
   about procedures for contribution, using git and Github, stabilizing features, etc.
-3. [High-Level Compiler Architecture][p3]:
+1. [Bootstrapping][p3]:
+   Describes how the Rust compiler builds itself using previous versions, including
+   an introduction to the bootstrap process and debugging methods.
+1. [High-level Compiler Architecture][p4]:
   Discusses the high-level architecture of the compiler and stages of the compile process.
-4. [Source Code Representation][p4]:
+1. [Source Code Representation][p5]:
   Describes the process of taking raw source code from the user
   and transforming it into various forms that the compiler can work with easily.
-5. [Analysis][p5]:
-   discusses the analyses that the compiler uses to check various properties of the code
+1. [Supporting Infrastructure][p6]:
+   Covers command-line argument conventions, compiler entry points like rustc_driver and
+   rustc_interface, and the design and implementation of errors and lints.
+1. [Analysis][p7]:
+   Discusses the analyses that the compiler uses to check various properties of the code
   and inform later stages of the compile process (e.g., type checking).
-6. [From MIR to Binaries][p6]: How linked executable machine code is generated.
-7. [Appendices][p7] at the end with useful reference information.
+1. [MIR to Binaries][p8]: How linked executable machine code is generated.
+1. [Appendices][p9] at the end with useful reference information.
   There are a few of these with different information, including a glossary.

 [p1]: ./building/how-to-build-and-run.html
 [p2]: ./contributing.md
-[p3]: ./part-2-intro.md
-[p4]: ./part-3-intro.md
-[p5]: ./part-4-intro.md
-[p6]: ./part-5-intro.md
-[p7]: ./appendix/background.md
+[p3]: ./building/bootstrapping/intro.md
+[p4]: ./part-2-intro.md
+[p5]: ./part-3-intro.md
+[p6]: ./cli.md
+[p7]: ./part-4-intro.md
+[p8]: ./part-5-intro.md
+[p9]: ./appendix/background.md

 ### Constant change

--- a/src/ast-validation.md
+++ b/src/ast-validation.md
@ -1,4 +1,4 @@
-# AST Validation
+# AST validation

 _AST validation_ is a separate AST pass that visits each
 item in the tree and performs simple checks. This pass
--- a/src/autodiff/debugging.md
+++ b/src/autodiff/debugging.md
@ -0,0 +1,113 @@
+# Reporting backend crashes
+
+If after a compilation failure you are greeted by a large amount of llvm-ir code, then our enzyme backend likely failed to compile your code. These cases are harder to debug, so your help is highly appreciated. Please also keep in mind that release builds are usually much more likely to work at the moment.
+
+The final goal here is to reproduce your bug in the enzyme [compiler explorer](https://enzyme.mit.edu/explorer/), in order to create a bug report in the [Enzyme](https://github.com/enzymead/enzyme/issues) repository.
+
+We have an `autodiff` flag which you can pass to `rustflags` to help with this. it will print the whole llvm-ir module, along with some `__enzyme_fwddiff` or `__enzyme_autodiff` calls. A potential workflow on linux could look like:  
+
+## Controlling llvm-ir generation
+
+Before generating the llvm-ir, keep in mind two techniques that can help ensure the relevant rust code is visible for debugging:
+
+- **`std::hint::black_box`**: wrap rust variables or expressions in `std::hint::black_box()` to prevent rust and llvm from optimizing them away. This is useful when you need to inspect or manually manipulate specific values in the llvm-ir.
+- **`extern "rust"` or `extern "c"`**: if you want to see how a specific function declaration is lowered to llvm-ir, you can declare it as `extern "rust"` or `extern "c"`. You can also look for existing `__enzyme_autodiff` or similar declarations within the generated module for examples.
+
+## 1) Generate an llvm-ir reproducer
+
+```sh
+rustflags="-z autodiff=enable,printmodbefore" cargo +enzyme build --release &> out.ll 
+```
+
+This also captures a few warnings and info messages above and below your module. open out.ll and remove every line above `; moduleid = <somehash>`. Now look at the end of the file and remove everything that's not part of llvm-ir, i.e. remove errors and warnings. The last line of your llvm-ir should now start with `!<somenumber> = `, i.e. `!40831 = !{i32 0, i32 1037508, i32 1037538, i32 1037559}` or `!43760 = !dilocation(line: 297, column: 5, scope: !43746)`.
+
+The actual numbers will depend on your code.  
+
+## 2) Check your llvm-ir reproducer
+
+To confirm that your previous step worked, we will use llvm's `opt` tool. find your path to the opt binary, with a path similar to `<some_dir>/rust/build/<x86/arm/...-target-tripple>/build/bin/opt`. also find `llvmenzyme-19.<so/dll/dylib>` path, similar to `/rust/build/target-tripple/enzyme/build/enzyme/llvmenzyme-19`. Please keep in mind that llvm frequently updates it's llvm backend, so the version number might be higher (20, 21, ...). Once you have both, run the following command:
+
+```sh
+<path/to/opt> out.ll -load-pass-plugin=/path/to/llvmenzyme-19.so -passes="enzyme" -s
+```
+
+If the previous step succeeded, you are going to see the same error that you saw when compiling your rust code with cargo. 
+
+If you fail to get the same error, please open an issue in the rust repository. If you succeed, congrats! the file is still huge, so let's automatically minimize it.
+
+## 3) Minimize your llvm-ir reproducer
+
+First find your `llvm-extract` binary, it's in the same folder as your opt binary. then run:
+
+```sh
+<path/to/llvm-extract> -s --func=<name> --recursive --rfunc="enzyme_autodiff*" --rfunc="enzyme_fwddiff*" --rfunc=<fnc_called_by_enzyme> out.ll -o mwe.ll 
+```
+
+This command creates `mwe.ll`, a minimal working example.
+
+Please adjust the name passed with the last `--func` flag. You can either apply the `#[no_mangle]` attribute to the function you differentiate, then you can replace it with the rust name. otherwise you will need to look up the mangled function name. To do that, open `out.ll` and search for `__enzyme_fwddiff` or `__enzyme_autodiff`. the first string in that function call is the name of your function. example:
+
+```llvm-ir 
+define double @enzyme_opt_helper_0(ptr %0, i64 %1, double %2) {
+  %4 = call double (...) @__enzyme_fwddiff(ptr @_zn2ad3_f217h3b3b1800bd39fde3e, metadata !"enzyme_const", ptr %0, metadata !"enzyme_const", i64 %1, metadata !"enzyme_dup", double %2, double %2)
+  ret double %4
+}
+```
+
+Here, `_zn2ad3_f217h3b3b1800bd39fde3e` is the correct name. make sure to not copy the leading `@`. redo step 2) by running the `opt` command again, but this time passing `mwe.ll` as the input file instead of `out.ll`. Check if this minimized example still reproduces the crash.
+
+## 4) (Optional) Minimize your llvm-ir reproducer further.
+
+After the previous step you should have an `mwe.ll` file with ~5k loc. let's try to get it down to 50. find your `llvm-reduce` binary next to `opt` and `llvm-extract`. Copy the first line of your error message, an example could be:
+
+```sh
+opt: /home/manuel/prog/rust/src/llvm-project/llvm/lib/ir/instructions.cpp:686: void llvm::callinst::init(llvm::functiontype*, llvm::value*, llvm::arrayref<llvm::value*>, llvm::arrayref<llvm::operandbundledeft<llvm::value*> >, const llvm::twine&): assertion `(args.size() == fty->getnumparams() || (fty->isvararg() && args.size() > fty->getnumparams())) && "calling a function with bad signature!"' failed.
+```
+
+If you just get a `segfault` there is no sensible error message and not much to do automatically, so continue to 5).  
+otherwise, create a `script.sh` file containing
+
+```sh
+#!/bin/bash
+<path/to/your/opt> $1 -load-pass-plugin=/path/to/llvmenzyme-19.so -passes="enzyme" \
+    |& grep "/some/path.cpp:686: void llvm::callinst::init"
+```
+
+Experiment a bit with which error message you pass to grep. it should be long enough to make sure that the error is unique. However, for longer errors including `(` or `)` you will need to escape them correctly which can become annoying. Run
+
+```sh 
+<path/to/llvm-reduce> --test=script.sh mwe.ll 
+```
+
+If you see `input isn't interesting! verify interesting-ness test`, you got the error message in script.sh wrong, you need to make sure that grep matches your actual error. If all works out, you will see a lot of iterations, ending with a new `reduced.ll` file. Verify with `opt` that you still get the same error.
+
+### Advanced debugging: manual llvm-ir investigation
+
+Once you have a minimized reproducer (`mwe.ll` or `reduced.ll`), you can delve deeper:
+
+- **manual editing:** try manually rewriting the llvm-ir. for certain issues, like those involving indirect calls, you might investigate enzyme-specific intrinsics like `__enzyme_virtualreverse`. Understanding how to use these might require consulting enzyme's documentation or source code.
+- **enzyme test cases:** look for relevant test cases within the [enzyme repository](https://github.com/enzymead/enzyme/tree/main/enzyme/test) that might demonstrate the correct usage of features or intrinsics related to your problem.
+
+## 5) Report your bug.
+
+Afterwards, you should be able to copy and paste your `mwe.ll` (or `reduced.ll`) example into our [compiler explorer](https://enzyme.mit.edu/explorer/).
+
+- Select `llvm ir` as language and `opt 20` as compiler.
+- Replace the field to the right of your compiler with `-passes="enzyme"`, if it is not already set.
+- Hopefully, you will see once again your now familiar error.
+- Please use the share button to copy links to them.
+- Please create an issue on [https://github.com/enzymead/enzyme/issues](https://github.com/enzymead/enzyme/issues) and share `mwe.ll` and (if you have it) `reduced.ll`, as well as links to the compiler explorer. Please feel free to also add your rust code or a link to it.
+
+#### Documenting findings
+
+some enzyme errors, like `"attempting to call an indirect active function whose runtime value is inactive"`, have historically caused confusion. If you investigate such an issue, even if you don't find a complete solution, please consider documenting your findings. If the insights are general to enzyme and not specific to its rust usage, contributing them to the main [enzyme documentation](https://github.com/enzymead/www) is often the best first step. You can also mention your findings in the relevant enzyme github issue or propose updates to these docs if appropriate. This helps prevent others from starting from scratch.
+
+With a clear reproducer and documentation, hopefully an enzyme developer will be able to fix your bug. Once that happens, the enzyme submodule inside the rust compiler will be updated, which should allow you to differentiate your rust code. Thanks for helping us to improve rust-ad.
+
+# Minimize rust code
+
+Beyond having a minimal llvm-ir reproducer, it is also helpful to have a minimal rust reproducer without dependencies. This allows us to add it as a test case to ci once we fix it, which avoids regressions for the future.
+
+There are a few solutions to help you with minimizing the rust reproducer. This is probably the most simple automated approach: [cargo-minimize](https://github.com/nilstrieb/cargo-minimize).
+
+Otherwise we have various alternatives, including [`treereduce`](https://github.com/langston-barrett/treereduce), [`halfempty`](https://github.com/googleprojectzero/halfempty), or [`picireny`](https://github.com/renatahodovan/picireny), potentially also [`creduce`](https://github.com/csmith-project/creduce).
--- a/src/autodiff/flags.md
+++ b/src/autodiff/flags.md
@ -0,0 +1,42 @@
+# Supported `RUSTFLAGS`
+
+To support you while debugging or profiling, we have added support for an experimental `-Z autodiff` rustc flag (which can be passed to cargo via `RUSTFLAGS`), which allow changing the behaviour of Enzyme, without recompiling rustc. We currently support the following values for `autodiff`.
+
+### Debug Flags
+
+```text
+PrintTA // Print TypeAnalysis information
+PrintAA // Print ActivityAnalysis information
+Print // Print differentiated functions while they are being generated and optimized
+PrintPerf // Print AD related Performance warnings
+PrintModBefore // Print the whole LLVM-IR module directly before running AD
+PrintModAfter // Print the whole LLVM-IR module after running AD, before optimizations
+PrintModFinal // Print the whole LLVM-IR module after running optimizations and AD
+LooseTypes // Risk incorrect derivatives instead of aborting when missing Type Info 
+```
+
+<div class="warning">
+`LooseTypes` is often helpful to get rid of Enzyme errors stating `Can not deduce type of <X>` and to be able to run some code. But please keep in mind that this flag absolutely has the chance to cause incorrect gradients. Even worse, the gradients might be correct for certain input values, but not for others. So please create issues about such bugs and only use this flag temporarily while you wait for your bug to be fixed.
+</div>
+
+### Benchmark flags
+
+For performance experiments and benchmarking we also support
+
+```text
+NoPostopt // We won't optimize the LLVM-IR Module after AD
+RuntimeActivity // Enables the runtime activity feature from Enzyme 
+Inline // Instructs Enzyme to maximize inlining as far as possible, beyond LLVM's default
+```
+
+You can combine multiple `autodiff` values using a comma as separator:
+
+```bash
+RUSTFLAGS="-Z autodiff=Enable,LooseTypes,PrintPerf" cargo +enzyme build
+```
+
+Using `-Zautodiff=Enable` will allow using autodiff and update your normal rustc compilation pipeline:
+
+1. Run your selected compilation pipeline. If you selected a release build, we will disable vectorization and loop unrolling.
+2. Differentiate your functions.
+3. Run your selected compilation pipeline again on the whole module. This time we do not disable vectorization or loop unrolling.
--- a/src/autodiff/installation.md
+++ b/src/autodiff/installation.md
@ -0,0 +1,86 @@
+# Installation
+
+In the near future, `std::autodiff` should become available in nightly builds for users. As a contribute however, you will still need to build rustc from source. Please be aware that the msvc target is not supported at the moment, all other tier 1 targets should work. Please open an issue if you encounter any problems on a supported tier 1 target, or if you succesfully build this project on a tier2/tier3 target.
+
+## Build instructions
+
+First you need to clone and configure the Rust repository:
+```bash
+git clone --depth=1 git@github.com:rust-lang/rust.git
+cd rust
+./configure --enable-llvm-link-shared --enable-llvm-plugins --enable-llvm-enzyme --release-channel=nightly --enable-llvm-assertions --enable-clang --enable-lld --enable-option-checking --enable-ninja --disable-docs
+```
+
+Afterwards you can build rustc using:
+```bash
+./x.py build --stage 1 library
+```
+
+Afterwards rustc toolchain link will allow you to use it through cargo:
+```
+rustup toolchain link enzyme build/host/stage1
+rustup toolchain install nightly # enables -Z unstable-options
+```
+
+You can then run our test cases:
+
+```bash
+./x.py test --stage 1 library tests/ui/autodiff
+./x.py test --stage 1 library tests/codegen/autodiff
+./x.py test --stage 1 library tests/pretty/autodiff*
+```
+
+Autodiff is still experimental, so if you want to use it in your own projects, you will need to add `lto="fat"` to your Cargo.toml 
+and use `RUSTFLAGS="-Zautodiff=Enable" cargo +enzyme` instead of `cargo` or `cargo +nightly`. 
+
+## Compiler Explorer and dist builds
+
+Our compiler explorer instance can be updated to a newer rustc in a similar way. First, prepare a docker instance.
+```bash
+docker run -it ubuntu:22.04
+export CC=clang CXX=clang++
+apt update
+apt install wget vim python3 git curl libssl-dev pkg-config lld ninja-build cmake clang build-essential 
+```
+Then build rustc in a slightly altered way:
+```bash
+git clone --depth=1 https://github.com/EnzymeAD/rust.git
+cd rust
+./configure --enable-llvm-link-shared --enable-llvm-plugins --enable-llvm-enzyme --release-channel=nightly --enable-llvm-assertions --enable-clang --enable-lld --enable-option-checking --enable-ninja --disable-docs
+./x dist
+```
+We then copy the tarball to our host. The dockerid is the newest entry under `docker ps -a`.
+```bash
+docker cp <dockerid>:/rust/build/dist/rust-nightly-x86_64-unknown-linux-gnu.tar.gz rust-nightly-x86_64-unknown-linux-gnu.tar.gz
+```
+Afterwards we can create a new (pre-release) tag on the EnzymeAD/rust repository and make a PR against the EnzymeAD/enzyme-explorer repository to update the tag.
+Remember to ping `tgymnich` on the PR to run his update script.
+
+
+## Build instruction for Enzyme itself
+
+Following the Rust build instruction above will build LLVMEnzyme, LLDEnzyme, and ClangEnzyme along with the Rust compiler.
+We recommend that approach, if you just want to use any of them and have no experience with cmake.
+However, if you prefer to just build Enzyme without Rust, then these instructions might help.
+
+```bash
+git clone --depth=1 git@github.com:llvm/llvm-project.git 
+cd llvm-project
+mkdir build
+cd build
+cmake -G Ninja ../llvm -DLLVM_TARGETS_TO_BUILD="host" -DLLVM_ENABLE_ASSERTIONS=ON -DLLVM_ENABLE_PROJECTS="clang;lld" -DLLVM_ENABLE_RUNTIMES="openmp" -DLLVM_ENABLE_PLUGINS=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=.
+ninja
+ninja install
+```
+This gives you a working LLVM build, now we can continue with building Enzyme.
+Leave the `llvm-project` folder, and execute the following commands:
+```bash
+git clone git@github.com:EnzymeAD/Enzyme.git 
+cd Enzyme/enzyme
+mkdir build 
+cd build 
+cmake .. -G Ninja -DLLVM_DIR=<YourLocalPath>/llvm-project/build/lib/cmake/llvm/ -DLLVM_EXTERNAL_LIT=<YourLocalPath>/llvm-project/llvm/utils/lit/lit.py -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=YES -DBUILD_SHARED_LIBS=ON
+ninja
+```
+This will build Enzyme, and you can find it in `Enzyme/enzyme/build/lib/<LLD/Clang/LLVM>Enzyme.so`. (Endings might differ based on your OS).
+
--- a/src/autodiff/internals.md
+++ b/src/autodiff/internals.md
@ -0,0 +1,27 @@
+The `std::autodiff` module in Rust allows differentiable programming:
+
+```rust
+#![feature(autodiff)]
+use std::autodiff::autodiff;
+
+// f(x) = x * x, f'(x) = 2.0 * x
+// bar therefore returns (x * x, 2.0 * x)
+#[autodiff(bar, Reverse, Active, Active)]
+fn foo(x: f32) -> f32 { x * x }
+
+fn main() {
+    assert_eq!(bar(3.0, 1.0), (9.0, 6.0));
+    assert_eq!(bar(4.0, 1.0), (16.0, 8.0));
+}
+```
+
+The detailed documentation for the `std::autodiff` module is available at [std::autodiff](https://doc.rust-lang.org/std/autodiff/index.html).
+
+Differentiable programing is used in various fields like numerical computing, [solid mechanics][ratel], [computational chemistry][molpipx], [fluid dynamics][waterlily] or for Neural Network training via Backpropagation, [ODE solver][diffsol], [differentiable rendering][libigl], [quantum computing][catalyst], and climate simulations.
+
+[ratel]: https://gitlab.com/micromorph/ratel
+[molpipx]: https://arxiv.org/abs/2411.17011v
+[waterlily]: https://github.com/WaterLily-jl/WaterLily.jl
+[diffsol]: https://github.com/martinjrobins/diffsol
+[libigl]: https://github.com/alecjacobson/libigl-enzyme-example?tab=readme-ov-file#run
+[catalyst]: https://github.com/PennyLaneAI/catalyst
--- a/src/autodiff/limitations.md
+++ b/src/autodiff/limitations.md
@ -0,0 +1,27 @@
+# Current limitations
+ 
+## Safety and Soundness
+
+Enzyme currently assumes that the user passes shadow arguments (`dx`, `dy`, ...) of appropriate size. Under Reverse Mode, we additionally assume that shadow arguments are mutable. In Reverse Mode we adjust the outermost pointer or reference to be mutable. Therefore `&f32` will receive the shadow type `&mut f32`. However, we do not check length for other types than slices (e.g. enums, Vec). We also do not enforce mutability of inner references, but will warn if we recognize them. We do intend to add additional checks over time.
+
+## ABI adjustments
+
+In some cases, a function parameter might get lowered in a way that we currently don't handle correctly, leading to a compile time type mismatch in the `rustc_codegen_llvm` backend. Here are some [examples](https://github.com/EnzymeAD/rust/issues/105).
+
+## Compile Times
+
+Enzyme will often achieve excellent runtime performance, but might increase your compile time by a large factor. For Rust, we already have made significant improvements and have a list of further improvements planed - please reach out if you have time to help here.
+
+### Type Analysis
+
+Most of the times, Type Analysis (TA) is the reason of large (>5x) compile time increases when using Enzyme. This poster explains why we need to run Type Analysis in the bottom left part: [Poster Link](https://c.wsmoses.com/posters/Enzyme-llvmdev.pdf).
+
+We intend to increase the number of locations where we pass down Type information based on Rust types, which in turn will reduce the number of locations where Enzyme has to run Type Analysis, which will help compile times.
+
+### Duplicated Optimizations
+
+The key reason for Enzyme offering often excellent performance is that Enzyme differentiates already optimized LLVM-IR. However, we also (have to) run LLVM's optimization pipeline after differentiating, to make sure that the code which Enzyme generates is optimized properly. As a result you should have excellent runtime performance (please fill an issue if not), but at a compile time cost for running optimizations twice.
+
+### Fat-LTO 
+
+The usage of `#[autodiff(...)]` currently requires compiling your project with Fat-LTO. We technically only need LTO if the function being differentiated calls functions in other compilation units. Therefore, other solutions are possible, but this is the most simple one to get started. 
--- a/src/bug-fix-procedure.md
+++ b/src/bug-fix-procedure.md
@ -1,4 +1,4 @@
-# Procedures for Breaking Changes
+# Procedures for breaking changes

 <!-- toc -->

--- a/src/building/bootstrapping/bootstrap-in-dependencies.md
+++ b/src/building/bootstrapping/bootstrap-in-dependencies.md
@ -0,0 +1,53 @@
+# `cfg(bootstrap)` in compiler dependencies
+
+The rust compiler uses some external crates that can run into cyclic dependencies with the compiler itself: the compiler needs an updated crate to build, but the crate needs an updated compiler. This page describes how `#[cfg(bootstrap)]` can be used to break this cycle.
+
+## Enabling `#[cfg(bootstrap)]`
+
+Usually the use of `#[cfg(bootstrap)]` in an external crate causes a warning:
+
+```
+warning: unexpected `cfg` condition name: `bootstrap`
+ --> src/main.rs:1:7
+  |
+1 | #[cfg(bootstrap)]
+  |       ^^^^^^^^^
+  |
+  = help: expected names are: `docsrs`, `feature`, and `test` and 31 more
+  = help: consider using a Cargo feature instead
+  = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
+           [lints.rust]
+           unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bootstrap)'] }
+  = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bootstrap)");` to the top of the `build.rs`
+  = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
+  = note: `#[warn(unexpected_cfgs)]` on by default
+```
+
+This warning can be silenced by adding these lines to the project's `Cargo.toml`:
+
+```toml
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bootstrap)'] }
+```
+
+Now `#[cfg(bootstrap)]` can be used in the crate just like it can be in the compiler: when the bootstrap compiler is used, code annotated with `#[cfg(bootstrap)]` is compiled, otherwise code annotated with `#[cfg(not(bootstrap))]` is compiled.
+
+## The update dance
+
+As a concrete example we'll use a change where the `#[naked]` attribute was made into an unsafe attribute, which caused a cyclic dependency with the `compiler-builtins` crate.
+
+### Step 1: accept the new behavior in the compiler ([#139797](https://github.com/rust-lang/rust/pull/139797))
+
+In this example it is possible to accept both the old and new behavior at the same time by disabling an error.
+
+### Step 2: update the crate ([#821](https://github.com/rust-lang/compiler-builtins/pull/821))
+
+Now in the crate, use `#[cfg(bootstrap)]` to use the old behavior, or `#[cfg(not(bootstrap))]` to use the new behavior.
+
+### Step 3: update the crate version used by the compiler ([#139934](https://github.com/rust-lang/rust/pull/139934))
+
+For `compiler-builtins` this meant a version bump, in other cases it may be a git submodule update.
+
+### Step 4: remove the old behavior from the compiler ([#139753](https://github.com/rust-lang/rust/pull/139753))
+
+The updated crate can now be used. In this example that meant that the old behavior could be removed.
--- a/src/building/suggested.md
+++ b/src/building/suggested.md
@ -1,4 +1,4 @@
-# Suggested Workflows
+# Suggested workflows

 The full bootstrapping process takes quite a while. Here are some suggestions to
 make your life easier.
@ -20,6 +20,43 @@ your `.git/hooks` folder as `pre-push` (without the `.sh` extension!).

 You can also install the hook as a step of running `./x setup`!

+## Config extensions
+
+When working on different tasks, you might need to switch between different bootstrap configurations.
+Sometimes you may want to keep an old configuration for future use. But saving raw config values in
+random files and manually copying and pasting them can quickly become messy, especially if you have a
+long history of different configurations.
+
+To simplify managing multiple configurations, you can create config extensions.
+
+For example, you can create a simple config file named `cross.toml`:
+
+```toml
+[build]
+build = "x86_64-unknown-linux-gnu"
+host = ["i686-unknown-linux-gnu"]
+target = ["i686-unknown-linux-gnu"]
+
+
+[llvm]
+download-ci-llvm = false
+
+[target.x86_64-unknown-linux-gnu]
+llvm-config = "/path/to/llvm-19/bin/llvm-config"
+```
+
+Then, include this in your `bootstrap.toml`:
+
+```toml
+include = ["cross.toml"]
+```
+
+You can also include extensions within extensions recursively.
+
+**Note:** In the `include` field, the overriding logic follows a right-to-left order. For example,
+in `include = ["a.toml", "b.toml"]`, extension `b.toml` overrides `a.toml`. Also, parent extensions
+always overrides the inner ones.
+
 ## Configuring `rust-analyzer` for `rustc`

 ### Project-local rust-analyzer setup
--- a/src/coherence.md
+++ b/src/coherence.md
@ -1,4 +1,3 @@
-
 # Coherence

 > NOTE: this is based on [notes by @lcnr](https://github.com/rust-lang/rust/pull/121848)
--- a/src/contributing.md
+++ b/src/contributing.md
@ -1,4 +1,4 @@
-# Contribution Procedures
+# Contribution procedures

 <!-- toc -->

@ -150,6 +150,20 @@ when contributing to Rust under [the git section](./git.md).
 [t-compiler]: https://rust-lang.zulipchat.com/#narrow/stream/131828-t-compiler
 [triagebot]: https://github.com/rust-lang/rust/blob/master/triagebot.toml

+### Keeping your branch up-to-date
+
+The CI in rust-lang/rust applies your patches directly against the current master,
+not against the commit your branch is based on. This can lead to unexpected failures
+if your branch is outdated, even when there are no explicit merge conflicts.
+
+Before submitting or updating a PR, make sure to update your branch
+as mentioned [here](git.md#keeping-things-up-to-date) if it's significantly
+behind the master branch (e.g., more than 100 commits behind).
+This fetches the latest master branch and rebases your changes on top of it,
+ensuring your PR is tested against the latest code.
+
+After rebasing, it's recommended to [run the relevant tests locally](tests/intro.md) to catch any issues before CI runs.
+
 ### r?

 All pull requests are reviewed by another person. We have a bot,
@ -346,7 +360,7 @@ function in the same way as other pull requests.
 [`src/doc`]: https://github.com/rust-lang/rust/tree/master/src/doc
 [std-root]: https://github.com/rust-lang/rust/blob/master/library/std/src/lib.rs#L1

-To find documentation-related issues, sort by the [A-docs label].
+To find documentation-related issues, use the [A-docs label].

 You can find documentation style guidelines in [RFC 1574].

@ -373,7 +387,7 @@ Just a few things to keep in mind:
  There is no strict limit on line lengths; let the sentence or part of the sentence flow to its proper end on the same line.

 - When contributing text to the guide, please contextualize the information with some time period
-  and/or a reason so that the reader knows how much to trust or mistrust the information.
+  and/or a reason so that the reader knows how much to trust the information.
  Aim to provide a reasonable amount of context, possibly including but not limited to:

  - A reason for why the data may be out of date other than "change",
@ -387,28 +401,28 @@ Just a few things to keep in mind:
    - jan 2021
    - january 2021

-    There is a CI action (in `~/.github/workflows/date-check.yml`)
-    that generates a monthly showing those that are over 6 months old
+    There is a CI action (in `.github/workflows/date-check.yml`)
+    that generates a monthly report showing those that are over 6 months old
    ([example](https://github.com/rust-lang/rustc-dev-guide/issues/2052)).

    For the action to pick the date,
    add a special annotation before specifying the date:

    ```md
-    <!-- date-check --> Sep 2024
+    <!-- date-check --> Apr 2025
    ```

    Example:

    ```md
-    As of <!-- date-check --> Sep 2024, the foo did the bar.
+    As of <!-- date-check --> Apr 2025, the foo did the bar.
    ```

    For cases where the date should not be part of the visible rendered output,
    use the following instead:

    ```md
-    <!-- date-check: Sep 2024 -->
+    <!-- date-check: Apr 2025 -->
    ```

  - A link to a relevant WG, tracking issue, `rustc` rustdoc page, or similar, that may provide
--- a/src/conventions.md
+++ b/src/conventions.md
@ -1,3 +1,5 @@
+# Coding conventions
+
 This file offers some tips on the coding conventions for rustc. This
 chapter covers [formatting](#formatting), [coding for correctness](#cc),
 [using crates from crates.io](#cio), and some tips on
@ -5,7 +7,7 @@ chapter covers [formatting](#formatting), [coding for correctness](#cc),

 <a id="formatting"></a>

-# Formatting and the tidy script
+## Formatting and the tidy script

 rustc is moving towards the [Rust standard coding style][fmt].

@ -20,44 +22,42 @@ Formatting is checked by the `tidy` script. It runs automatically when you do
 `./x test` and can be run in isolation with `./x fmt --check`.

 If you want to use format-on-save in your editor, the pinned version of
-`rustfmt` is built under `build/<target>/stage0/bin/rustfmt`. You'll have to
-pass the <!-- date-check: nov 2022 --> `--edition=2021` argument yourself when calling
-`rustfmt` directly.
+`rustfmt` is built under `build/<target>/stage0/bin/rustfmt`.

 [fmt]: https://github.com/rust-dev-tools/fmt-rfcs
-
 [`rustfmt`]:https://github.com/rust-lang/rustfmt

-## Formatting C++ code
+### Formatting C++ code

 The compiler contains some C++ code for interfacing with parts of LLVM that
 don't have a stable C API.
 When modifying that code, use this command to format it:

-```sh
-./x test tidy --extra-checks=cpp:fmt --bless
+```console
+./x test tidy --extra-checks cpp:fmt --bless
 ```

 This uses a pinned version of `clang-format`, to avoid relying on the local
 environment.

-## Formatting and linting Python code
+### Formatting and linting Python code

 The Rust repository contains quite a lot of Python code. We try to keep
-it both linted and formatted by the [ruff][ruff] tool.
+it both linted and formatted by the [ruff] tool.

 When modifying Python code, use this command to format it:
-```sh
-./x test tidy --extra-checks=py:fmt --bless
+
+```console
+./x test tidy --extra-checks py:fmt --bless
 ```

-and the following command to run lints:
-```sh
-./x test tidy --extra-checks=py:lint
+And, the following command to run lints:
+
+```console
+./x test tidy --extra-checks py:lint
 ```

-This uses a pinned version of `ruff`, to avoid relying on the local
-environment.
+These use a pinned version of `ruff`, to avoid relying on the local environment.

 [ruff]: https://github.com/astral-sh/ruff

@ -65,7 +65,7 @@ environment.

 <!-- REUSE-IgnoreStart -->
 <!-- Prevent REUSE from interpreting the heading as a copyright notice -->
-## Copyright notice
+### Copyright notice
 <!-- REUSE-IgnoreEnd -->

 In the past, files began with a copyright and license notice. Please **omit**
@ -75,41 +75,42 @@ MIT/Apache-2.0).
 All of the copyright notices should be gone by now, but if you come across one
 in the rust-lang/rust repo, feel free to open a PR to remove it.

-## Line length
+### Line length

 Lines should be at most 100 characters. It's even better if you can
 keep things to 80.

-**Ignoring the line length limit.** Sometimes – in particular for
-tests – it can be necessary to exempt yourself from this limit. In
-that case, you can add a comment towards the top of the file like so:
+Sometimes, and particularly for tests, it can be necessary to exempt yourself from this limit.
+In that case, you can add a comment towards the top of the file like so:

 ```rust
 // ignore-tidy-linelength
 ```

-## Tabs vs spaces
+### Tabs vs spaces

-Prefer 4-space indent.
+Prefer 4-space indents.

 <a id="cc"></a>

-# Coding for correctness
+## Coding for correctness

 Beyond formatting, there are a few other tips that are worth
 following.

-## Prefer exhaustive matches
+### Prefer exhaustive matches

 Using `_` in a match is convenient, but it means that when new
 variants are added to the enum, they may not get handled correctly.
 Ask yourself: if a new variant were added to this enum, what's the
 chance that it would want to use the `_` code, versus having some
 other treatment? Unless the answer is "low", then prefer an
-exhaustive match. (The same advice applies to `if let` and `while
-let`, which are effectively tests for a single variant.)
+exhaustive match.

-## Use "TODO" comments for things you don't want to forget
+The same advice applies to `if let` and `while let`,
+which are effectively tests for a single variant.
+
+### Use "TODO" comments for things you don't want to forget

 As a useful tool to yourself, you can insert a `// TODO` comment
 for something that you want to get back to before you land your PR:
@ -136,13 +137,13 @@ if foo {

 <a id="cio"></a>

-# Using crates from crates.io
+## Using crates from crates.io

 See the [crates.io dependencies][crates] section.

 <a id="er"></a>

-# How to structure your PR
+## How to structure your PR

 How you prepare the commits in your PR can make a big difference for the
 reviewer. Here are some tips.
@ -172,7 +173,7 @@ require that every intermediate commit successfully builds – we only
 expect to be able to bisect at a PR level. However, if you *can* make
 individual commits build, that is always helpful.

-# Naming conventions
+## Naming conventions

 Apart from normal Rust style/naming conventions, there are also some specific
 to the compiler.
--- a/src/crates-io.md
+++ b/src/crates-io.md
@ -1,4 +1,4 @@
-# crates.io Dependencies
+# crates.io dependencies

 The Rust compiler supports building with some dependencies from `crates.io`.
 Examples are `log` and `env_logger`.
--- a/src/diagnostics.md
+++ b/src/diagnostics.md
@ -1,4 +1,4 @@
-# Errors and Lints
+# Errors and lints

 <!-- toc -->

@ -772,7 +772,7 @@ store.register_renamed("single_use_lifetime", "single_use_lifetimes");
 [`store.register_removed`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/struct.LintStore.html#method.register_removed
 [`rustc_lint::register_builtins`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/fn.register_builtins.html

-### Lint Groups
+### Lint groups

 Lints can be turned on in groups. These groups are declared in the
 [`register_builtins`][rbuiltins] function in [`rustc_lint::lib`][builtin]. The
--- a/src/feature-gates.md
+++ b/src/feature-gates.md
@ -1,4 +1,4 @@
-# Feature Gates
+# Feature gates

 This chapter is intended to provide basic help for adding, removing, and
 modifying feature gates.
--- a/src/hir.md
+++ b/src/hir.md
@ -144,7 +144,7 @@ that `n` must be some HIR expression, you can do
 Finally, you can find the parents of nodes, via
 calls like [`tcx.parent_hir_node(n)`][parent_hir_node].

-[get_parent_item]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyCtxt.html#method.parent_hir_node
+[parent_hir_node]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyCtxt.html#method.parent_hir_node


 ## HIR Bodies
--- a/src/incrcomp-debugging.md
+++ b/src/incrcomp-debugging.md
@ -1,4 +1,4 @@
-# Debugging and Testing Dependencies
+# Debugging and testing dependencies

 ## Testing the dependency graph

--- a/src/memory.md
+++ b/src/memory.md
@ -1,4 +1,4 @@
-# Memory Management in Rustc
+# Memory management in rustc

 Generally rustc tries to be pretty careful how it manages memory.
 The compiler allocates _a lot_ of data structures throughout compilation,
--- a/src/panic-implementation.md
+++ b/src/panic-implementation.md
@ -1,4 +1,4 @@
-# Panicking in rust
+# Panicking in Rust

 <!-- toc -->

--- a/src/parallel-rustc.md
+++ b/src/parallel-rustc.md
@ -1,4 +1,4 @@
-# Parallel Compilation
+# Parallel compilation

 <div class="warning">
 As of <!-- date-check --> November 2024,
@ -28,7 +28,7 @@ The following sections are kept for now but are quite outdated.

 [codegen]: backend/codegen.md

-## Code Generation
+## Code generation

 During monomorphization the compiler splits up all the code to
 be generated into smaller chunks called _codegen units_. These are then generated by
@ -38,7 +38,7 @@ occurs in the [`rustc_codegen_ssa::base`] module.

 [`rustc_codegen_ssa::base`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/base/index.html

-## Data Structures
+## Data structures

 The underlying thread-safe data-structures used in the parallel compiler
 can be found in the [`rustc_data_structures::sync`] module. These data structures 
@ -83,7 +83,7 @@ can be accessed directly through `Deref::deref`.
 [`rustc_data_structures::sync::worker_local`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_data_structures/sync/worker_local/index.html
 [`WorkerLocal`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_data_structures/sync/worker_local/struct.WorkerLocal.html

-## Parallel Iterator
+## Parallel iterator

 The parallel iterators provided by the [`rayon`] crate are easy ways to
 implement parallelism. In the current implementation of the parallel compiler
@ -124,7 +124,7 @@ the parallel iterator function has been used are as follows:

 There are still many loops that have the potential to use parallel iterators.

-## Query System
+## Query system

 The query model has some properties that make it actually feasible to evaluate
 multiple queries in parallel without too much effort:
--- a/src/queries/incremental-compilation-in-detail.md
+++ b/src/queries/incremental-compilation-in-detail.md
@ -1,4 +1,4 @@
-# Incremental Compilation In Detail
+# Incremental Compilation in detail

 <!-- toc -->

--- a/src/queries/query-evaluation-model-in-detail.md
+++ b/src/queries/query-evaluation-model-in-detail.md
@ -1,4 +1,4 @@
-# The Query Evaluation Model in Detail
+# The Query Evaluation Model in detail

 <!-- toc -->

--- a/src/serialization.md
+++ b/src/serialization.md
@ -1,4 +1,4 @@
-# Serialization in Rustc
+# Serialization in rustc

 rustc has to [serialize] and deserialize various data during compilation.
 Specifically:
--- a/src/test-implementation.md
+++ b/src/test-implementation.md
@ -83,7 +83,7 @@ with your hand-written one, it will not share a [Symbol][Symbol]. This
 technique prevents name collision during code generation and is the foundation
 of Rust's [`macro`] hygiene.

-## Step 2: Harness Generation
+## Step 2: Harness generation

 Now that our tests are accessible from the root of our crate, we need to do
 something with them using [`rustc_ast`][ast] generates a module like so:
@ -106,7 +106,7 @@ called [`test`][test] that is part of Rust core, that implements all of the
 runtime for testing. [`test`][test]'s interface is unstable, so the only stable way
 to interact with it is through the `#[test]` macro.

-## Step 3: Test Object Generation
+## Step 3: Test object generation

 If you've written tests in Rust before, you may be familiar with some of the
 optional attributes available on test functions. For example, a test can be
--- a/src/tests/ecosystem.md
+++ b/src/tests/ecosystem.md
@ -15,9 +15,11 @@ CI. See the [Crater chapter](crater.md) for more details.

 `cargotest` is a small tool which runs `cargo test` on a few sample projects
 (such as `servo`, `ripgrep`, `tokei`, etc.). This runs as part of CI and ensures
-there aren't any significant regressions.
+there aren't any significant regressions:

-> Example: `./x test src/tools/cargotest`
+```console
+./x test src/tools/cargotest
+```

 ### Large OSS Project builders

--- a/src/tests/ui.md
+++ b/src/tests/ui.md
@ -303,7 +303,7 @@ It should be preferred to using `error-pattern`, which is imprecise and non-exha
 ### `error-pattern`

 The `error-pattern` [directive](directives.md) can be used for runtime messages, which don't
-have a specific span, or in exceptional cases for compile time messages.
+have a specific span, or in exceptional cases, for compile time messages.

 Let's think about this test:

@ -316,7 +316,7 @@ fn main() {
 }
 ```

-We want to ensure this shows "index out of bounds" but we cannot use the `ERROR`
+We want to ensure this shows "index out of bounds", but we cannot use the `ERROR`
 annotation since the runtime error doesn't have any span. Then it's time to use the
 `error-pattern` directive:

@ -333,18 +333,19 @@ fn main() {
 Use of `error-pattern` is not recommended in general.

 For strict testing of compile time output, try to use the line annotations `//~` as much as
-possible, including `//~?` annotations for diagnostics without span.
+possible, including `//~?` annotations for diagnostics without spans.

 If the compile time output is target dependent or too verbose, use directive
 `//@ dont-require-annotations: <diagnostic-kind>` to make the line annotation checking
-non-exhaustive, some of the compiler messages can stay uncovered by annotations in this mode.
+non-exhaustive.
+Some of the compiler messages can stay uncovered by annotations in this mode.

-For checking runtime output `//@ check-run-results` may be preferable.
+For checking runtime output, `//@ check-run-results` may be preferable.

 Only use `error-pattern` if none of the above works.

 Line annotations `//~` are still checked in tests using `error-pattern`.
-In exceptional cases use `//@ compile-flags: --error-format=human` to opt out of these checks.
+In exceptional cases, use `//@ compile-flags: --error-format=human` to opt out of these checks.

 ### Diagnostic kinds (error levels)

@ -596,4 +597,27 @@ with "user-facing" Rust alone. Indeed, one could say that this slightly abuses
 the term "UI" (*user* interface) and turns such UI tests from black-box tests
 into white-box ones. Use them carefully and sparingly.

-[compiler debugging]: ../compiler-debugging.md#rustc_test-attributes
+[compiler debugging]: ../compiler-debugging.md#rustc_-test-attributes
+
+## UI test mode preset lint levels
+
+By default, test suites under UI test mode (`tests/ui`, `tests/ui-fulldeps`,
+but not `tests/rustdoc-ui`) will specify
+
+- `-A unused`
+- `-A internal_features`
+
+If:
+
+- The ui test's pass mode is below `run` (i.e. check or build).
+- No compare modes are specified.
+
+Since they can be very noisy in ui tests.
+
+You can override them with `compile-flags` lint level flags or
+in-source lint level attributes as required.
+
+Note that the `rustfix` version will *not* have `-A unused` passed,
+meaning that you may have to `#[allow(unused)]` to suppress `unused`
+lints on the rustfix'd file (because we might be testing rustfix
+on `unused` lints themselves).
--- a/src/the-parser.md
+++ b/src/the-parser.md
@ -1,4 +1,4 @@
-# Lexing and Parsing
+# Lexing and parsing

 The very first thing the compiler does is take the program (in UTF-8 Unicode text)
 and turn it into a data format the compiler can work with more conveniently than strings.
@ -59,7 +59,7 @@ Note that while parsing, we may encounter macro definitions or invocations.
 We set these aside to be expanded (see [Macro Expansion](./macro-expansion.md)).
 Expansion itself may require parsing the output of a macro, which may reveal more macros to be expanded, and so on.

-## More on Lexical Analysis
+## More on lexical analysis

 Code for lexical analysis is split between two crates:

--- a/src/unsafety-checking.md
+++ b/src/unsafety-checking.md
@ -1,4 +1,4 @@
-# Unsafety Checking
+# Unsafety checking

 Certain expressions in Rust can violate memory safety and as such need to be
 inside an `unsafe` block or function. The compiler will also warn if an unsafe
--- a/src/walkthrough.md
+++ b/src/walkthrough.md
@ -221,7 +221,7 @@ There are a couple of things that may happen for some PRs during the review proc
  some merge conflicts with other PRs that happen to get merged first. You
  should fix these merge conflicts using the normal git procedures.

-[crater]: ./tests/intro.html#crater
+[crater]: ./tests/crater.html

 If you are not doing a new feature or something like that (e.g. if you are
 fixing a bug), then that's it! Thanks for your contribution :)
--- a/triagebot.toml
+++ b/triagebot.toml
@ -7,5 +7,9 @@ allow-unauthenticated = [
    "blocked",
 ]

+[no-mentions]
+
+[canonicalize-issue-links]
+
 # Automatically close and reopen PRs made by bots to run CI on them
 [bot-pull-requests]