part 2, 3, 4 intros

Author: mark-i-m

src/part-2-intro.md

@@ -1,12 +1,15 @@
 # Part 2: How rustc works
 
-This part of the guide describes how the compiler works. It goes through
-everything from high-level structure of the compiler to how each stage of
-compilation works.
+The remaining parts of this guide discuss how the compiler works. They go
+through everything from high-level structure of the compiler to how each stage
+of compilation works. They should be friendly to both readers interested in the
+end-to-end process of compilation _and_ readers interested in learning about a
+specific system they wish to contribute to. If anything is unclear, feel free
+to file an issue on the [rustc-dev-guide
+repo](https://github.com/rust-lang/rustc-dev-guide) or contact the compiler
+team, as detailed in [this chapter from Part 1](./compiler-team.md).
 
-This section should be friendly to both readers interested in the end-to-end
-process of compilation _and_ readers interested in learning about a specific
-system they wish to contribute to. If anything is unclear, feel free to file
-an issue on the [rustc-dev-guide repo](https://github.com/rust-lang/rustc-dev-guide)
-or contact the compiler team, as detailed in [this chapter from Part
-1](./compiler-team.md).
+In this part, we will specifically look at the high-level architecture of the
+compiler. Specifically, will look at the query system, incremental compilation,
+and interning. These are three overarching design choices that impact the whole
+compiler.

src/part-3-intro.md

@@ -0,0 +1,7 @@
+# Part 3: The Compiler Frontend
+
+This part of the guide looks at the compiler frontend (with the major exception
+of the type system, which is in the next part). This part describes the process
+of taking raw source code from the user and transforming it into various forms
+that the compiler can work with easily. These are called intermediate
+representations.

src/part-4-intro.md

@@ -0,0 +1,11 @@
+# Part 4: The Type System
+
+This part discusses the many analyses that the compiler uses to check various
+properties of the code and to inform later stages. This includes the
+representation, inference, and checking of types, the trait system, and the
+borrow checker. These analyses do not happen as one big pass or set of
+contiguous passes. Rather, they are spread out throughout various parts of the
+compilation process and use different intermediate representations. For example,
+type checking happens on the HIR, while borrow checking happens on the MIR.
+Nonetheless, for the sake of presentation, we will discuss all of these
+analyses in this part of the guide.