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

Author: Kivooeo

src/destructors.md

@@ -126,6 +126,15 @@ r[destructors.scope.nesting.match-arm]
 * The parent of the expression after the `=>` in a `match` expression is the
   scope of the arm that it's in.
 
+r[destructors.scope.nesting.match-guard-pattern]
+* The parent of an `if let` guard pattern is the scope of the guard expression.
+
+r[destructors.scope.nesting.match-guard-bindings]
+* Variables bound by `if let` guard patterns have their drop scope determined by
+  guard success:
+  - On guard failure: dropped immediately after guard evaluation
+  - On guard success: scope extends to the end of the match arm body
+
 r[destructors.scope.nesting.match]
 * The parent of the arm scope is the scope of the `match` expression that it
   belongs to.
@@ -204,8 +213,8 @@ smallest scope that contains the expression and is one of the following:
 * A statement.
 * The body of an [`if`], [`while`] or [`loop`] expression.
 * The `else` block of an `if` expression.
-* The non-pattern matching condition expression of an `if` or `while` expression,
-  or a `match` guard.
+* The condition expression of an `if` or `while` expression.
+* A `match` guard expression, including `if let` guard patterns.
 * The body expression for a match arm.
 * Each operand of a [lazy boolean expression].
 * The pattern-matching condition(s) and consequent body of [`if`] ([destructors.scope.temporary.edition2024]).
@@ -415,6 +424,58 @@ let x = (&temp()).use_temp();  // ERROR
 # x;
 ```
 
+r[destructors.scope.match-guards]
+### Match Guards and Pattern Binding
+
+r[destructors.scope.match-guards.basic]
+Match guard expressions create their own temporary scope. Variables bound within
+guard patterns have conditional drop scopes based on guard evaluation results.
+
+r[destructors.scope.match-guards.if-let]
+For `if let` guards specifically:
+
+1. **Guard pattern evaluation**: The `if let` pattern is evaluated within the
+   guard's temporary scope.
+2. **Conditional binding scope**:
+   - If the pattern matches, bound variables extend their scope to the match arm body
+   - If the pattern fails, bound variables are dropped immediately
+3. **Temporary cleanup**: Temporaries created during guard evaluation are dropped
+   when the guard scope ends, regardless of pattern match success.
+
+r[destructors.scope.match-guards.multiple]
+For multiple guards connected by `&&`:
+- Each guard maintains its own temporary scope
+- Failed guards drop their bindings before subsequent guard evaluation
+- Only successful guard bindings are available in the arm body
+- Guards are evaluated left-to-right with short-circuit semantics
+
+```rust
+# struct PrintOnDrop(&'static str);
+# impl Drop for PrintOnDrop {
+#     fn drop(&mut self) {
+#         println!("drop({})", self.0);
+#     }
+# }
+# fn expensive_operation(x: i32) -> Option<PrintOnDrop> {
+#     Some(PrintOnDrop("expensive result"))
+# }
+
+match Some(42) {
+    // Guard creates temporary scope for pattern evaluation
+    Some(x) if let Some(y) = expensive_operation(x) => {
+        // Both x (from main pattern) and y (from guard) are live
+        // y will be dropped at end of this arm
+        println!("Success case");
+    } // y dropped here
+    Some(x) => {
+        // If guard failed, y was already dropped during guard evaluation
+        // expensive_operation result was also dropped
+        println!("Guard failed case");
+    }
+    None => {}
+}
+```
+
 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].
 
 ```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);
@@ -268,3 +256,4 @@ r[expr.match.attributes.inner]
 [Range Pattern]: ../patterns.md#range-patterns
 [scrutinee]: ../glossary.md#scrutinee
 [value expression]: ../expressions.md#place-expressions-and-value-expressions
+[scope and drop section]: ../destructors.md#match-guards-and-pattern-binding