hir-ty: simplify unused_must_use container walk per review

  Address ChayimFriedman2 review feedback on #22405:

  * Push directly to self.diagnostics rather than threading a
    &mut Vec parameter through the recursion.  Drops the
    check_unused_must_use / collect_unused_must_use split and the
    allocation in the thin wrapper.

  * Replace the recursive single-tail-chain walk (Block/Unsafe/Const)
    with a loop that reassigns expr until reaching a non-chain leaf.
    Branching containers (If/Match) still recurse since they have
    multiple arms.

  The borrow checker required hoisting the Statement::Expr pass
  out of the main loop in validate_block, since MatchCheckCtx
  holds &self.infcx and the must_use pass now needs &mut self.
  The two passes are independent (must_use on expression
  statements, non_exhaustive_let on let statements) so order is
  free.

  19 unused_must_use tests + 981 hir-ty tests + 693
  ide-diagnostics tests pass.

Signed-off-by: Onyeka Obi <softwareengineerasaservant@isurvivable.cv>

Author: MavenRain

crates/hir-ty/src/diagnostics/expr.rs

@@ -330,21 +330,21 @@ impl<'db> ExprValidator<'db> {
         let (Expr::Block { statements, .. } | Expr::Unsafe { statements, .. }) = expr else {
             return;
         };
+        if self.validate_lints {
+            for stmt in &**statements {
+                if let Statement::Expr { expr: stmt_expr, has_semi: true } = *stmt {
+                    self.check_unused_must_use(stmt_expr);
+                }
+            }
+        }
         let pattern_arena = Arena::new();
         let cx = MatchCheckCtx::new(self.owner.module(self.db()), &self.infcx, self.env);
         for stmt in &**statements {
-            match *stmt {
-                Statement::Expr { expr: stmt_expr, has_semi: true } if self.validate_lints => {
-                    self.diagnostics.extend(self.check_unused_must_use(stmt_expr));
-                }
-                Statement::Let { pat, initializer, else_branch: None, .. } => {
-                    if let Some(diag) =
-                        self.check_non_exhaustive_let(&cx, &pattern_arena, pat, initializer)
-                    {
-                        self.diagnostics.push(diag);
-                    }
-                }
-                _ => {}
+            if let Statement::Let { pat, initializer, else_branch: None, .. } = *stmt
+                && let Some(diag) =
+                    self.check_non_exhaustive_let(&cx, &pattern_arena, pat, initializer)
+            {
+                self.diagnostics.push(diag);
             }
         }
     }
@@ -416,43 +416,31 @@ impl<'db> ExprValidator<'db> {
         pattern
     }
 
-    fn check_unused_must_use(&self, expr: ExprId) -> Vec<BodyValidationDiagnostic<'db>> {
-        let mut diags = Vec::new();
-        self.collect_unused_must_use(expr, &mut diags);
-        diags
-    }
-
-    fn collect_unused_must_use(
-        &self,
-        expr: ExprId,
-        diags: &mut Vec<BodyValidationDiagnostic<'db>>,
-    ) {
+    fn check_unused_must_use(&mut self, mut expr: ExprId) {
         // Walk through container expressions so that the value-producing leaf is
         // checked even when wrapped in a block, `unsafe { .. }`, `if`/`match`, or
-        // a `const { .. }` block.
-        match &self.body[expr] {
-            Expr::Block { tail: Some(tail), .. } | Expr::Unsafe { tail: Some(tail), .. } => {
-                self.collect_unused_must_use(*tail, diags);
-                return;
-            }
-            Expr::If { then_branch, else_branch, .. } => {
-                self.collect_unused_must_use(*then_branch, diags);
-                if let Some(else_branch) = else_branch {
-                    self.collect_unused_must_use(*else_branch, diags);
+        // a `const { .. }` block.  Single-tail chains are followed by reassigning
+        // `expr`; branching containers (`if`/`match`) recurse on each arm.
+        loop {
+            match &self.body[expr] {
+                Expr::Block { tail: Some(tail), .. }
+                | Expr::Unsafe { tail: Some(tail), .. }
+                | Expr::Const(tail) => expr = *tail,
+                Expr::If { then_branch, else_branch, .. } => {
+                    self.check_unused_must_use(*then_branch);
+                    if let Some(else_branch) = else_branch {
+                        self.check_unused_must_use(*else_branch);
+                    }
+                    return;
                 }
-                return;
-            }
-            Expr::Match { arms, .. } => {
-                for arm in arms.iter() {
-                    self.collect_unused_must_use(arm.expr, diags);
+                Expr::Match { arms, .. } => {
+                    for arm in arms.iter() {
+                        self.check_unused_must_use(arm.expr);
+                    }
+                    return;
                 }
-                return;
-            }
-            Expr::Const(inner) => {
-                self.collect_unused_must_use(*inner, diags);
-                return;
+                _ => break,
             }
-            _ => {}
         }
 
         let fn_def = match &self.body[expr] {
@@ -480,7 +468,7 @@ impl<'db> ExprValidator<'db> {
                 .map(|message| BodyValidationDiagnostic::UnusedMustUse { expr, message })
         };
         if let Some(diag) = must_use_diag(fn_def).or_else(|| must_use_diag(ty_def)) {
-            diags.push(diag);
+            self.diagnostics.push(diag);
         }
     }