Update let chain grammar for minimum precedence

This adds some more exclusions to the let chain grammar to capture the
minimum precedence while parsing chains. Note that this is incomplete,
see #1811. I didn't want to
block things on finalizing this.

I also reworked the `while` grammar to just reuse the grammar from `if`
to avoid the duplication.

Author: ehuss

src/expressions/if-expr.md

@@ -4,16 +4,31 @@ r[expr.if]
 r[expr.if.syntax]
 ```grammar,expressions
 IfExpression ->
-    `if` IfConditions BlockExpression
+    `if` Conditions BlockExpression
     (`else` ( BlockExpression | IfExpression ) )?
 
-IfConditions -> IfCondition ( `&&` IfCondition )*
-
-IfCondition ->
+Conditions ->
       Expression _except [StructExpression]_
-    | `let` Pattern `=` Scrutinee _except [LazyBooleanExpression]_
+    | LetChain
+
+LetChain -> LetChainCondition ( `&&` LetChainCondition )*
+
+LetChainCondition ->
+      Expression _except [ExcludedConditions]_
+    | OuterAttribute* `let` Pattern `=` Scrutinee _except [ExcludedConditions]_
+
+@root ExcludedConditions ->
+      StructExpression
+    | LazyBooleanExpression
+    | RangeExpr
+    | RangeFromExpr
+    | RangeInclusiveExpr
+    | AssignmentExpression
+    | CompoundAssignmentExpression
 ```
-<!-- TODO: The exception above isn't accurate, see https://github.com/rust-lang/reference/issues/569 -->
+<!-- TODO: The struct exception above needs clarification, see https://github.com/rust-lang/reference/issues/1808
+     The chain grammar could use some work, see https://github.com/rust-lang/reference/issues/1811
+-->
 
 r[expr.if.intro]
 The syntax of an `if` expression is a sequence of one or more condition operands separated by `&&`,
@@ -161,7 +176,7 @@ if let Some(x) = foo && (condition1 || condition2) { /*...*/ }
 
 r[expr.if.edition2024]
 > [!EDITION-2024]
-> Before the 2024 edition, let chains are not supported and only a single _IfCondition_ is allowed in an `if` expression.
+> Before the 2024 edition, let chains are not supported. That is, the [LetChain] grammar is not allowed in an `if` expression.
 
 [_BlockExpression_]: block-expr.md
 [_Expression_]: ../expressions.md

src/expressions/loop-expr.md

@@ -52,15 +52,8 @@ r[expr.loop.while]
 
 r[expr.loop.while.grammar]
 ```grammar,expressions
-PredicateLoopExpression -> `while` WhileConditions BlockExpression
-
-WhileConditions -> WhileCondition ( `&&` WhileCondition )*
-
-WhileCondition ->
-      Expression _except [StructExpression]_
-    | `let` Pattern `=` Scrutinee _except [LazyBooleanExpression]_
+PredicateLoopExpression -> `while` Conditions BlockExpression
 ```
-<!-- TODO: The exception above isn't accurate, see https://github.com/rust-lang/reference/issues/569 -->
 
 r[expr.loop.while.intro]
 A `while` loop expression allows repeating the evaluation of a block while a set of conditions remain true.