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
      2. GCC codegen backend
    7. Performance testing
    8. 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. About the compiler team
  16. Using Git
  17. Mastering @rustbot
  18. Walkthrough: a typical contribution
  19. Implementing new language features
  20. Stability guarantees
  21. Stability attributes
  22. Stabilizing language features
    ❱
    1. Stabilization report template
  23. Feature Gates
  24. Coding conventions
  25. Procedures for breaking changes
  26. Using external repositories
  27. Fuzzing
  28. Notification groups
    ❱
    1. Apple
    2. ARM
    3. Emscripten
    4. Fuchsia
    5. RISC-V
    6. Rust for Linux
    7. WASI
    8. WebAssembly
    9. Windows
  29. Licenses
  30. Editions
  32. Bootstrapping
  33. Prologue
  34. What Bootstrapping does
  35. How Bootstrap does it
  36. Writing tools in Bootstrap
  37. Debugging bootstrap
  38. cfg(bootstrap) in dependencies
  40. High-level Compiler Architecture
  41. Prologue
  42. Overview of the compiler
  43. The compiler source code
  44. 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
  45. Memory management in rustc
  46. Serialization in rustc
  47. Parallel compilation
  48. Rustdoc internals
    ❱
    1. Search
    2. The rustdoc test suite
    3. The rustdoc-gui test suite
    4. The rustdoc-json test suite
  49. GPU offload internals
    ❱
    1. Installation
    2. Usage
  50. Autodiff internals
    ❱
    1. Installation
    2. How to debug
    3. Autodiff flags
    4. Type Trees
  52. Source Code Representation
  53. Prologue
  54. 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
  55. The HIR (High-level IR)
    ❱
    1. Lowering AST to HIR
    2. Debugging
  56. Ambig/Unambig Types and Consts
  57. The THIR (Typed High-level IR)
  58. The MIR (Mid-level IR)
    ❱
    1. MIR construction
    2. MIR visitor and traversal
    3. MIR queries and passes: getting the MIR
  59. Inline assembly
  61. Supporting Infrastructure
  62. Command-line arguments
  63. rustc_driver and rustc_interface
    ❱
    1. Remarks on perma-unstable features
    2. Example: Type checking
    3. Example: Getting diagnostics
  64. Errors and lints
    ❱
    1. Diagnostic and subdiagnostic structs
    2. Translation
    3. LintStore
    4. Error codes
    5. Diagnostic items
    6. ErrorGuaranteed
  66. Analysis
  67. Prologue
  68. Generic parameter definitions
    ❱
    1. EarlyBinder and instantiating parameters
  69. Binders and Higher ranked regions
    ❱
    1. Instantiating binders
  70. Early vs Late bound parameters
  71. The ty module: representing types
    ❱
    1. ADTs and Generic Arguments
    2. Parameter types/consts/regions
  72. TypeFolder and TypeFoldable
  73. Aliases and Normalization
  74. Typing/Param Envs
  75. Type inference
  76. 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
  77. Variance
  78. Coherence checking
  79. HIR Type checking
    ❱
    1. Coercions
    2. Method lookup
  80. Const Generics
  81. Opaque types
    ❱
    1. Inference details
    2. Return Position Impl Trait In Trait
    3. Region inference restrictions
  82. Const condition checking
  83. Pattern and exhaustiveness checking
  84. Unsafety checking
  85. MIR dataflow
  86. Drop elaboration
  87. 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
    5. Two-phase-borrows
  88. Closure capture inference
  89. Async closures/"coroutine-closures"
  91. MIR to binaries
  92. Prologue
  93. MIR optimizations
  94. Debugging MIR
  95. Constant evaluation
    ❱
    1. Interpreter
  96. Monomorphization
  97. Lowering MIR
  98. Code generation
    ❱
    1. Updating LLVM
    2. Debugging LLVM
    3. Backend Agnostic Codegen
    4. Implicit caller location
  99. Libraries and metadata
  100. Profile-guided optimization
  101. LLVM source-based code coverage
  102. Sanitizers support
  103. Debugging support in the Rust compiler
  106. Appendix A: Background topics
  107. Appendix B: Glossary
  108. Appendix C: Code Index
  109. Appendix D: Compiler Lecture Series
  110. Appendix E: Bibliography
  111. Appendix Z: HumorRust