update part intros

Author: mark-i-m

src/part-3-intro.md

@@ -1,7 +1,9 @@
-# Part 3: The Compiler Frontend
+# Part 3: Source Code Representations
 
-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.
+This part of the guide looks at the various ways the compiler transforms and
+represents source code. 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.
+
+This process starts with compiler understanding what the user has asked for:
+parsing the command line arguments given and determining what it is to compile.

src/part-4-intro.md

@@ -1,7 +1,8 @@
-# Part 4: The Type System
+# Part 4: Analysis
 
 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
+properties of the code and to inform later stages. Typically, this is what people
+mean when they talk about "Rust's type system". 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

src/part-5-intro.md

@@ -1,4 +1,4 @@
-# The Compiler Backend
+# From MIR to binaries
 
 All of the preceding chapters of this guide have one thing in common: we never
 generated any executable machine code at all! With this chapter, all of that
@@ -7,13 +7,14 @@ changes.
 It's often useful to think of compilers as being composed of a _frontend_ and a
 _backend_  (though in rustc, there's not a sharp line between frontend and
 backend). The _frontend_ is responsible for taking raw source code, checking it
-for correctness, and getting it into a format usable by the backend. For rustc,
-this format is the MIR.  The _backend_ refers to the parts of the compiler that
-turn rustc's MIR into actual executable code (e.g. an ELF or EXE binary) that
-can run on a processor.  All of the previous chapters deal with rustc's
-frontend.
-
-rustc's backend does the following:
+for correctness, and getting it into a format from which we can generate code.
+For rustc, we typically consider MIR to be this format (though arguably, one
+could consider LLVM IR to be this format). The _backend_ refers to the parts
+of the compiler that produce actual executable code (e.g. an ELF or EXE binary)
+that can run on a processor. All of the previous chapters deal with rustc's
+"frontend".
+
+rustc's "backend" does the following:
 
 0. First, we need to collect the set of things to generate code for. In
    particular, we need to find out which concrete types to substitute for