Grammar: Statements.

Cleans up "Statement" definition.
Adds "let" statement.

Author: ehuss

src/expressions.md

@@ -2,9 +2,12 @@
 
 > **<sup>Syntax</sup>**\
 > _Expression_ :\
+> &nbsp;&nbsp; &nbsp;&nbsp; _ExpressionWithoutBlock_\
+> &nbsp;&nbsp; | _ExpressionWithBlock_
+>
+> _ExpressionWithoutBlock_ :\
 > &nbsp;&nbsp; &nbsp;&nbsp; [_LiteralExpression_]\
 > &nbsp;&nbsp; | [_PathExpression_]\
-> &nbsp;&nbsp; | [_BlockExpression_]\
 > &nbsp;&nbsp; | [_OperatorExpression_]\
 > &nbsp;&nbsp; | [_GroupedExpression_]\
 > &nbsp;&nbsp; | [_ArrayExpression_]\
@@ -17,14 +20,18 @@
 > &nbsp;&nbsp; | [_MethodCallExpression_]\
 > &nbsp;&nbsp; | [_FieldExpression_]\
 > &nbsp;&nbsp; | [_ClosureExpression_]\
-> &nbsp;&nbsp; | [_LoopExpression_]\
 > &nbsp;&nbsp; | [_ContinueExpression_]\
 > &nbsp;&nbsp; | [_BreakExpression_]\
 > &nbsp;&nbsp; | [_RangeExpression_]\
+> &nbsp;&nbsp; | [_ReturnExpression_]
+>
+> _ExpressionWithBlock_ :\
+> &nbsp;&nbsp; &nbsp;&nbsp; [_BlockExpression_]\
+> &nbsp;&nbsp; | [_UnsafeBlockExpression_]\
+> &nbsp;&nbsp; | [_LoopExpression_]\
 > &nbsp;&nbsp; | [_IfExpression_]\
 > &nbsp;&nbsp; | [_IfLetExpression_]\
-> &nbsp;&nbsp; | [_MatchExpression_]\
-> &nbsp;&nbsp; | [_ReturnExpression_]
+> &nbsp;&nbsp; | [_MatchExpression_]
 
 An expression may have two roles: it always produces a *value*, and it may have
 *effects* (otherwise known as "side effects"). An expression *evaluates to* a
@@ -341,3 +348,4 @@ exist in `core::ops` and `core::cmp` with the same names.
 [_StructExpression_]:             expressions/struct-expr.html
 [_TupleExpression_]:              expressions/tuple-expr.html
 [_TupleIndexingExpression_]:      expressions/tuple-expr.html#tuple-indexing-expressions
+[_UnsafeBlockExpression_]:        expressions/block-expr.html#unsafe-blocks

src/expressions/block-expr.md

@@ -4,19 +4,11 @@
 > _BlockExpression_ :\
 >    `{`\
 > &nbsp;&nbsp; &nbsp;&nbsp; [_InnerAttribute_]<sup>\*</sup>\
-> &nbsp;&nbsp; &nbsp;&nbsp; _Statements_<sup>\*</sup>\
+> &nbsp;&nbsp; &nbsp;&nbsp; [_Statement_]<sup>\*</sup>\
 > &nbsp;&nbsp; &nbsp;&nbsp; [_Expression_]<sup>?</sup>\
 > &nbsp;&nbsp; `}`
->
-> _Statements_ :\
-> &nbsp;&nbsp; ( `;`\
-> &nbsp;&nbsp; | [_ItemDeclaration_]\
-> &nbsp;&nbsp; | [_LetStatement_] ;\
-> &nbsp;&nbsp; | [_NonControlFlowExpressionStatement_][expression statement] ;\
-> &nbsp;&nbsp; | [_FlowControlExpressionStatement_][expression statement] ;<sup>?</sup>\
-> &nbsp;&nbsp; )<sup>\*</sup>
-
-A *block expression*, or *block*, is a control flow expression and anonymouse
+
+A *block expression*, or *block*, is a control flow expression and anonymous
 namespace scope for items and variable declarations. As a control flow
 expression, a block sequentially executes its component non-item declaration
 statements and then its final optional expression. As an anonymous namespace
@@ -60,7 +52,7 @@ assert_eq!(5, five);
 > expression of an expression statement, the expected type is `()` unless it
 > is followed immediately by a semicolon.
 
-Blocks are always [value expressions] and evaluate the last expression in 
+Blocks are always [value expressions] and evaluate the last expression in
 value expression context. This can be used to force moving a value if really
 needed. For example, the following example fails on the call to `consume_self`
 because the struct was moved out of `s` in the block expression.
@@ -126,9 +118,7 @@ fn is_unix_platform() -> bool {
 ```
 
 [_InnerAttribute_]: attributes.html
-[_ItemDeclaration_]: items.html
-[_LetStatement_]: statements.html#let-statements
-[expression statement]: statements.html#expression-statements
+[_Statement_]: statements.html
 [_Expression_]: expressions.html
 [expression]: expressions.html
 [statements]: statements.html

src/statements.md

@@ -1,5 +1,14 @@
 # Statements
 
+> **<sup>Syntax</sup>**\
+> _Statement_ :\
+> &nbsp;&nbsp; &nbsp;&nbsp; `;`\
+> &nbsp;&nbsp; | [_Item_]\
+> &nbsp;&nbsp; | [_LetStatement_]\
+> &nbsp;&nbsp; | [_ExpressionWithoutBlock_][expression] `;`\
+> &nbsp;&nbsp; | [_ExpressionWithBlock_][expression]
+
+
 A *statement* is a component of a [block], which is in turn a component of an
 outer [expression] or [function].
 
@@ -42,6 +51,10 @@ fn outer() {
 
 ### `let` statements
 
+> **<sup>Syntax</sup>**\
+> _LetStatement_ :\
+> &nbsp;&nbsp; `let` [_Pattern_] ( `:` [_Type_] )<sup>?</sup> (`=` [_Expression_] )<sup>?</sup> `;`
+
 A *`let` statement* introduces a new set of [variables], given by a [pattern]. The
 pattern is followed optionally by a type annotation and then optionally by an
 initializer expression. When no type annotation is given, the compiler will
@@ -107,3 +120,8 @@ statement are [`cfg`], and [the lint check attributes].
 [`cfg`]: conditional-compilation.html
 [the lint check attributes]: attributes.html#lint-check-attributes
 [pattern]: patterns.html
+[_Expression_]: expressions.html
+[_Item_]: items.html
+[_LetStatement_]: #let-statements
+[_Pattern_]: patterns.html
+[_Type_]: types.html