cutted down match-expr, added info in destructors, fixed syntax, removed ingore from some blocks

Author: Kivooeo

src/destructors.md

@@ -415,6 +415,50 @@ let x = (&temp()).use_temp();  // ERROR
 # x;
 ```
 
+r[destructors.scope.temporary.if-let-guard]
+### If Let Guards in Match Expressions
+
+When an `if let` guard is evaluated in a match expression:
+
+1. **Guard evaluation scope**: Variables bound by the `if let` pattern and any temporaries created during guard evaluation have a scope that extends through the match arm body if the guard succeeds.
+
+2. **Failed guard cleanup**: If the `if let` guard fails to match:
+   - Any variables bound by the guard pattern are immediately dropped
+   - Temporaries created during guard evaluation are dropped
+   - Pattern matching continues to the next arm
+
+3. **Successful guard**: If the guard succeeds:
+   - Guard-bound variables remain live for the duration of the match arm body
+   - They are dropped at the end of the match arm execution
+
+4. **Multiple guards**: In arms with multiple guards connected by `&&`:
+   - Each failed guard drops its own bindings before evaluating the next guard
+   - Only successful guard bindings are available in the arm body
+
+#### Example
+
+```rust
+# let value = Some(2)
+# fn expensive_operation(x: i32) -> Option<i32> {
+#       Some(x + 2)
+# }
+#
+match value {
+    Some(x) if let Some(y) = expensive_operation(x) => {
+        // Both x and y are live here
+        // expensive_operation(x) result is moved into y
+        // y dropped here at end of arm
+    } // Any temporaries from expensive_operation dropped here
+    Some(x) => {
+        // If first guard failed, y and expensive_operation result
+        // were already dropped before reaching this arm
+    }
+    None => {}
+}
+```
+
+This behavior is consistent across all Rust editions and matches the scoping semantics of nested `if let` expressions within match arms.
+
 r[destructors.forget]
 ## Not running destructors
 

src/expressions/match-expr.md

@@ -23,11 +23,8 @@ MatchArmGuard ->
     `if` MatchConditions
 
 MatchConditions ->
-    MatchCondition ( `&&` MatchCondition )*
-
-MatchCondition ->
-      OuterAttribute* `let` Pattern `=` Scrutinee
-    | Expression
+      Expression _except [StructExpression]_
+    | LetChain
 ```
 <!-- TODO: The exception above isn't accurate, see https://github.com/rust-lang/reference/issues/569 -->
 
@@ -161,71 +158,62 @@ 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.if.let.guard]
-## If Let Guards
-Match arms can include `if let` guards to allow conditional pattern matching within the guard clause.
+## If-let Guards
+Match arms can have additional conditions using *if-let guards*. These allow using `if let` expressions within match guard clauses, enabling conditional pattern matching directly in the guard.
 
 r[expr.match.if.let.guard.syntax]
-```rust,ignore
-match expression {
-    pattern if let subpattern = guard_expr => arm_body,
-    ...
+```rust
+enum Command {
+    Run(String),
+    Stop,
+}
+
+match cmd {
+    Command::Run(name) if let Some(first_char) = name.chars().next() => {
+        // Both `name` and `first_char` are available here
+        println!("Running: {} (starts with '{}')", name, first_char);
+    }
+    Command::Run(name) => {
+        println!("Cannot run command: {}", name);
+    }
+    _ => {}
 }
 ```
-Here, `guard_expr` is evaluated and matched against `subpattern`. If the `if let` expression in the guard matches successfully, the arm's body is executed. Otherwise, pattern matching continues to the next arm.
+Here, the guard condition `let Some(first_char) = name.chars().next()` is evaluated. If the `if let` expression successfully matches (i.e., the string has at least one character), the arm's body is executed with both `name` and `first_char` available. Otherwise, pattern matching continues to the next arm.
+
+The key point is that the `if let` guard creates a new binding (`first_char`) that's only available if the guard succeeds, and this binding can be used alongside the original pattern bindings (`name`) in the arm's body.
 
 r[expr.match.if.let.guard.behavior]
 When the pattern matches successfully, the `if let` expression in the guard is evaluated:
   * The guard proceeds if the inner pattern (`subpattern`) matches the result of `guard_expr`.
   * Otherwise, the next arm is tested.
 
-```rust,ignore
-let value = Some(10);
-
-let msg = match value {
-    Some(x) if let Some(y) = Some(x - 1) => format!("Matched inner value: {}", y),
-    _ => "No match".to_string(),
-};
-```
-
-r[expr.match.if.let.guard.scope]
-* The `if let` guard may refer to variables bound by the outer match pattern.
-* New variables bound inside the `if let` guard (e.g., `y` in the example above) are available within the body of the match arm where the guard evaluates to `true`, but are not accessible in other arms or outside the match expression.
-
-```rust,ignore
-let opt = Some(42);
-
-match opt {
-    Some(x) if let Some(y) = Some(x + 1) => {
-        // Both `x` and `y` are available in this arm,
-        // since the pattern matched and the guard evaluated to true.
-        println!("x = {}, y = {}", x, y);
-    }
-    _ => {
-        // `y` is not available here --- it was only bound inside the guard above.
-        // Uncommenting the line below will cause a compile-time error:
-        // println!("{}", y); // error: cannot find value `y` in this scope
+```rust
+# let value = Some(2)
+# fn process(x: i32) -> Result<i32, String> {
+#       Ok(x + 2)
+# }
+#
+match value {
+    Some(x) if let Ok(y) = process(x) => {
+//       ^                         ^
+//       |                         |
+//       |                         +-- `y` bound in if-let guard
+//       +-- `x` bound in match arm pattern
+//
+//      Both `x` and `y` are available here
+        println!("Processed {} into {}", x, y);
     }
+    _ => {}
 }
-
-// Outside the match expression, neither `x` nor `y` are in scope.
 ```
 
-* The outer pattern variables (`x`) follow the same borrowing behavior as in standard match guards (see below).
-
-r[expr.match.if.let.guard.drop]
-
-* Variables bound inside `if let` guards are dropped before evaluating subsequent match arms.
-
-* Temporaries created during guard evaluation follow standard drop semantics and are cleaned up appropriately.
+r[expr.match.if.let.guard.scope]
 
-r[expr.match.if.let.guard.borrowing]
-Variables bound by the outer pattern follow the same borrowing rules as standard match guards:
-* A shared reference is taken to pattern variables before guard evaluation
-* Values are moved or copied only when the guard succeeds
-* Moving from outer pattern variables within the guard is restricted
+For detailed information about variable scope and drop behavior, see the [scope and drop section](../destructors.md#If-Let-Guards-in-Match-Expressions).
 
 ```rust,ignore
-fn take<T>(value: T) -> Option<T> { Some(value) }
+# fn take<T>(value: T) -> Option<T> { Some(value) }
 
 let val = Some(vec![1, 2, 3]);
 match val {
@@ -236,7 +224,7 @@ match val {
 ```
 > [!NOTE]
 > Multiple matches using the `|` operator can cause the pattern guard and the side effects it has to execute multiple times. For example:
-> ```rust,ignore
+> ```rust
 > use std::cell::Cell;
 >
 > let i: Cell<i32> = Cell::new(0);