Fix statements and add some missing attributes.

Author: ehuss

src/expressions.md

@@ -262,6 +262,7 @@ a few specific cases:
         https://github.com/rust-lang/rust/issues/15701
   -->
 * The tail expression of [block expressions].
+<!-- Keep list in sync with block-expr.md -->
 
 They are never allowed before:
 

src/expressions/array-expr.md

@@ -4,9 +4,11 @@
 
 > **<sup>Syntax</sup>**\
 > _ArrayExpression_ :\
-> &nbsp;&nbsp; &nbsp;&nbsp; `[`  `]`\
-> &nbsp;&nbsp; | `[` [_Expression_] ( `,` [_Expression_] )<sup>\*</sup> `,`<sup>?</sup> `]`\
-> &nbsp;&nbsp; | `[` [_Expression_] `;` [_Expression_] `]`
+> &nbsp;&nbsp; `[` [_InnerAttribute_]<sup>\*</sup> _ArrayElements_<sup>?</sup> `]`
+>
+> _ArrayElements_ :\
+> &nbsp;&nbsp; &nbsp;&nbsp; [_Expression_] ( `,` [_Expression_] )<sup>\*</sup> `,`<sup>?</sup>\
+> &nbsp;&nbsp; | [_Expression_] `;` [_Expression_]
 
 An _[array](types.html#array-and-slice-types) expression_ can be written by
 enclosing zero or more comma-separated expressions of uniform type in square
@@ -30,6 +32,12 @@ greater than 1 then this requires that the type of `a` is
 [[1, 0, 0], [0, 1, 0], [0, 0, 1]]; // 2D array
 ```
 
+### Array expression attributes
+
+[Inner attributes] are allowed directly after the opening bracket of an array
+expression in the same expression contexts as [attributes on block
+expressions].
+
 ## Array and slice indexing expressions
 
 > **<sup>Syntax</sup>**\
@@ -73,8 +81,11 @@ arr[10];                  // warning: index out of bounds
 The array index expression can be implemented for types other than arrays and slices
 by implementing the [Index] and [IndexMut] traits.
 
-[_Expression_]: expressions.html
-[memory location]: expressions.html#place-expressions-and-value-expressions
-[Index]: ../std/ops/trait.Index.html
 [IndexMut]: ../std/ops/trait.IndexMut.html
+[Index]: ../std/ops/trait.Index.html
+[Inner attributes]: attributes.html
+[_Expression_]: expressions.html
+[_InnerAttribute_]: attributes.html
+[attributes on block expressions]: expressions/block-expr.html#attributes-on-block-expressions
 [constant expression]: const_eval.html#constant-expressions
+[memory location]: expressions.html#place-expressions-and-value-expressions

src/expressions/block-expr.md

@@ -4,9 +4,13 @@
 > _BlockExpression_ :\
 >    `{`\
 > &nbsp;&nbsp; &nbsp;&nbsp; [_InnerAttribute_]<sup>\*</sup>\
-> &nbsp;&nbsp; &nbsp;&nbsp; [_Statement_]<sup>\*</sup>\
-> &nbsp;&nbsp; &nbsp;&nbsp; [_Expression_]<sup>?</sup>\
+> &nbsp;&nbsp; &nbsp;&nbsp; _Statements_<sup>?</sup>\
 > &nbsp;&nbsp; `}`
+>
+> _Statements_ :\
+> &nbsp;&nbsp; &nbsp;&nbsp; [_Statement_]<sup>\+</sup>\
+> &nbsp;&nbsp; | [_Statement_]<sup>\+</sup> [_ExpressionWithoutBlock_]\
+> &nbsp;&nbsp; | [_ExpressionWithoutBlock_]
 
 A *block expression*, or *block*, is a control flow expression and anonymous
 namespace scope for items and variable declarations. As a control flow
@@ -101,11 +105,19 @@ let a = unsafe { an_unsafe_fn() };
 
 ## Attributes on block expressions
 
-Block expressions allow [outer attributes] and [inner attributes] directly after
-the opening brace when the block expression is the outer expression of an
-[expression statement] or the final expression of another block expression. The
-attributes that have meaning on a block expression are [`cfg`] and [the lint
-check attributes].
+[Inner attributes] are allowed directly after the opening brace of a block
+expression in the following situations:
+
+* [Function] and [method] bodies.
+* Loop bodies ([`loop`], [`while`], [`while let`], and [`for`]).
+* Block expressions used as a [statement].
+* Block expressions as elements of [array expressions], [tuple expressions],
+  [call expressions], tuple-style [struct] and [enum variant] expressions.
+* A block expression as the tail expression of another block expression.
+<!-- Keep list in sync with expressions.md -->
+
+The attributes that have meaning on a block expression are [`cfg`] and [the
+lint check attributes].
 
 For example, this function returns `true` on unix platforms and `false` on other
 platforms.
@@ -117,15 +129,26 @@ fn is_unix_platform() -> bool {
 }
 ```
 
+[_ExpressionWithoutBlock_]: expressions.html
 [_InnerAttribute_]: attributes.html
 [_Statement_]: statements.html
-[_Expression_]: expressions.html
+[`cfg`]: conditional-compilation.html
+[`for`]: expressions/loop-expr.html#iterator-loops
+[`loop`]: expressions/loop-expr.html#infinity-loops
+[`while let`]: expressions/loop-expr.html#predicate-pattern-loops
+[`while`]: expressions/loop-expr.html#predicate-loops
+[array expressions]: expressions/array-expr.html
+[call expressions]: expressions/call-expr.html
+[enum variant]: expressions/enum-variant-expr.html
+[expression attributes]: expressions.html#expression-attributes
 [expression]: expressions.html
-[statements]: statements.html
-[value expressions]: expressions.html#place-expressions-and-value-expressions
-[outer attributes]: attributes.html
+[function]: items/functions.html
 [inner attributes]: attributes.html
-[expression statement]: statements.html#expression-statements
-[`cfg`]: conditional-compilation.html
+[method]: items/associated-items.html#methods
+[statement]: statements.html
+[statements]: statements.html
+[struct]: expressions/struct-expr.html
 [the lint check attributes]: attributes.html#lint-check-attributes
+[tuple expressions]: expressions/tuple-expr.html
 [unsafe operations]: unsafety.html
+[value expressions]: expressions.html#place-expressions-and-value-expressions

src/expressions/grouped-expr.md

@@ -2,7 +2,7 @@
 
 > **<sup>Syntax</sup>**\
 > _GroupedExpression_ :\
-> &nbsp;&nbsp; `(` [_Expression_] `)`
+> &nbsp;&nbsp; `(` [_InnerAttribute_]<sup>\*</sup> [_Expression_] `)`
 
 An expression enclosed in parentheses evaluates to the result of the enclosed
 expression. Parentheses can be used to explicitly specify evaluation order
@@ -35,4 +35,13 @@ assert_eq!( a.f (), "The method f");
 assert_eq!((a.f)(), "The field f");
 ```
 
+## Group expression attributes
+
+[Inner attributes] are allowed directly after the opening parenthesis of a
+group expression in the same expression contexts as [attributes on block
+expressions].
+
+[Inner attributes]: attributes.html
 [_Expression_]: expressions.html
+[_InnerAttribute_]: attributes.html
+[attributes on block expressions]: expressions/block-expr.html#attributes-on-block-expressions

src/expressions/match-expr.md

@@ -120,6 +120,10 @@ let message = match maybe_digit {
 Outer attributes are allowed on match arms. The only attributes that have
 meaning on match arms are [`cfg`], `cold`, and the [lint check attributes].
 
+[Inner attributes] are allowed directly after the opening brace of the match
+expression in the same expression contexts as [attributes on block
+expressions].
+
 [_Expression_]: expressions.html
 [_BlockExpression_]: expressions/block-expr.html#block-expressions
 [place expression]: expressions.html#place-expressions-and-value-expressions
@@ -133,8 +137,10 @@ meaning on match arms are [`cfg`], `cold`, and the [lint check attributes].
 [_Pattern_]: patterns.html
 [pattern]: patterns.html
 [Identifier Patterns]: patterns.html#identifier-patterns
+[Inner attributes]: attributes.html
 [Struct Patterns]: patterns.html#struct-patterns
 [Tuple Struct Patterns]: patterns.html#tuplestruct-patterns
 [Tuple Patterns]: patterns.html#tuple-patterns
 [Range Pattern]: patterns.html#range-patterns
+[attributes on block expressions]: expressions/block-expr.html#attributes-on-block-expressions
 [binding mode]: patterns.html#binding-modes

src/expressions/struct-expr.md

@@ -7,7 +7,7 @@
 >    | _StructExprUnit_
 >
 > _StructExprStruct_ :\
-> &nbsp;&nbsp; [_PathInExpression_] `{` (_StructExprFields_ | _StructBase_)<sup>?</sup> `}`
+> &nbsp;&nbsp; [_PathInExpression_] `{` [_InnerAttribute_]<sup>\*</sup> (_StructExprFields_ | _StructBase_)<sup>?</sup> `}`
 >
 > _StructExprFields_ :\
 > &nbsp;&nbsp; _StructExprField_ (`,` _StructExprField_)<sup>\*</sup> (`,` _StructBase_ | `,`<sup>?</sup>)
@@ -16,10 +16,12 @@
 > &nbsp;&nbsp; &nbsp;&nbsp; [IDENTIFIER]\
 > &nbsp;&nbsp; | ([IDENTIFIER] | [TUPLE_INDEX]) `:` [_Expression_]
 >
-> _StructBase_ : `..` [_Expression_]
+> _StructBase_ :\
+> &nbsp;&nbsp; `..` [_Expression_]
 >
 > _StructExprTuple_ :\
 > &nbsp;&nbsp; [_PathInExpression_] `(`\
+> &nbsp;&nbsp; &nbsp;&nbsp; [_InnerAttribute_]<sup>\*</sup>\
 > &nbsp;&nbsp; &nbsp;&nbsp; ( [_Expression_] (`,` [_Expression_])<sup>\*</sup> `,`<sup>?</sup> )<sup>?</sup>\
 > &nbsp;&nbsp; `)`
 >
@@ -126,11 +128,19 @@ let a = Gamma;  // Gamma unit value.
 let b = Gamma{};  // Exact same value as `a`.
 ```
 
+## Struct expression attributes
+
+[Inner attributes] are allowed directly after the opening brace or parenthesis
+of a struct expression in the same expression contexts as [attributes on block
+expressions].
 
 [IDENTIFIER]: identifiers.html
+[Inner attributes]: attributes.html
 [TUPLE_INDEX]: tokens.html#integer-literals
 [_Expression_]: expressions.html
+[_InnerAttribute_]: attributes.html
 [_PathInExpression_]: paths.html#paths-in-expressions
+[attributes on block expressions]: expressions/block-expr.html#attributes-on-block-expressions
 [call expression]: expressions/call-expr.html
 [if let]: expressions/if-expr.html#if-let-expressions
 [if]: expressions/if-expr.html#if-expressions

src/expressions/tuple-expr.md

@@ -4,8 +4,10 @@
 
 > **<sup>Syntax</sup>**\
 > _TupleExpression_ :\
-> &nbsp;&nbsp; &nbsp;&nbsp; `(` `)`\
-> &nbsp;&nbsp; | `(` ( [_Expression_] `,` )<sup>+</sup> [_Expression_]<sup>?</sup> `)`
+> &nbsp;&nbsp; `(` [_InnerAttribute_]<sup>\*</sup> _TupleElements_<sup>?</sup> `)`
+>
+> _TupleElements_ :\
+> &nbsp;&nbsp; ( [_Expression_] `,` )<sup>+</sup> [_Expression_]<sup>?</sup>
 
 Tuples are written by enclosing zero or more comma-separated expressions in
 parentheses. They are used to create [tuple-typed](types.html#tuple-types)
@@ -25,6 +27,12 @@ comma:
 (0); // zero in parentheses
 ```
 
+### Tuple expression attributes
+
+[Inner attributes] are allowed directly after the opening parenthesis of a
+tuple expression in the same expression contexts as [attributes on block
+expressions].
+
 ## Tuple indexing expressions
 
 > **<sup>Syntax</sup>**\
@@ -46,5 +54,8 @@ let unit_x = Point(1.0, 0.0);
 assert_eq!(unit_x.0, 1.0);
 ```
 
+[Inner attributes]: attributes.html
 [TUPLE_INDEX]: tokens.html#integer-literals
 [_Expression_]: expressions.html
+[_InnerAttribute_]: attributes.html
+[attributes on block expressions]: expressions/block-expr.html#attributes-on-block-expressions

src/statements.md

@@ -74,7 +74,8 @@ An expression that consists of only a [block expression][block] or control flow
 expression, if used in a context where a statement is permitted, can omit the
 trailing semicolon. This can cause an ambiguity between it being parsed as a
 standalone statement and as a part of another expression; in this case, it is
-parsed as a statement.
+parsed as a statement. The type of [_ExpressionWithBlock_][expression]
+expressions when used as statements must be the unit type.
 
 ```rust
 # let mut v = vec![1, 2, 3];