Add identifier syntax to path-expr, range-expr, return-expr, struct-expr, tuple-expr, and underscore-expr

Author: chorman0773

src/expressions/path-expr.md

@@ -1,12 +1,20 @@
 # Path expressions
 
+r[expr.path]
+
+r[expr.path.syntax]
 > **<sup>Syntax</sup>**\
 > _PathExpression_ :\
 > &nbsp;&nbsp; &nbsp;&nbsp; [_PathInExpression_]\
 > &nbsp;&nbsp; | [_QualifiedPathInExpression_]
 
+r[expr.path.intro]
 A [path] used as an expression context denotes either a local variable or an item.
+
+r[expr.path.place]
 Path expressions that resolve to local or static variables are [place expressions], other paths are [value expressions].
+
+r[expr.path.safety]
 Using a [`static mut`] variable requires an [`unsafe` block].
 
 ```rust
@@ -23,6 +31,7 @@ let push_integer = Vec::<i32>::push;
 let slice_reverse = <[i32]>::reverse;
 ```
 
+r[expr.path.const]
 Evaluation of associated constants is handled the same way as [`const` blocks].
 
 [_PathInExpression_]: ../paths.md#paths-in-expressions

src/expressions/range-expr.md

@@ -1,5 +1,8 @@
 # Range expressions
 
+r[expr.range]
+
+r[expr.range.syntax]
 > **<sup>Syntax</sup>**\
 > _RangeExpression_ :\
 > &nbsp;&nbsp; &nbsp;&nbsp; _RangeExpr_\
@@ -27,6 +30,7 @@
 > _RangeToInclusiveExpr_ :\
 > &nbsp;&nbsp; `..=` [_Expression_]
 
+r[expr.range.behaviour]
 The `..` and `..=` operators will construct an object of one of the `std::ops::Range` (or `core::ops::Range`) variants, according to the following table:
 
 | Production             | Syntax        | Type                         | Range                 |
@@ -49,6 +53,7 @@ Examples:
 ..=7;   // std::ops::RangeToInclusive
 ```
 
+r[expr.range.equivalence]
 The following expressions are equivalent.
 
 ```rust
@@ -58,6 +63,7 @@ let y = 0..10;
 assert_eq!(x, y);
 ```
 
+r[expr.range.for]
 Ranges can be used in `for` loops:
 
 ```rust

src/expressions/return-expr.md

@@ -1,10 +1,16 @@
 # `return` expressions
 
+r[expr.return]
+
+r[expr.return.syntax]
 > **<sup>Syntax</sup>**\
 > _ReturnExpression_ :\
 > &nbsp;&nbsp; `return` [_Expression_]<sup>?</sup>
 
+r[expr.return.intro]
 Return expressions are denoted with the keyword `return`.
+
+r[expr.return.behaviour]
 Evaluating a `return` expression moves its argument into the designated output location for the current function call, destroys the current function activation frame, and transfers control to the caller frame.
 
 An example of a `return` expression:

src/expressions/struct-expr.md

@@ -1,5 +1,8 @@
 # Struct expressions
 
+r[expr.struct]
+
+r[expr.struct.syntax]
 > **<sup>Syntax</sup>**\
 > _StructExpression_ :\
 > &nbsp;&nbsp; &nbsp;&nbsp; _StructExprStruct_\
@@ -29,6 +32,7 @@
 >
 > _StructExprUnit_ : [_PathInExpression_]
 
+r[expr.struct.intro]
 A *struct expression* creates a struct, enum, or union value.
 It consists of a path to a [struct], [enum variant], or [union] item followed by the values for the fields of the item.
 There are three forms of struct expressions: struct, tuple, and unit.
@@ -51,17 +55,29 @@ some_fn::<Cookie>(Cookie);
 
 ## Field struct expression
 
+r[expr.struct.field]
+
+r[expr.struct.field.intro]
 A struct expression with fields enclosed in curly braces allows you to specify the value for each individual field in any order.
 The field name is separated from its value with a colon.
 
+r[expr.struct.field.union-constraint]
 A value of a [union] type can only be created using this syntax, and it must specify exactly one field.
 
 ## Functional update syntax
 
+r[expr.struct.update]
+
+r[expr.struct.update.intro]
 A struct expression that constructs a value of a struct type can terminate with the syntax `..` followed by an expression to denote a functional update.
+
+r[expr.struct.update.constraint]
 The expression following `..` (the base) must have the same struct type as the new struct type being formed.
 
+r[expr.struct.update.fields]
 The entire expression uses the given values for the fields that were specified and moves or copies the remaining fields from the base expression.
+
+r[expr.struct.update.visibility-constraint]
 As with all struct expressions, all of the fields of the struct must be [visible], even those not explicitly named.
 
 ```rust
@@ -72,9 +88,11 @@ Point3d {y: 0, z: 10, .. base}; // OK, only base.x is accessed
 drop(y_ref);
 ```
 
+r[expr.struct.restriction]
 Struct expressions with curly braces can't be used directly in a [loop] or [if] expression's head, or in the [scrutinee] of an [if let] or [match] expression.
 However, struct expressions can be used in these situations if they are within another expression, for example inside [parentheses].
 
+r[expr.struct.tuple-field]
 The field names can be decimal integer values to specify indices for constructing tuple structs.
 This can be used with base structs to fill out the remaining indices not specified:
 
@@ -87,6 +105,8 @@ let c3 = Color{1: 0, ..c2};  // Fill out all other fields using a base struct.
 
 ### Struct field init shorthand
 
+r[expr.struct.field.named]
+
 When initializing a data structure (struct, enum, union) with named (but not numbered) fields, it is allowed to write `fieldname` as a shorthand for `fieldname: fieldname`.
 This allows a compact syntax with less duplication.
 For example:
@@ -102,6 +122,8 @@ Point3d { x, y: y_value, z };
 
 ## Tuple struct expression
 
+r[expr.struct.tuple]
+
 A struct expression with fields enclosed in parentheses constructs a tuple struct.
 Though it is listed here as a specific expression for completeness, it is equivalent to a [call expression] to the tuple struct's constructor. For example:
 
@@ -114,6 +136,8 @@ let pos = c(8, 6, 7);  // Creates a `Position` value.
 
 ## Unit struct expression
 
+r[expr.struct.unit]
+
 A unit struct expression is just the path to a unit struct item.
 This refers to the unit struct's implicit constant of its value.
 The unit struct value can also be constructed with a fieldless struct expression. For example:

src/expressions/tuple-expr.md

@@ -1,22 +1,38 @@
 # Tuple and tuple indexing expressions
 
+r[expr.tuple]
+
 ## Tuple expressions
 
+r[expr.tuple]
+
+r[expr.tuple.syntax]
 > **<sup>Syntax</sup>**\
 > _TupleExpression_ :\
 > &nbsp;&nbsp; `(` _TupleElements_<sup>?</sup> `)`
 >
 > _TupleElements_ :\
 > &nbsp;&nbsp; ( [_Expression_] `,` )<sup>+</sup> [_Expression_]<sup>?</sup>
 
+r[expr.tuple.result]
 A *tuple expression* constructs [tuple values][tuple type].
 
+r[expr.tuple.intro]
 The syntax for tuple expressions is a parenthesized, comma separated list of expressions, called the *tuple initializer operands*.
+
+r[expr.tuple.unary-tuple-restriction]
 1-ary tuple expressions require a comma after their tuple initializer operand to be disambiguated with a [parenthetical expression].
 
+r[expr.tuple.value]
 Tuple expressions are a [value expression] that evaluate into a newly constructed value of a tuple type.
+
+r[expr.tuple.type]
 The number of tuple initializer operands is the arity of the constructed tuple.
+
+r[expr.tuple.unit]
 Tuple expressions without any tuple initializer operands produce the unit tuple.
+
+r[expr.tuple.fields]
 For other tuple expressions, the first written tuple initializer operand initializes the field `0` and subsequent operands initializes the next highest field.
 For example, in the tuple expression `('a', 'b', 'c')`, `'a'` initializes the value of the field `0`, `'b'` field `1`, and `'c'` field `2`.
 
@@ -31,19 +47,27 @@ Examples of tuple expressions and their types:
 
 ## Tuple indexing expressions
 
+r[expr.tuple-index]
+
+r[expr.tuple-index.syntax]
 > **<sup>Syntax</sup>**\
 > _TupleIndexingExpression_ :\
 > &nbsp;&nbsp; [_Expression_] `.` [TUPLE_INDEX]
 
+r[expr.tuple-index.intro]
 A *tuple indexing expression* accesses fields of [tuples][tuple type] and [tuple structs][tuple struct].
 
 The syntax for a tuple index expression is an expression, called the *tuple operand*, then a `.`, then finally a tuple index.
+
+r[expr.tuple-index.restriction]
 The syntax for the *tuple index* is a [decimal literal] with no leading zeros, underscores, or suffix.
 For example `0` and `2` are valid tuple indices but not `01`, `0_`, nor `0i32`.
 
+r[expr.tuple-index.constraint]
 The type of the tuple operand must be a [tuple type] or a [tuple struct].
 The tuple index must be a name of a field of the type of the tuple operand.
 
+r[expr.tuple-index.result]
 Evaluation of tuple index expressions has no side effects beyond evaluation of its tuple operand.
 As a [place expression], it evaluates to the location of the field of the tuple operand with the same name as the tuple index.
 

src/expressions/underscore-expr.md

@@ -1,13 +1,20 @@
 # `_` expressions
 
+r[expr.placeholder]
+
+r[expr.placeholder.syntax]
 > **<sup>Syntax</sup>**\
 > _UnderscoreExpression_ :\
 > &nbsp;&nbsp; `_`
 
+r[expr.placeholder.intro]
 Underscore expressions, denoted with the symbol `_`, are used to signify a
-placeholder in a destructuring assignment. They may only appear in the left-hand
-side of an assignment.
+placeholder in a destructuring assignment.
+
+r[expr.placeholder.constraint]
+They may only appear in the left-hand side of an assignment.
 
+r[expr.placeholder.pattern]
 Note that this is distinct from the [wildcard pattern](../patterns.md#wildcard-pattern).
 
 Examples of `_` expressions: