Adjust some rule names for clarity

This adjusts some rule names to be more explicit about what they are
for.

Author: ehuss

src/expressions/await-expr.md

@@ -14,7 +14,7 @@ future is ready to produce a value.
 r[expr.await.construct]
 The syntax for an await expression is an expression with a type that implements the [`IntoFuture`] trait, called the *future operand*, then the token `.`, and then the `await` keyword.
 
-r[expr.await.constraints]
+r[expr.await.allowed-positions]
 Await expressions are legal only within an [async context], like an [`async fn`], [`async` closure], or [`async` block].
 
 r[expr.await.effects]

src/expressions/field-expr.md

@@ -15,7 +15,7 @@ When the operand is [mutable], the field expression is also mutable.
 r[expr.field.form]
 The syntax for a field expression is an expression, called the *container operand*, then a `.`, and finally an [identifier].
 
-r[expr.field.constraint]
+r[expr.field.not-method-call]
 Field expressions cannot be followed by a parenthetical comma-separated list of expressions, as that is instead parsed as a [method call expression].
 That is, they cannot be the function operand of a [call expression].
 

src/expressions/if-expr.md

@@ -16,7 +16,7 @@ r[expr.if.intro]
 An `if` expression is a conditional branch in program control.
 The syntax of an `if` expression is a condition operand, followed by a consequent block, any number of `else if` conditions and blocks, and an optional trailing `else` block.
 
-r[expr.if.constraint]
+r[expr.if.condition-bool]
 The condition operands must have the [boolean type].
 
 r[expr.if.condition-true]
@@ -152,7 +152,7 @@ if let E::X(n) | E::Y(n) = v {
 }
 ```
 
-r[expr.if.let.restriction]
+r[expr.if.let.lazy-bool]
 The expression cannot be a [lazy boolean operator expression][_LazyBooleanOperatorExpression_].
 Use of a lazy boolean operator is ambiguous with a planned feature change of the language (the implementation of if-let chains - see [eRFC 2947][_eRFCIfLetChain_]).
 When lazy boolean operator expression is desired, this can be achieved by using parenthesis as below:

src/expressions/literal-expr.md

@@ -129,7 +129,7 @@ A character literal expression consists of a single [CHAR_LITERAL] token.
 r[expr.literal.char.type]
 The expression's type is the primitive [`char`][textual types] type.
 
-r[expr.literal.char.restriction]
+r[expr.literal.char.no-suffix]
 The token must not have a suffix.
 
 r[expr.literal.char.literal-content]
@@ -171,7 +171,7 @@ r[expr.literal.string.type]
 The expression's type is a shared reference (with `static` lifetime) to the primitive [`str`][textual types] type.
 That is, the type is `&'static str`.
 
-r[expr.literal.string.restriction]
+r[expr.literal.string.no-suffix]
 The token must not have a suffix.
 
 r[expr.literal.string.literal-content]
@@ -218,7 +218,7 @@ A byte literal expression consists of a single [BYTE_LITERAL] token.
 r[expr.literal.byte-char.literal]
 The expression's type is the primitive [`u8`][numeric types] type.
 
-r[expr.literal.byte-char.restriction]
+r[expr.literal.byte-char.no-suffix]
 The token must not have a suffix.
 
 r[expr.literal.byte-char.literal-content]
@@ -259,7 +259,7 @@ r[expr.literal.byte-string.type]
 The expression's type is a shared reference (with `static` lifetime) to an array whose element type is [`u8`][numeric types].
 That is, the type is `&'static [u8; N]`, where `N` is the number of bytes in the represented string described below.
 
-r[expr.literal.byte-string.restriction]
+r[expr.literal.byte-string.no-suffix]
 The token must not have a suffix.
 
 r[expr.literal.byte-string.literal-content]
@@ -308,7 +308,7 @@ r[expr.literal.c-string.type]
 The expression's type is a shared reference (with `static` lifetime) to the standard library [CStr] type.
 That is, the type is `&'static core::ffi::CStr`.
 
-r[expr.literal.c-string.restriction]
+r[expr.literal.c-string.no-suffix]
 The token must not have a suffix.
 
 r[expr.literal.c-string.literal-content]

src/expressions/loop-expr.md

@@ -144,7 +144,7 @@ while let Some(v @ 1) | Some(v @ 2) = vals.pop() {
 }
 ```
 
-r[expr.loop.while.let.restriction]
+r[expr.loop.while.let.lazy-bool]
 As is the case in [`if let` expressions], the scrutinee cannot be a [lazy boolean operator expression][_LazyBooleanOperatorExpression_].
 
 r[expr.loop.for]
@@ -302,7 +302,7 @@ Labelled block expressions are exactly like block expressions, except that they
 r[expr.loop.block-labels.break]
 Unlike loops, `break` expressions within a labelled block expression *must* have a label (i.e. the label is not optional).
 
-r[expr.loop.block-labels.restriction]
+r[expr.loop.block-labels.label-required]
 Similarly, labelled block expressions *must* begin with a label.
 
 ```rust
@@ -344,7 +344,7 @@ In the case of a `for` loop, the head is the call-expression controlling the loo
 r[expr.loop.continue.label]
 Like `break`, `continue` is normally associated with the innermost enclosing loop, but `continue 'label` may be used to specify the loop affected.
 
-r[expr.loop.continue.constraint]
+r[expr.loop.continue.in-loop-only]
 A `continue` expression is only permitted in the body of a loop.
 
 r[expr.loop.break-value]

src/expressions/match-expr.md

@@ -151,7 +151,7 @@ r[expr.match.guard.value]
 Only when the guard evaluates to true is the value moved, or copied, from the scrutinee into the variable.
 This allows shared borrows to be used inside guards without moving out of the scrutinee in case guard fails to match.
 
-r[expr.match.guard.restriction]
+r[expr.match.guard.no-mutation]
 Moreover, by holding a shared reference while evaluating the guard, mutation inside guards is also prevented.
 
 r[expr.match.attributes]

src/expressions/method-call-expr.md

@@ -71,7 +71,7 @@ Then, for each candidate type `T`, search for a [visible] method with a receiver
 r[expr.method.ambiguous-target]
 If this results in multiple possible candidates, then it is an error, and the receiver must be [converted][disambiguate call] to an appropriate receiver type to make the method call.
 
-r[expr.method.constraint]
+r[expr.method.receiver-constraints]
 This process does not take into account the mutability or lifetime of the receiver, or whether a method is `unsafe`.
 Once a method is looked up, if it can't be called for one (or more) of those reasons, the result is a compiler error.
 

src/expressions/operator-expr.md

@@ -196,7 +196,7 @@ r[expr.try.syntax]
 r[expr.try.intro]
 The question mark operator (`?`) unwraps valid values or returns erroneous values, propagating them to the calling function.
 
-r[expr.try.constraint]
+r[expr.try.restricted-types]
 It is a unary postfix operator that can only be applied to the types `Result<T, E>` and `Option<T>`.
 
 r[expr.try.behavior-std-result]
@@ -358,7 +358,7 @@ r[expr.cmp.syntax]
 r[expr.cmp.intro]
 Comparison operators are also defined both for primitive types and many types in the standard library.
 
-r[expr.cmp.restriction]
+r[expr.cmp.paren-chaining]
 Parentheses are required when chaining comparison operators. For example, the expression `a == b == c` is invalid and may be written as `(a == b) == c`.
 
 r[expr.cmp.trait]
@@ -736,12 +736,12 @@ let (mut a, mut b) = (0, 1);
 (b, a) = (a, b);
 ```
 
-r[expr.assign.destructure.restriction]
+r[expr.assign.destructure.assignee]
 In contrast to destructuring declarations using `let`, patterns may not appear on the left-hand side of an assignment due to syntactic ambiguities.
 Instead, a group of expressions that correspond to patterns are designated to be [assignee expressions][assignee expression], and permitted on the left-hand side of an assignment.
 Assignee expressions are then desugared to pattern matches followed by sequential assignment.
 
-r[expr.assign.destructure.constraint]
+r[expr.assign.destructure.irrefutable]
 The desugared patterns must be irrefutable: in particular, this means that only slice patterns whose length is known at compile-time, and the trivial slice `[..]`, are permitted for destructuring assignment.
 
 The desugaring method is straightforward, and is illustrated best by example.
@@ -818,7 +818,7 @@ The syntax of compound assignment is a [mutable] [place expression], the *assign
 r[expr.compound-assign.place]
 Unlike other place operands, the assigned place operand must be a place expression.
 
-r[expr.compound-assign.constraint]
+r[expr.compound-assign.no-value]
 Attempting to use a value expression is a compiler error rather than promoting it to a temporary.
 
 r[expr.compound-assign.operand-order]

src/expressions/struct-expr.md

@@ -68,7 +68,7 @@ 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]
+r[expr.struct.update.base-same-type]
 The expression following `..` (the base) must have the same struct type as the new struct type being formed.
 
 r[expr.struct.update.fields]
@@ -85,7 +85,7 @@ Point3d {y: 0, z: 10, .. base}; // OK, only base.x is accessed
 drop(y_ref);
 ```
 
-r[expr.struct.restriction]
+r[expr.struct.brace-restricted-positions]
 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].
 

src/expressions/tuple-expr.md

@@ -55,12 +55,14 @@ A *tuple indexing expression* accesses fields of [tuples][tuple type] and [tuple
 
 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]
+r[expr.tuple-index.index-syntax]
 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]
+r[expr.tuple-index.required-type]
 The type of the tuple operand must be a [tuple type] or a [tuple struct].
+
+r[expr.tuple-index.index-name-operand]
 The tuple index must be a name of a field of the type of the tuple operand.
 
 r[expr.tuple-index.result]

src/expressions/underscore-expr.md

@@ -10,7 +10,7 @@ r[expr.placeholder.intro]
 Underscore expressions, denoted with the symbol `_`, are used to signify a
 placeholder in a destructuring assignment.
 
-r[expr.placeholder.constraint]
+r[expr.placeholder.lhs-assignment-only]
 They may only appear in the left-hand side of an assignment.
 
 r[expr.placeholder.pattern]