1. Getting Started
  2. About this guide
  6. Building and debugging rustc
  7. How to build and run the compiler
    ❱
    1. Quickstart
    2. Prerequisites
    3. Suggested workflows
    4. Distribution artifacts
    5. Building documentation
    6. Rustdoc overview
    7. Adding a new target
    8. Optimized build
  8. Testing the compiler
    ❱
    1. Running tests
      ❱
      1. Testing with Docker
      2. Testing with CI
    2. Adding new tests
    3. Best practices
    4. Compiletest
      ❱
      1. UI tests
      2. Test directives
      3. Minicore
    5. Ecosystem testing
      ❱
      1. Crater
      2. Fuchsia
      3. Rust for Linux
    6. Codegen backend testing
      ❱
      1. Cranelift codegen backend (stub)
      2. GCC codegen backend
    7. Performance testing
    8. Autodiff CI job
    9. Pre-stabilization CI job for the next solver and polonius alpha
    10. Parallel frontend CI job
    11. Standard library semver breakage test
    12. Misc info
  9. Debugging the compiler
    ❱
    1. Using the tracing/logging instrumentation
  10. Profiling the compiler
    ❱
    1. with the linux perf tool
    2. with Windows Performance Analyzer
    3. with the Rust benchmark suite
  11. crates.io dependencies
  13. Contributing to Rust
  14. Contribution procedures
  15. Writing rustc-dev-guide documentation
  16. About the compiler team
  17. Using Git
  18. Mastering @rustbot
  19. Running LLMs
    ❱
    1. Writing code with LLMs
    2. Reviewing code with LLMs
  20. Walkthrough: a typical contribution
  21. Implementing new language features
  22. Stability guarantees
  23. Stability attributes
  24. Stabilizing language features
    ❱
    1. Stabilization report template
  25. Feature Gates
  26. Coding conventions
  27. Procedures for breaking changes
  28. Using external repositories
  29. Fuzzing
  30. Notification groups
    ❱
    1. Apple
    2. ARM
    3. Emscripten
    4. Fuchsia
    5. LoongArch
    6. RISC-V
    7. Rust for Linux
    8. WASI
    9. WebAssembly
    10. Windows
    11. GPU target
  31. Licenses
  32. Editions
  34. Bootstrapping
  35. Prologue
  36. What Bootstrapping does
  37. How Bootstrap does it
  38. Writing tools in Bootstrap
  39. Debugging bootstrap
  40. cfg(bootstrap) in dependencies
  42. High-level compiler architecture
  43. Prologue
  44. Overview of the compiler
  45. The compiler source code
  46. Queries: demand-driven compilation
    ❱
    1. The Query Evaluation Model in detail
    2. Incremental compilation
    3. Incremental compilation in detail
    4. Debugging and testing
    5. Salsa
  47. Memory management in rustc
  48. Serialization in rustc
  49. Parallel compilation
  50. Rustdoc internals
    ❱
    1. Search
    2. The rustdoc-html test suite
    3. The rustdoc-gui test suite (stub)
    4. The rustdoc-json test suite
  51. GPU offload internals
    ❱
    1. Installation
    2. Usage
    3. Contributing
  52. Autodiff internals
    ❱
    1. Installation
    2. How to debug
    3. Autodiff flags
    4. Type Trees
  54. Source code representation
  55. Prologue
  56. Syntax and the AST
    ❱
    1. Lexing and parsing
    2. Macro expansion
    3. Name resolution
    4. Attributes
    5. #[test] implementation
    6. Panic implementation
    7. AST validation
    8. Feature gate checking
    9. Lang Items
  57. The HIR (High-level IR)
    ❱
    1. Lowering AST to HIR
    2. Attribute Parsing
    3. Debugging
  58. Ambig/Unambig Types and Consts
  59. The THIR (Typed High-level IR)
  60. The MIR (Mid-level IR)
    ❱
    1. MIR construction
    2. MIR visitor and traversal
    3. MIR queries and passes: getting the MIR
  61. Inline assembly
  63. Supporting infrastructure
  64. Command-line arguments
  65. rustc_driver and rustc_interface
    ❱
    1. External rustc_drivers
    2. Example: Type checking
    3. Example: Getting diagnostics
  66. Errors and lints
    ❱
    1. Diagnostic and subdiagnostic structs
    2. Translation
    3. LintStore
    4. Error codes
    5. Diagnostic items
    6. ErrorGuaranteed
  68. Analysis
  69. Prologue
  70. Generic parameter definitions
    ❱
    1. EarlyBinder and instantiating parameters
  71. Binders and Higher ranked regions
    ❱
    1. Instantiating binders
  72. Early vs Late bound parameters
  73. The ty module: representing types
    ❱
    1. ADTs and Generic Arguments
    2. Parameter types/consts/regions
  74. TypeFolder and TypeFoldable
  75. Aliases and normalization
  76. Typing/Param envs
  77. Type inference
  78. Trait solving
    ❱
    1. Higher-ranked trait bounds
    2. Caching subtleties
    3. Implied bounds
    4. Specialization
    5. Chalk-based trait solving
      ❱
      1. Lowering to logic
      2. Goals and clauses
      3. Canonical queries
      4. Canonicalization
    6. Next-gen trait solving
      ❱
      1. Invariants of the type system
      2. The solver
      3. Candidate preference
      4. Canonicalization
      5. Coinduction
      6. Caching
      7. Proof trees
      8. Opaque types
      9. Significant changes and quirks
      10. Sharing the trait solver with rust-analyzer
    7. Unsize and CoerceUnsized traits
    8. Having separate Trait and Projection bounds
  79. Well-formedness
  80. Variance
  81. Coherence checking
  82. HIR Type checking
    ❱
    1. Coercions
    2. Method lookup
  83. Const generics
  84. Opaque types
    ❱
    1. Inference details
    2. Return Position Impl Trait In Trait
    3. Region inference restrictions
  85. Const traits and const condition checking
  86. Pattern and exhaustiveness checking
  87. Unsafety checking
  88. MIR dataflow
  89. Drop elaboration
  90. The borrow checker
    ❱
    1. Tracking moves and initialization
      ❱
      1. Move paths
    2. MIR type checker
    3. Drop check
    4. Region inference
      ❱
      1. Constraint propagation
      2. Lifetime parameters
      3. Member constraints
      4. Placeholders and universes
      5. Closure constraints
      6. Error reporting (stub)
    5. Two-phase-borrows
    6. Debugging the borrow checker
  91. Closure capture inference
  92. Async closures/"coroutine-closures"
  94. MIR to binaries
  95. Prologue
  96. MIR optimizations
  97. Debugging MIR
  98. Constant evaluation
    ❱
    1. Interpreter
  99. Monomorphization
  100. Lowering MIR
  101. Code generation
    ❱
    1. Updating LLVM
    2. Debugging LLVM
    3. Backend Agnostic Codegen
    4. Implicit caller location
  102. Debug info
    ❱
    1. Rust codegen
    2. LLVM codegen
    3. Debugger internals
      ❱
      1. LLDB internals
      2. GDB internals (stub)
    4. Debugger visualizers
      ❱
      1. LLDB - Python Providers
      2. GDB - Python Providers
      3. CDB - Natvis (stub)
    5. Testing (stub)
    6. (Lecture notes) Debugging support in the Rust compiler
  103. Libraries and metadata
  104. Profile-guided optimization
  105. LLVM source-based code coverage
  106. Sanitizers support
  109. Appendix A: Background topics
  110. Appendix B: Glossary
  111. Appendix C: Code Index
  112. Appendix D: Compiler Lecture Series
  113. Appendix E: Bibliography
  114. Appendix F: Reading club sessions
  115. Appendix Z: HumorRust