sembr src/mir/construction.md

Author: tshepang

src/mir/construction.md

@@ -11,13 +11,15 @@ list of items:
     * Drop code (the `Drop::drop` function is not called directly)
     * Drop implementations of types without an explicit `Drop` implementation
 
-The lowering is triggered by calling the [`mir_built`] query. The MIR builder does
+The lowering is triggered by calling the [`mir_built`] query.
+The MIR builder does
 not actually use the HIR but operates on the [THIR] instead, processing THIR
 expressions recursively.
 
 The lowering creates local variables for every argument as specified in the signature.
 Next, it creates local variables for every binding specified (e.g. `(a, b): (i32, String)`)
-produces 3 bindings, one for the argument, and two for the bindings. Next, it generates
+produces 3 bindings, one for the argument, and two for the bindings.
+Next, it generates
 field accesses that read the fields from the argument and writes the value to the binding
 variable.
 
@@ -52,7 +54,8 @@ fn generate_more_mir(&mut self, block: BasicBlock) -> BlockAnd<ResultType> {
 ```
 
 When you invoke these functions, it is common to have a local variable `block`
-that is effectively a "cursor". It represents the point at which we are adding new MIR.
+that is effectively a "cursor".
+It represents the point at which we are adding new MIR.
 When you invoke `generate_more_mir`, you want to update this cursor.
 You can do this manually, but it's tedious:
 
@@ -89,18 +92,22 @@ representations:
 
 We start out with lowering the function body to an `Rvalue` so we can create an
 assignment to `RETURN_PLACE`, This `Rvalue` lowering will in turn trigger lowering to
-`Operand` for its arguments (if any). `Operand` lowering either produces a `const`
-operand, or moves/copies out of a `Place`, thus triggering a `Place` lowering. An
+`Operand` for its arguments (if any).
+`Operand` lowering either produces a `const`
+operand, or moves/copies out of a `Place`, thus triggering a `Place` lowering.
+An
 expression being lowered to a `Place` can in turn trigger a temporary to be created
-if the expression being lowered contains operations. This is where the snake bites its
+if the expression being lowered contains operations.
+This is where the snake bites its
 own tail and we need to trigger an `Rvalue` lowering for the expression to be written
 into the local.
 
 ## Operator lowering
 
 Operators on builtin types are not lowered to function calls (which would end up being
 infinite recursion calls, because the trait impls just contain the operation itself
-again). Instead there are `Rvalue`s for binary and unary operators and index operations.
+again).
+Instead there are `Rvalue`s for binary and unary operators and index operations.
 These `Rvalue`s later get codegened to llvm primitive operations or llvm intrinsics.
 
 Operators on all other types get lowered to a function call to their `impl` of the
@@ -118,7 +125,8 @@ In [MIR] there is no difference between method calls and function calls anymore.
 ## Conditions
 
 `if` conditions and `match` statements for `enum`s with variants that have no fields are
-lowered to `TerminatorKind::SwitchInt`. Each possible value (so `0` and `1` for `if`
+lowered to `TerminatorKind::SwitchInt`.
+Each possible value (so `0` and `1` for `if`
 conditions) has a corresponding `BasicBlock` to which the code continues.
 The argument being branched on is (again) an `Operand` representing the value of
 the if condition.
@@ -127,14 +135,14 @@ the if condition.
 
 `match` statements for `enum`s with variants that have fields are lowered to
 `TerminatorKind::SwitchInt`, too, but the `Operand` refers to a `Place` where the
-discriminant of the value can be found. This often involves reading the discriminant
-to a new temporary variable.
+discriminant of the value can be found.
+This often involves reading the discriminant to a new temporary variable.
 
 ## Aggregate construction
 
 Aggregate values of any kind (e.g. structs or tuples) are built via `Rvalue::Aggregate`.
-All fields are
-lowered to `Operator`s. This is essentially equivalent to one assignment
+All fields are lowered to `Operator`s.
+This is essentially equivalent to one assignment
 statement per aggregate field plus an assignment to the discriminant in the
 case of `enum`s.