`ty::Ty`, Parallelism, Bootstrapping, and References in the Rust Compiler

(Note that the name is mostly historic. This is _not_ a "typing context" in the sense of `Γ` or `Δ` from type theory. The name is retained because that's what the name of the struct is in the source code.) All queries are defined as methods on the [`TyCtxt`] type, and the in-memory query cache is stored there too. In the code, there is usually a variable called `tcx` which is a handle on the typing context. You will also see lifetimes with the name `'tcx`, which means that something is tied to the lifetime of the [`TyCtxt`] (usually it is stored or interned there). ### `ty::Ty` Types are really important in Rust, and they form the core of a lot of compiler analyses. The main type (in the compiler) that represents types (in the user's program) is [`rustc_middle::ty::Ty`][ty]. This is so important that we have a whole chapter on [`ty::Ty`][ty], but for now, we just want to mention that it exists and is the way `rustc` represents types! Also note that the [`rustc_middle::ty`] module defines the [`TyCtxt`] struct we mentioned before. ### Parallelism Compiler performance is a problem that we would like to improve on (and are always working on). One aspect of that is parallelizing `rustc` itself. Currently, there is only one part of rustc that is parallel by default: [code generation](./parallel-rustc.md#Codegen). However, the rest of the compiler is still not yet parallel. There have been lots of efforts spent on this, but it is generally a hard problem. The current approach is to turn [`RefCell`]s into [`Mutex`]s -- that is, we switch to thread-safe internal mutability. However, there are ongoing challenges with lock contention, maintaining query-system invariants under concurrency, and the complexity of the code base. One can try out the current work by enabling parallel compilation in `bootstrap.toml`. It's still early days, but there are already some promising performance improvements. ### Bootstrapping `rustc` itself is written in Rust. So how do we compile the compiler? We use an older compiler to compile the newer compiler. This is called [_bootstrapping_]. Bootstrapping has a lot of interesting implications. For example, it means that one of the major users of Rust is the Rust compiler, so we are constantly testing our own software ("eating our own dogfood"). For more details on bootstrapping, see [the bootstrapping section of the guide][rustc-bootstrap].  # References - Command line parsing - Guide: [The Rustc Driver and Interface](rustc-driver/intro.md) - Driver definition: [`rustc_driver`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_driver/) - Main entry point: [`rustc_session::config::build_session_options`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_session/config/fn.build_session_options.html) - Lexical Analysis: Lex the user program to a stream of tokens - Guide: [Lexing and Parsing](the-parser.md) - Lexer definition: [`rustc_lexer`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lexer/index.html) - Main entry point: [`rustc_lexer::cursor::Cursor::advance_token`](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lexer/cursor/struct.Cursor.html#method.advance_token) - Parsing: Parse the stream of tokens to an Abstract Syntax Tree (AST) - Guide: [Lexing and Parsing](the-parser.md) - Guide: [Macro Expansion](macro-expansion.md)

This section elaborates on `ty::Ty` as the main type representing types in the Rust compiler, and mentions that the `rustc_middle::ty` module defines the `TyCtxt` struct. It also covers the topic of parallelism in `rustc`, noting that code generation is currently the only part that is parallel by default, and discusses ongoing efforts to parallelize other parts of the compiler. Bootstrapping, the process of compiling `rustc` with an older version of itself, is explained. Finally, a reference section lists important modules related to compiler phases like command-line parsing, lexical analysis, and parsing.