@@ -1 +1 @@
-7fb284d9037fa54f6a9b24261c82b394472cbfd7
+390279b302ca98ae270f434100ae3730531d1246
@@ -86,7 +86,7 @@
 - [Debugging bootstrap](./building/bootstrapping/debugging-bootstrap.md)
 - [cfg(bootstrap) in dependencies](./building/bootstrapping/bootstrap-in-dependencies.md)
 
-# High-level Compiler Architecture
+# High-level compiler architecture
 
 - [Prologue](./part-2-intro.md)
 - [Overview of the compiler](./overview.md)
@@ -115,7 +115,7 @@
     - [Autodiff flags](./autodiff/flags.md)
     - [Type Trees](./autodiff/type-trees.md)
 
-# Source Code Representation
+# Source code representation
 
 - [Prologue](./part-3-intro.md)
 - [Syntax and the AST](./syntax-intro.md)
@@ -140,7 +140,7 @@
     - [MIR queries and passes: getting the MIR](./mir/passes.md)
 - [Inline assembly](./asm.md)
 
-# Supporting Infrastructure
+# Supporting infrastructure
 
 - [Command-line arguments](./cli.md)
 - [rustc_driver and rustc_interface](./rustc-driver/intro.md)
@@ -167,8 +167,8 @@
     - [ADTs and Generic Arguments](./ty-module/generic-arguments.md)
     - [Parameter types/consts/regions](./ty-module/param-ty-const-regions.md)
 - [`TypeFolder` and `TypeFoldable`](./ty-fold.md)
-- [Aliases and Normalization](./normalization.md)
-- [Typing/Param Envs](./typing-parameter-envs.md)
+- [Aliases and normalization](./normalization.md)
+- [Typing/Param envs](./typing-parameter-envs.md)
 - [Type inference](./type-inference.md)
 - [Trait solving](./traits/resolution.md)
     - [Higher-ranked trait bounds](./traits/hrtb.md)
@@ -199,7 +199,7 @@
 - [HIR Type checking](./hir-typeck/summary.md)
     - [Coercions](./hir-typeck/coercions.md)
     - [Method lookup](./hir-typeck/method-lookup.md)
-- [Const Generics](./const-generics.md)
+- [Const generics](./const-generics.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)
@@ -239,18 +239,18 @@
     - [Debugging LLVM](./backend/debugging.md)
     - [Backend Agnostic Codegen](./backend/backend-agnostic.md)
     - [Implicit caller location](./backend/implicit-caller-location.md)
-- [Debug Info](./debuginfo/intro.md)
-    - [Rust Codegen](./debuginfo/rust-codegen.md)
-    - [LLVM Codegen](./debuginfo/llvm-codegen.md)
-    - [Debugger Internals](./debuginfo/debugger-internals.md)
-        - [LLDB Internals](./debuginfo/lldb-internals.md)
-        - [GDB Internals](./debuginfo/gdb-internals.md)
-    - [Debugger Visualizers](./debuginfo/debugger-visualizers.md)
+- [Debug info](./debuginfo/intro.md)
+    - [Rust codegen](./debuginfo/rust-codegen.md)
+    - [LLVM codegen](./debuginfo/llvm-codegen.md)
+    - [Debugger internals](./debuginfo/debugger-internals.md)
+        - [LLDB internals](./debuginfo/lldb-internals.md)
+        - [GDB internals](./debuginfo/gdb-internals.md)
+    - [Debugger visualizers](./debuginfo/debugger-visualizers.md)
         - [LLDB - Python Providers](./debuginfo/lldb-visualizers.md)
         - [GDB - Python Providers](./debuginfo/gdb-visualizers.md)
         - [CDB - Natvis](./debuginfo/natvis-visualizers.md)
     - [Testing](./debuginfo/testing.md)
-    - [(Lecture Notes) Debugging support in the Rust compiler](./debugging-support-in-rustc.md)
+    - [(Lecture notes) Debugging support in the Rust compiler](./debugging-support-in-rustc.md)
 - [Libraries and metadata](./backend/libs-and-metadata.md)
 - [Profile-guided optimization](./profile-guided-optimization.md)
 - [LLVM source-based code coverage](./llvm-coverage-instrumentation.md)
 
@@ -1,5 +1,7 @@
 # About this guide
 
+<!-- date-check: Jul 2026 -->
+
 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.
 
@@ -14,18 +16,18 @@ There are several parts to this guide:
 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]:
+1. [High-level compiler architecture][p4]:
    Discusses the high-level architecture of the compiler and stages of the compile process.
-1. [Source Code Representation][p5]:
+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.
-1. [Supporting Infrastructure][p6]:
+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).
-1. [MIR to Binaries][p8]: How linked executable machine code is generated.
+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.
 
 
@@ -20,7 +20,7 @@ rustup +nightly component add enzyme
 
 Older rustup versions are not aware of this component, so if you run into issues try updating rustup itself:
 ```console
-rustup update
+rustup self update
 rustup +nightly component add enzyme
 ```
 
 
@@ -1,4 +1,4 @@
-# Const Generics
+# Const generics
 
 ## Kinds of const arguments
 
@@ -15,9 +15,9 @@ Inference Variables are quite boring and treated equivalently to type inference
 Const Parameters are also similarly boring and equivalent to uses of type parameters almost everywhere.
 However, there are some interesting subtleties with how they are handled during parsing, name resolution, and AST lowering: [ambig-unambig-ty-and-consts].
 
-## Anon Consts
+## Anon consts
 
-Anon Consts (short for anonymous const items) are how arbitrary expression are represented in const generics, for example an array length of `1 + 1` or `foo()` or even just `0`.
+Anon consts (short for anonymous const items) are how arbitrary expression are represented in const generics, for example an array length of `1 + 1` or `foo()` or even just `0`.
 These are unique to const generics and have no real type equivalent.
 
 ### Desugaring
@@ -85,7 +85,7 @@ After all of this desugaring has taken place the final representation in the typ
 
 This allows the representation for const "aliases" to be the same as the representation of `TyKind::Alias`. Having a proper HIR body also allows for a *lot* of code re-use, e.g. we can reuse HIR typechecking and all of the lowering steps to MIR where we can then reuse const eval.
 
-### Enforcing lack of Generic Parameters
+### Enforcing lack of generic parameters
 
 There are three ways that we enforce anon consts can't use generic parameters:
 1. Name Resolution will not resolve paths to generic parameters when inside of an anon const
@@ -134,7 +134,9 @@ fn foo<T: Sized>() {
 }
 ```
 
-However, to avoid most of the problems involved in allowing generic parameters in anon const const arguments we require that the constant be evaluated before monomorphization (e.g. during type checking). In some sense we only allow generic parameters here when they are semantically unused.
+However, to avoid most of the problems involved in allowing generic parameters in anon const const arguments,
+we require that the constant be evaluated before monomorphization (e.g. during type checking).
+In some sense we only allow generic parameters here when they are semantically unused.
 
 In the previous example the anon const can be evaluated for any type parameter `T` because raw pointers to sized types always have the same size (e.g. `8` on 64bit platforms).
 
@@ -182,7 +184,7 @@ It is currently unclear what the right way to make `generic_const_parameter_type
 
 `min_generic_const_args` will allow for some expressions (for example array construction) to be representable without an anon const and therefore without running into these issues, though whether this is *enough* has yet to be determined.
 
-## Checking types of Const Arguments
+## Checking types of const arguments
 
 In order for a const argument to be well formed it must have the same type as the const parameter it is an argument to.
 For example, a const argument of type `bool` for an array length is not well formed, as an array's length parameter has type `usize`.
 
@@ -1,14 +1,16 @@
-# Debugger Internals
+# Debugger internals
 
-It is the debugger's job to convert the debug info into an in-memory representation. Both the
-interpretation of the debug info and the in-memory representation are arbitrary; anything will do
-so long as meaningful information can be reconstructed while the program is running. The pipeline
-from raw debug info to usable types can be quite complicated.
+It is the debugger's job to convert the debug info into an in-memory representation.
+Both the interpretation of the debug info and the in-memory representation are arbitrary;
+anything will do,
+so long as meaningful information can be reconstructed while the program is running.
+The pipeline from raw debug info to usable types can be quite complicated.
 
 Once the information is in a workable format, the debugger front-end then must provide a way to
 interpret and display the data, a way for users to interact with it, and an API for extensibility.
 
-Debuggers are vast systems and cannot be covered completely here. This section will provide a brief
-overview of the subsystems directly relevant to the Rust debugging experience.
+Debuggers are vast systems and cannot be covered completely here.
+This section will provide a brief overview of the subsystems
+directly relevant to the Rust debugging experience.
 
-Microsoft's debugging engine is closed source, so it will not be covered here.
+Microsoft's debugging engine is closed source, so it will not be covered here.
Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-7fb284d9037fa54f6a9b24261c82b394472cbfd7`
	`1`	`+390279b302ca98ae270f434100ae3730531d1246`