Adjust rules next to headers

Author: ehuss

src/expressions.md

@@ -1,6 +1,5 @@
-# Expressions
-
 r[expr]
+# Expressions
 
 r[expr.syntax]
 > **<sup>Syntax</sup>**\
@@ -68,9 +67,8 @@ Blocks are just another kind of expression, so blocks, statements, expressions,
 
 > **Note**: We give names to the operands of expressions so that we may discuss them, but these names are not stable and may be changed.
 
-## Expression precedence
-
 r[expr.precedence]
+## Expression precedence
 
 The precedence of Rust operators and expressions is ordered as follows, going from strong to weak.
 Binary Operators at the same precedence level are grouped in the order given by their associativity.
@@ -97,9 +95,8 @@ Binary Operators at the same precedence level are grouped in the order given by
 | `=` `+=` `-=` `*=` `/=` `%=` <br> `&=` <code>&#124;=</code> `^=` `<<=` `>>=` | right to left |
 | `return` `break` closures   |                     |
 
-## Evaluation order of operands
-
 r[expr.operand-order]
+## Evaluation order of operands
 
 r[expr.operand-order.default]
 The following list of expressions all evaluate their operands the same way, as described after the list.
@@ -147,9 +144,8 @@ assert_eq!(
 
 > **Note**: Since this is applied recursively, these expressions are also evaluated from innermost to outermost, ignoring siblings until there are no inner subexpressions.
 
-## Place Expressions and Value Expressions
-
 r[expr.place-value]
+## Place Expressions and Value Expressions
 
 r[expr.place-value.intro]
 Expressions are divided into two main categories: place expressions and value expressions;
@@ -200,9 +196,8 @@ Explicitly, the assignee expressions are:
 r[expr.place-value.parenthesis]
 Arbitrary parenthesisation is permitted inside assignee expressions.
 
-### Moved and copied types
-
 r[expr.move]
+### Moved and copied types
 
 r[expr.move.intro]
 When a place expression is evaluated in a value expression context, or is bound by value in a pattern, it denotes the value held _in_ that memory location.
@@ -227,9 +222,8 @@ After moving out of a place expression that evaluates to a local variable, the l
 r[expr.move.place-invalid]
 In all other cases, trying to use a place expression in a value expression context is an error.
 
-### Mutability
-
 r[expr.mut]
+### Mutability
 
 r[expr.mut.intro]
 For a place expression to be [assigned][assign] to, mutably [borrowed][borrow], [implicitly mutably borrowed], or bound to a pattern containing `ref mut`, it must be _mutable_.
@@ -251,17 +245,15 @@ The following expressions can be mutable place expression contexts:
 * [Array indexing] of a type that implements `IndexMut`:
   this then evaluates the value being indexed, but not the index, in mutable place expression context.
 
-### Temporaries
-
 r[expr.temporary]
+### Temporaries
 
 When using a value expression in most place expression contexts, a temporary unnamed memory location is created and initialized to that value.
 The expression evaluates to that location instead, except if [promoted] to a `static`.
 The [drop scope] of the temporary is usually the end of the enclosing statement.
 
-### Implicit Borrows
-
 r[expr.implicit-borrow]
+### Implicit Borrows
 
 r[expr.implicit-borrow-intro]
 Certain expressions will treat an expression as a place expression by implicitly borrowing it.
@@ -291,16 +283,14 @@ Implicit borrows may be taken in the following expressions:
 * Operands of [comparison].
 * Left operands of the [compound assignment].
 
-## Overloading Traits
-
 r[expr.overload]
+## Overloading Traits
 
 Many of the following operators and expressions can also be overloaded for other types using traits in `std::ops` or `std::cmp`.
 These traits also exist in `core::ops` and `core::cmp` with the same names.
 
-## Expression Attributes
-
 r[expr.attr]
+## Expression Attributes
 
 r[expr.attr.restriction]
 [Outer attributes][_OuterAttribute_] before an expression are allowed only in a few specific cases:

src/expressions/array-expr.md

@@ -1,6 +1,5 @@
-# Array and array index expressions
-
 r[expr.array]
+# Array and array index expressions
 
 ## Array expressions
 
@@ -64,9 +63,8 @@ const EMPTY: Vec<i32> = Vec::new();
 [EMPTY; 2];
 ```
 
-## Array and slice indexing expressions
-
 r[expr.array.index]
+## Array and slice indexing expressions
 
 > **<sup>Syntax</sup>**\
 > _IndexExpression_ :\

src/expressions/await-expr.md

@@ -1,6 +1,5 @@
-# Await expressions
-
 r[expr.await]
+# Await expressions
 
 r[expr.await.syntax]
 > **<sup>Syntax</sup>**\
@@ -30,16 +29,14 @@ More specifically, an await expression has the following effect.
 
 > **Edition differences**: Await expressions are only available beginning with Rust 2018.
 
-## Task context
-
 r[expr.await.task]
+## Task context
 
 The task context refers to the [`Context`] which was supplied to the current [async context] when the async context itself was polled.
 Because `await` expressions are only legal in an async context, there must be some task context available.
 
-## Approximate desugaring
-
 r[expr.await.desugar]
+## Approximate desugaring
 
 Effectively, an await expression is roughly equivalent to the following non-normative desugaring:
 

src/expressions/block-expr.md

@@ -1,6 +1,5 @@
-# Block expressions
-
 r[expr.block]
+# Block expressions
 
 r[expr.block.syntax]
 > **<sup>Syntax</sup>**\
@@ -87,9 +86,8 @@ Blocks are always [value expressions] and evaluate the last operand in value exp
 > }
 > ```
 
-## `async` blocks
-
 r[expr.block.async]
+## `async` blocks
 
 r[expr.block.async.syntax]
 > **<sup>Syntax</sup>**\
@@ -116,24 +114,21 @@ The actual data format for this type is unspecified.
 
 > **Edition differences**: Async blocks are only available beginning with Rust 2018.
 
-### Capture modes
-
 r[expr.block.async.capture]
+### Capture modes
 
 Async blocks capture variables from their environment using the same [capture modes] as closures.
 Like closures, when written `async { .. }` the capture mode for each variable will be inferred from the content of the block.
 `async move { .. }` blocks however will move all referenced variables into the resulting future.
 
-### Async context
-
 r[expr.block.async.context]
+### Async context
 
 Because async blocks construct a future, they define an **async context** which can in turn contain [`await` expressions].
 Async contexts are established by async blocks as well as the bodies of async functions, whose semantics are defined in terms of async blocks.
 
-### Control-flow operators
-
 r[expr.block.async.function]
+### Control-flow operators
 
 r[expr.block.async.function.intro]
 Async blocks act like a function boundary, much like closures.
@@ -155,9 +150,8 @@ loop {
 }
 ```
 
-## `const` blocks
-
 r[expr.block.const]
+## `const` blocks
 
 r[expr.block.const.syntax]
 > **<sup>Syntax</sup>**\
@@ -221,9 +215,8 @@ if false {
 }
 ```
 
-## `unsafe` blocks
-
 r[expr.block.unsafe]
+## `unsafe` blocks
 
 > **<sup>Syntax</sup>**\
 > _UnsafeBlockExpression_ :\
@@ -246,15 +239,13 @@ unsafe {
 let a = unsafe { an_unsafe_fn() };
 ```
 
-## Labelled block expressions
-
 r[expr.block.label]
+## Labelled block expressions
 
 Labelled block expressions are documented in the [Loops and other breakable expressions] section.
 
-## Attributes on block expressions
-
 r[expr.block.attributes]
+## Attributes on block expressions
 
 r[expr.block.attributes.inner-attributes]
 [Inner attributes] are allowed directly after the opening brace of a block expression in the following situations:

src/expressions/call-expr.md

@@ -1,6 +1,5 @@
-# Call expressions
-
 r[expr.call]
+# Call expressions
 
 r[expr.call.syntax]
 > **<sup>Syntax</sup>**\
@@ -36,9 +35,8 @@ let three: i32 = add(1i32, 2i32);
 let name: &'static str = (|| "Rust")();
 ```
 
-## Disambiguating Function Calls
-
 r[expr.call.desugar]
+## Disambiguating Function Calls
 
 r[expr.call.desugar.fully-qualified]
 All function calls are sugar for a more explicit [fully-qualified syntax].

src/expressions/closure-expr.md

@@ -1,6 +1,5 @@
-# Closure expressions
-
 r[expr.closure]
+# Closure expressions
 
 r[expr.closure.syntax]
 > **<sup>Syntax</sup>**\
@@ -48,9 +47,8 @@ r[expr.closure.capture-move]
 A closure can be forced to capture its environment by copying or moving values by prefixing it with the `move` keyword.
 This is often used to ensure that the closure's lifetime is `'static`.
 
-## Closure trait implementations
-
 r[expr.closure.trait-impl]
+## Closure trait implementations
 
 Which traits the closure type implement depends on how variables are captured, the types of the captured variables, and the presence of `async`.
 See the [call traits and coercions] chapter for how and when a closure implements `Fn`, `FnMut`, and `FnOnce`.
@@ -100,7 +98,6 @@ ten_times(move |j| println!("{}, {}", word, j));
 ## Attributes on closure parameters
 
 r[expr.closure.param-attributes]
-
 Attributes on closure parameters follow the same rules and restrictions as [regular function parameters].
 
 [_Expression_]: ../expressions.md

src/expressions/field-expr.md

@@ -1,6 +1,5 @@
-# Field access expressions
-
 r[expr.field]
+# Field access expressions
 
 r[expr.field.syntax]
 > **<sup>Syntax</sup>**\
@@ -43,16 +42,14 @@ foo().x;
 (mystruct.function_field)() // Call expression containing a field expression
 ```
 
-## Automatic dereferencing
-
 r[expr.field.autoref-deref]
+## Automatic dereferencing
 
 If the type of the container operand implements [`Deref`] or [`DerefMut`][`Deref`] depending on whether the operand is [mutable], it is *automatically dereferenced* as many times as necessary to make the field access possible.
 This process is also called *autoderef* for short.
 
-## Borrowing
-
 r[expr.field.borrow]
+## Borrowing
 
 The fields of a struct or a reference to a struct are treated as separate entities when borrowing.
 If the struct does not implement [`Drop`] and is stored in a local variable, this also applies to moving out of each of its fields.

src/expressions/grouped-expr.md

@@ -1,6 +1,5 @@
-# Grouped expressions
-
 r[expr.paren]
+# Grouped expressions
 
 r[expr.paren.syntax]
 > **<sup>Syntax</sup>**\

src/expressions/if-expr.md

@@ -1,6 +1,5 @@
-# `if` and `if let` expressions
-
 r[expr.if]
+# `if` and `if let` expressions
 
 ## `if` expressions
 
@@ -53,9 +52,8 @@ let y = if 12 * 15 > 150 {
 assert_eq!(y, "Bigger");
 ```
 
-## `if let` expressions
-
 r[expr.if.let]
+## `if let` expressions
 
 r[expr.if.let.syntax]
 > **<sup>Syntax</sup>**\