hir-ty: walk container exprs for unused_must_use

ExprValidator::check_unused_must_use previously matched only Expr::Call
and Expr::MethodCall directly on the expression of a Statement::Expr
with semicolon.  This left several stmt-with-semi cases unwarned:
blocks whose tail is a #[must_use] call (`{ produces() };`),
unsafe-blocks (`unsafe { produces() };`), if/else arms, match arms,
and const blocks.

Refactors check_unused_must_use into a recursive collector that walks
into Expr::Block { tail, .. }, Expr::Unsafe { tail, .. },
Expr::If { then_branch, else_branch, .. }, Expr::Match { arms, .. },
and Expr::Const(inner) before applying the existing leaf check (callee
or method #[must_use] attribute, or #[must_use] ADT return type).
The diagnostic stays at the leaf call so the span points to the actual
must_use producer rather than the wrapping block.

Adds ide-diagnostics tests covering each new container case (block
tail, unsafe block tail, nested blocks, if/else branches, match arms,
const block, #[must_use] ADT through a block) and lock-in tests
confirming that the existing RustcLint plumbing already honors
#[allow(unused_must_use)], #[allow(unused)], and
#[deny(unused_must_use)] attribute resolution.

Follow-up to #22239.

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

Author: MavenRain

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

@@ -333,17 +333,18 @@ impl<'db> ExprValidator<'db> {
         let pattern_arena = Arena::new();
         let cx = MatchCheckCtx::new(self.owner.module(self.db()), &self.infcx, self.env);
         for stmt in &**statements {
-            let diag = match *stmt {
+            match *stmt {
                 Statement::Expr { expr: stmt_expr, has_semi: true } if self.validate_lints => {
-                    self.check_unused_must_use(stmt_expr)
+                    self.diagnostics.extend(self.check_unused_must_use(stmt_expr));
                 }
                 Statement::Let { pat, initializer, else_branch: None, .. } => {
-                    self.check_non_exhaustive_let(&cx, &pattern_arena, pat, initializer)
+                    if let Some(diag) =
+                        self.check_non_exhaustive_let(&cx, &pattern_arena, pat, initializer)
+                    {
+                        self.diagnostics.push(diag);
+                    }
                 }
-                _ => None,
-            };
-            if let Some(diag) = diag {
-                self.diagnostics.push(diag);
+                _ => {}
             }
         }
     }
@@ -415,7 +416,45 @@ impl<'db> ExprValidator<'db> {
         pattern
     }
 
-    fn check_unused_must_use(&self, expr: ExprId) -> Option<BodyValidationDiagnostic<'db>> {
+    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>>,
+    ) {
+        // 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);
+                }
+                return;
+            }
+            Expr::Match { arms, .. } => {
+                for arm in arms.iter() {
+                    self.collect_unused_must_use(arm.expr, diags);
+                }
+                return;
+            }
+            Expr::Const(inner) => {
+                self.collect_unused_must_use(*inner, diags);
+                return;
+            }
+            _ => {}
+        }
+
         let fn_def = match &self.body[expr] {
             Expr::Call { callee, .. } => {
                 let callee_ty = self.infer.expr_ty(*callee);
@@ -430,7 +469,7 @@ impl<'db> ExprValidator<'db> {
             Expr::MethodCall { .. } => {
                 self.infer.method_resolution(expr).map(|(func, _)| func.into())
             }
-            _ => return None,
+            _ => None,
         };
         let ty_def = self.infer.type_of_expr_with_adjust(expr).and_then(|ty| match ty.kind() {
             TyKind::Adt(adt, _) => Some(adt.def_id().into()),
@@ -440,7 +479,9 @@ impl<'db> ExprValidator<'db> {
             AttrFlags::must_use_message(self.db(), owner?)
                 .map(|message| BodyValidationDiagnostic::UnusedMustUse { expr, message })
         };
-        must_use_diag(fn_def).or_else(|| must_use_diag(ty_def))
+        if let Some(diag) = must_use_diag(fn_def).or_else(|| must_use_diag(ty_def)) {
+            diags.push(diag);
+        }
     }
 
     fn check_for_trailing_return(&mut self, body_expr: ExprId, body: &Body) {

crates/ide-diagnostics/src/handlers/unused_must_use.rs

@@ -126,6 +126,198 @@ fn main() {
     x = produces();
     let _ = x;
 }
+"#,
+        );
+    }
+
+    #[test]
+    fn block_tail_expression_in_stmt_position() {
+        check_diagnostics(
+            r#"
+#[must_use]
+fn produces() -> i32 { 0 }
+fn main() {
+    {
+        produces()
+      //^^^^^^^^^^ warn: unused return value that must be used
+    };
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn unsafe_block_tail_expression_in_stmt_position() {
+        check_diagnostics(
+            r#"
+#[must_use]
+unsafe fn produces() -> i32 { 0 }
+fn main() {
+    unsafe {
+        produces()
+      //^^^^^^^^^^ warn: unused return value that must be used
+    };
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn nested_block_tail_expression() {
+        check_diagnostics(
+            r#"
+#[must_use]
+fn produces() -> i32 { 0 }
+fn main() {
+    {
+        {
+            produces()
+          //^^^^^^^^^^ warn: unused return value that must be used
+        }
+    };
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn no_warning_when_block_tail_is_bound() {
+        check_diagnostics(
+            r#"
+#[must_use]
+fn produces() -> i32 { 0 }
+fn main() {
+    let _x = {
+        produces()
+    };
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn if_branches_in_stmt_position() {
+        check_diagnostics(
+            r#"
+#[must_use]
+fn produces() -> i32 { 0 }
+fn main() {
+    if true {
+        produces()
+      //^^^^^^^^^^ warn: unused return value that must be used
+    } else {
+        produces()
+      //^^^^^^^^^^ warn: unused return value that must be used
+    };
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn match_arms_in_stmt_position() {
+        check_diagnostics(
+            r#"
+#[must_use]
+fn produces() -> i32 { 0 }
+fn main() {
+    match 0 {
+        0 => produces(),
+           //^^^^^^^^^^ warn: unused return value that must be used
+        _ => produces(),
+           //^^^^^^^^^^ warn: unused return value that must be used
+    };
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn const_block_in_stmt_position() {
+        check_diagnostics(
+            r#"
+#[must_use]
+const fn produces() -> i32 { 0 }
+fn main() {
+    const {
+        produces()
+      //^^^^^^^^^^ warn: unused return value that must be used
+    };
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn must_use_type_through_block() {
+        check_diagnostics(
+            r#"
+#[must_use]
+struct Important;
+fn produces() -> Important { Important }
+fn main() {
+    {
+        produces()
+      //^^^^^^^^^^ warn: unused return value that must be used
+    };
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn allow_attribute_on_fn_silences_lint() {
+        check_diagnostics(
+            r#"
+#[must_use]
+fn produces() -> i32 { 0 }
+#[allow(unused_must_use)]
+fn main() {
+    produces();
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn allow_attribute_on_stmt_silences_lint() {
+        check_diagnostics(
+            r#"
+#[must_use]
+fn produces() -> i32 { 0 }
+fn main() {
+    #[allow(unused_must_use)]
+    produces();
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn allow_unused_group_silences_lint() {
+        check_diagnostics(
+            r#"
+#[must_use]
+fn produces() -> i32 { 0 }
+#[allow(unused)]
+fn main() {
+    produces();
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn deny_attribute_escalates_lint() {
+        check_diagnostics(
+            r#"
+#[must_use]
+fn produces() -> i32 { 0 }
+#[deny(unused_must_use)]
+fn main() {
+    produces();
+  //^^^^^^^^^^ error: unused return value that must be used
+}
 "#,
         );
     }