Improve error message for assert!() macro in functions returning bool

When assert!() is used in a function that returns a value, the compiler
emits a confusing error message suggesting the if expression is missing
an else clause. This commit detects when the if expression comes from
an assert!() or debug_assert!() macro expansion and provides a clearer
error message explaining that assert!() does not return a value.

Author: enthropy7

compiler/rustc_hir_typeck/src/_match.rs

@@ -4,7 +4,7 @@ use rustc_hir::def_id::LocalDefId;
 use rustc_hir::{self as hir, ExprKind, HirId, PatKind};
 use rustc_hir_pretty::ty_to_string;
 use rustc_middle::ty::{self, Ty};
-use rustc_span::Span;
+use rustc_span::{Span, sym};
 use rustc_trait_selection::traits::{
     MatchExpressionArmCause, ObligationCause, ObligationCauseCode,
 };
@@ -291,6 +291,25 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         error
     }
 
+    /// Check if the span comes from an assert-like macro expansion.
+    fn is_from_assert_macro(&self, span: Span) -> bool {
+        span.ctxt().outer_expn_data().macro_def_id.is_some_and(|def_id| {
+            if let Some(name) = self.tcx.get_diagnostic_name(def_id) {
+                matches!(
+                    name,
+                    sym::assert_macro
+                        | sym::debug_assert_macro
+                        | sym::assert_eq_macro
+                        | sym::assert_ne_macro
+                        | sym::debug_assert_eq_macro
+                        | sym::debug_assert_ne_macro
+                )
+            } else {
+                false
+            }
+        })
+    }
+
     /// Explain why `if` expressions without `else` evaluate to `()` and detect likely irrefutable
     /// `if let PAT = EXPR {}` expressions that could be turned into `let PAT = EXPR;`.
     fn explain_if_expr(
@@ -302,15 +321,22 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         then_expr: &'tcx hir::Expr<'tcx>,
         error: &mut bool,
     ) {
+        let is_assert_macro = self.is_from_assert_macro(if_span);
+
         if let Some((if_span, msg)) = ret_reason {
             err.span_label(if_span, msg);
         } else if let ExprKind::Block(block, _) = then_expr.kind
             && let Some(expr) = block.expr
         {
             err.span_label(expr.span, "found here");
         }
-        err.note("`if` expressions without `else` evaluate to `()`");
-        err.help("consider adding an `else` block that evaluates to the expected type");
+
+        if is_assert_macro {
+            err.primary_message("mismatched types");
+        } else {
+            err.note("`if` expressions without `else` evaluate to `()`");
+            err.help("consider adding an `else` block that evaluates to the expected type");
+        }
         *error = true;
         if let ExprKind::Let(hir::LetExpr { span, pat, init, .. }) = cond_expr.kind
             && let ExprKind::Block(block, _) = then_expr.kind

tests/ui/expr/if/assert-macro-without-else.rs

@@ -0,0 +1,34 @@
+//@ dont-require-annotations: NOTE
+
+fn f() -> bool {
+    assert!(1 < 2)
+    //~^ ERROR mismatched types [E0317]
+}
+
+fn g() -> i32 {
+    assert_eq!(1, 1)
+    //~^ ERROR mismatched types [E0317]
+}
+
+fn h() -> bool {
+    assert_ne!(1, 2)
+    //~^ ERROR mismatched types [E0317]
+}
+
+// Test nested macros
+macro_rules! g {
+    () => {
+        f!()
+    };
+}
+macro_rules! f {
+    () => {
+        assert!(1 < 2)
+        //~^ ERROR mismatched types [E0317]
+    };
+}
+fn nested() -> bool {
+    g!()
+}
+
+fn main() {}

tests/ui/expr/if/assert-macro-without-else.stderr

@@ -0,0 +1,40 @@
+error[E0317]: mismatched types
+  --> $DIR/assert-macro-without-else.rs:4:5
+   |
+LL | fn f() -> bool {
+   |           ---- expected `bool` because of this return type
+LL |     assert!(1 < 2)
+   |     ^^^^^^^^^^^^^^ expected `bool`, found `()`
+
+error[E0317]: mismatched types
+  --> $DIR/assert-macro-without-else.rs:9:5
+   |
+LL |     assert_eq!(1, 1)
+   |     ^^^^^^^^^^^^^^^^ expected `i32`, found `()`
+   |
+   = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0317]: mismatched types
+  --> $DIR/assert-macro-without-else.rs:14:5
+   |
+LL |     assert_ne!(1, 2)
+   |     ^^^^^^^^^^^^^^^^ expected `bool`, found `()`
+   |
+   = note: this error originates in the macro `assert_ne` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0317]: mismatched types
+  --> $DIR/assert-macro-without-else.rs:26:9
+   |
+LL |         assert!(1 < 2)
+   |         ^^^^^^^^^^^^^^ expected `bool`, found `()`
+...
+LL | fn nested() -> bool {
+   |                ---- expected `bool` because of this return type
+LL |     g!()
+   |     ---- in this macro invocation
+   |
+   = note: this error originates in the macro `assert` which comes from the expansion of the macro `g` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0317`.