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
  9. Testing the compiler
    ❱
    1. Running tests
      ❱
      1. Testing with Docker
      2. Testing with CI
    3. Adding new tests
    4. Best practices
    5. Compiletest
      ❱
      1. UI tests
      2. Test directives
      3. Minicore
    7. Ecosystem testing
      ❱
      1. Crater
      2. Fuchsia
      3. Rust for Linux
    9. Codegen backend testing
      ❱
      1. Cranelift codegen backend
      2. GCC codegen backend
    11. Performance testing
    12. Suggest tests tool
    13. Misc info
  11. Debugging the compiler
    ❱
    1. Using the tracing/logging instrumentation
  13. Profiling the compiler
    ❱
    1. with the linux perf tool
    2. with Windows Performance Analyzer
    3. with the Rust benchmark suite
  15. crates.io dependencies
  17. Contributing to Rust
  18. Contribution procedures
  19. About the compiler team
  20. Using Git
  21. Mastering @rustbot
  22. Walkthrough: a typical contribution
  23. Implementing new language features
  24. Stability attributes
  25. Stabilizing Features
  26. Feature Gates
  27. Coding conventions
  28. Procedures for breaking changes
  29. Using external repositories
  30. Fuzzing
  31. Notification groups
    ❱
    1. Apple
    2. ARM
    3. Emscripten
    4. Fuchsia
    5. RISC-V
    6. Rust for Linux
    7. WASI
    8. WebAssembly
    9. Windows
  33. Licenses
  34. Editions
  36. Bootstrapping
  37. Prologue
  38. What Bootstrapping does
  39. How Bootstrap does it
  40. Writing tools in Bootstrap
  41. Debugging bootstrap
  42. cfg(bootstrap) in dependencies
  44. High-level Compiler Architecture
  45. Prologue
  46. Overview of the compiler
  47. The compiler source code
  48. 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
  50. Memory management in rustc
  51. Serialization in rustc
  52. Parallel compilation
  53. Rustdoc internals
    ❱
    1. Search
    2. The rustdoc test suite
    3. The rustdoc-gui test suite
    4. The rustdoc-json test suite
  55. GPU offload internals
    ❱
    1. Installation
  57. Autodiff internals
    ❱
    1. Installation
    2. How to debug
    3. Autodiff flags
    4. Current limitations
  60. Source Code Representation
  61. Prologue
  62. 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
  64. The HIR (High-level IR)
    ❱
    1. Lowering AST to HIR
    2. Ambig/Unambig Types and Consts
    3. Debugging
  66. The THIR (Typed High-level IR)
  67. The MIR (Mid-level IR)
    ❱
    1. MIR construction
    2. MIR visitor and traversal
    3. MIR queries and passes: getting the MIR
  69. Inline assembly
  71. Supporting Infrastructure
  72. Command-line arguments
  73. rustc_driver and rustc_interface
    ❱
    1. Remarks on perma-unstable features
    2. Example: Type checking
    3. Example: Getting diagnostics
  75. Errors and lints
    ❱
    1. Diagnostic and subdiagnostic structs
    2. Translation
    3. LintStore
    4. Error codes
    5. Diagnostic items
    6. ErrorGuaranteed
  78. Analysis
  79. Prologue
  80. Generic parameter definitions
    ❱
    1. EarlyBinder and instantiating parameters
  82. Binders and Higher ranked regions
    ❱
    1. Instantiating binders
  84. Early vs Late bound parameters
  85. The ty module: representing types
    ❱
    1. ADTs and Generic Arguments
    2. Parameter types/consts/regions
  87. TypeFolder and TypeFoldable
  88. Aliases and Normalization
  89. Typing/Param Envs
  90. Type inference
  91. 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
    7. Next-gen trait solving
      ❱
      1. Invariants of the type system
      2. The solver
      3. Canonicalization
      4. Coinduction
      5. Caching
      6. Proof trees
      7. Opaque types
      8. Significant changes and quirks
    9. Unsize and CoerceUnsized traits
  93. Type checking
    ❱
    1. Method lookup
    2. Variance
    3. Coherence checking
    4. Opaque types
      ❱
      1. Inference details
      2. Return Position Impl Trait In Trait
      3. Region inference restrictions
  95. Const condition checking
  96. Pattern and exhaustiveness checking
  97. Unsafety checking
  98. MIR dataflow
  99. Drop elaboration
  100. The borrow checker
    ❱
    1. Tracking moves and initialization
      ❱
      1. Move paths
    3. MIR type checker
    4. Drop check
    5. Region inference
      ❱
      1. Constraint propagation
      2. Lifetime parameters
      3. Member constraints
      4. Placeholders and universes
      5. Closure constraints
      6. Error reporting
    7. Two-phase-borrows
  102. Closure capture inference
  103. Async closures/"coroutine-closures"
  105. MIR to binaries
  106. Prologue
  107. MIR optimizations
  108. Debugging MIR
  109. Constant evaluation
    ❱
    1. Interpreter
  111. Monomorphization
  112. Lowering MIR
  113. Code generation
    ❱
    1. Updating LLVM
    2. Debugging LLVM
    3. Backend Agnostic Codegen
    4. Implicit caller location
  115. Libraries and metadata
  116. Profile-guided optimization
  117. LLVM source-based code coverage
  118. Sanitizers support
  119. Debugging support in the Rust compiler
  122. Appendix A: Background topics
  123. Appendix B: Glossary
  124. Appendix C: Code Index
  125. Appendix D: Compiler Lecture Series
  126. Appendix E: Bibliography
  127. Appendix Z: HumorRust