Use if <cond> {} else { <then> } instead of if !<cond> { <then> }

This approach works on *every* edition and emits the desired output consistently:

```
error[E0308]: mismatched types
  --> $DIR/issue-28308.rs:6:13
   |
LL |     assert!("foo");
   |             ^^^^^ expected `bool`, found `&str`
```

Author: estebank

compiler/rustc_builtin_macros/src/assert.rs

@@ -1,15 +1,14 @@
 mod context;
 
 use rustc_ast::ptr::P;
-use rustc_ast::token::Delimiter;
+use rustc_ast::token::{self, Delimiter};
 use rustc_ast::tokenstream::{DelimSpan, TokenStream};
-use rustc_ast::{self as ast, DelimArgs, Expr, ExprKind, MacCall, Path, PathSegment, UnOp, token};
+use rustc_ast::{DelimArgs, Expr, ExprKind, MacCall, Path, PathSegment};
 use rustc_ast_pretty::pprust;
 use rustc_errors::PResult;
 use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacEager, MacroExpanderResult};
 use rustc_parse::exp;
 use rustc_parse::parser::Parser;
-use rustc_span::edition::Edition;
 use rustc_span::{DUMMY_SP, Ident, Span, Symbol, sym};
 use thin_vec::thin_vec;
 
@@ -21,7 +20,7 @@ pub(crate) fn expand_assert<'cx>(
     span: Span,
     tts: TokenStream,
 ) -> MacroExpanderResult<'cx> {
-    let Assert { cond_expr, inner_cond_expr, custom_message } = match parse_assert(cx, span, tts) {
+    let Assert { cond_expr, custom_message } = match parse_assert(cx, span, tts) {
         Ok(assert) => assert,
         Err(err) => {
             let guar = err.emit();
@@ -31,7 +30,7 @@ pub(crate) fn expand_assert<'cx>(
 
     // `core::panic` and `std::panic` are different macros, so we use call-site
     // context to pick up whichever is currently in scope.
-    let call_site_span = cx.with_call_site_ctxt(span);
+    let call_site_span = cx.with_call_site_ctxt(cond_expr.span);
 
     let panic_path = || {
         if use_panic_2021(span) {
@@ -65,15 +64,15 @@ pub(crate) fn expand_assert<'cx>(
                 }),
             })),
         );
-        expr_if_not(cx, call_site_span, cond_expr, then, None)
+        expr_if_not(cx, call_site_span, cond_expr, then)
     }
     // If `generic_assert` is enabled, generates rich captured outputs
     //
     // FIXME(c410-f3r) See https://github.com/rust-lang/rust/issues/96949
     else if cx.ecfg.features.generic_assert() {
         // FIXME(estebank): we use the condition the user passed without coercing to `bool` when
         // `generic_assert` is enabled, but we could use `cond_expr` instead.
-        context::Context::new(cx, call_site_span).build(inner_cond_expr, panic_path())
+        context::Context::new(cx, call_site_span).build(cond_expr, panic_path())
     }
     // If `generic_assert` is not enabled, only outputs a literal "assertion failed: ..."
     // string
@@ -88,34 +87,29 @@ pub(crate) fn expand_assert<'cx>(
                 DUMMY_SP,
                 Symbol::intern(&format!(
                     "assertion failed: {}",
-                    pprust::expr_to_string(&inner_cond_expr)
+                    pprust::expr_to_string(&cond_expr)
                 )),
             )],
         );
-        expr_if_not(cx, call_site_span, cond_expr, then, None)
+        expr_if_not(cx, call_site_span, cond_expr, then)
     };
 
     ExpandResult::Ready(MacEager::expr(expr))
 }
 
-// `assert!($cond_expr, $custom_message)`
+/// `assert!($cond_expr, $custom_message)`
 struct Assert {
-    // `{ let assert_macro: bool = $cond_expr; assert_macro }`
     cond_expr: P<Expr>,
-    // We keep the condition without the `bool` coercion for the panic message.
-    inner_cond_expr: P<Expr>,
     custom_message: Option<TokenStream>,
 }
 
-// if !{ ... } { ... } else { ... }
-fn expr_if_not(
-    cx: &ExtCtxt<'_>,
-    span: Span,
-    cond: P<Expr>,
-    then: P<Expr>,
-    els: Option<P<Expr>>,
-) -> P<Expr> {
-    cx.expr_if(span, cx.expr(span, ExprKind::Unary(UnOp::Not, cond)), then, els)
+/// `if !{ ... } { ... }`
+fn expr_if_not(cx: &ExtCtxt<'_>, span: Span, cond: P<Expr>, then: P<Expr>) -> P<Expr> {
+    // Instead of expanding to `if !<cond> { <then> }`, we expand to `if <cond> {} else { <then> }`.
+    // This allows us to always complain about mismatched types instead of "cannot apply unary
+    // operator `!` to type `X`" when passing an invalid `<cond>`.
+    let els = cx.expr_block(cx.block(span, thin_vec![]));
+    cx.expr_if(span, cond, els, Some(then))
 }
 
 fn parse_assert<'a>(cx: &ExtCtxt<'a>, sp: Span, stream: TokenStream) -> PResult<'a, Assert> {
@@ -125,7 +119,7 @@ fn parse_assert<'a>(cx: &ExtCtxt<'a>, sp: Span, stream: TokenStream) -> PResult<
         return Err(cx.dcx().create_err(errors::AssertRequiresBoolean { span: sp }));
     }
 
-    let inner_cond_expr = parser.parse_expr()?;
+    let cond_expr = parser.parse_expr()?;
 
     // Some crates use the `assert!` macro in the following form (note extra semicolon):
     //
@@ -161,66 +155,10 @@ fn parse_assert<'a>(cx: &ExtCtxt<'a>, sp: Span, stream: TokenStream) -> PResult<
         parser.unexpected()?;
     }
 
-    let cond_expr = expand_cond(cx, parser, inner_cond_expr.clone());
-    Ok(Assert { cond_expr, inner_cond_expr, custom_message })
-}
-
-fn expand_cond(cx: &ExtCtxt<'_>, parser: Parser<'_>, cond_expr: P<Expr>) -> P<Expr> {
-    let span = cx.with_call_site_ctxt(cond_expr.span);
-    // Coerce the expression to `bool` for more accurate errors. If `assert!` is passed an
-    // expression that isn't `bool`, the type error will point at only the expression and not the
-    // entire macro call. If a non-`bool` is passed that doesn't implement `trait Not`, we won't
-    // talk about traits, we'll just state the appropriate type error.
-    // `let assert_macro: bool = $expr;`
-    let ident = Ident::new(sym::assert_macro, DUMMY_SP);
-
-    let expr = if use_assert_2024(span) {
-        // `{ let assert_macro: bool = $expr; assert_macro }`
-        cond_expr
-    } else {
-        // In <=2021, we allow anything that can be negated to `bool`, not just `bool`s. We use the
-        // "double not" trick to coerce the expression to `bool`. We still assign it to a new `bool`
-        // binding so that in the case of a type that implements `Not` but doesn't return `bool`,
-        // like `i32`, we still point at the condition and not at the whole macro.
-        // `{ let assert_macro: bool = !!$expr; assert_macro }`
-        let not = |expr| parser.mk_expr(span, ast::ExprKind::Unary(ast::UnOp::Not, expr));
-        not(not(cond_expr))
-    };
-    let block = thin_vec![
-        cx.stmt_let_ty(
-            DUMMY_SP,
-            false,
-            ident,
-            Some(cx.ty_ident(span, Ident::new(sym::bool, DUMMY_SP))),
-            expr,
-        ),
-        parser.mk_stmt(
-            span,
-            ast::StmtKind::Expr(
-                parser.mk_expr(span, ast::ExprKind::Path(None, ast::Path::from_ident(ident)))
-            ),
-        ),
-    ];
-    parser.mk_expr(
-        span,
-        ast::ExprKind::Block(parser.mk_block(block, ast::BlockCheckMode::Default, span), None),
-    )
+    Ok(Assert { cond_expr, custom_message })
 }
 
 fn parse_custom_message(parser: &mut Parser<'_>) -> Option<TokenStream> {
     let ts = parser.parse_tokens();
     if !ts.is_empty() { Some(ts) } else { None }
 }
-
-pub(crate) fn use_assert_2024(mut span: Span) -> bool {
-    // To determine the edition, we check the first span up the expansion
-    // stack that isn't internal.
-    loop {
-        let expn = span.ctxt().outer_expn_data();
-        if let Some(_features) = expn.allow_internal_unstable {
-            span = expn.call_site;
-            continue;
-        }
-        break expn.edition >= Edition::Edition2024;
-    }
-}

tests/coverage/assert_not.cov-map

@@ -1,13 +1,22 @@
 Function name: assert_not::main
-Raw bytes (29): 0x[01, 01, 00, 05, 01, 06, 01, 01, 12, 05, 02, 05, 00, 14, 09, 01, 05, 00, 14, 0d, 01, 05, 00, 16, 11, 01, 01, 00, 02]
+Raw bytes (58): 0x[01, 01, 02, 05, 00, 0d, 00, 0a, 01, 06, 01, 00, 0b, 05, 01, 05, 00, 0c, 01, 00, 0d, 00, 11, 00, 01, 05, 00, 0c, 05, 00, 0d, 00, 13, 0d, 01, 05, 00, 0c, 02, 00, 0d, 00, 13, 00, 01, 05, 00, 0c, 0d, 00, 0d, 00, 15, 06, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
-Number of expressions: 0
-Number of file 0 mappings: 5
-- Code(Counter(0)) at (prev + 6, 1) to (start + 1, 18)
-- Code(Counter(1)) at (prev + 2, 5) to (start + 0, 20)
-- Code(Counter(2)) at (prev + 1, 5) to (start + 0, 20)
-- Code(Counter(3)) at (prev + 1, 5) to (start + 0, 22)
-- Code(Counter(4)) at (prev + 1, 1) to (start + 0, 2)
-Highest counter ID seen: c4
+Number of expressions: 2
+- expression 0 operands: lhs = Counter(1), rhs = Zero
+- expression 1 operands: lhs = Counter(3), rhs = Zero
+Number of file 0 mappings: 10
+- Code(Counter(0)) at (prev + 6, 1) to (start + 0, 11)
+- Code(Counter(1)) at (prev + 1, 5) to (start + 0, 12)
+- Code(Counter(0)) at (prev + 0, 13) to (start + 0, 17)
+- Code(Zero) at (prev + 1, 5) to (start + 0, 12)
+- Code(Counter(1)) at (prev + 0, 13) to (start + 0, 19)
+- Code(Counter(3)) at (prev + 1, 5) to (start + 0, 12)
+- Code(Expression(0, Sub)) at (prev + 0, 13) to (start + 0, 19)
+    = (c1 - Zero)
+- Code(Zero) at (prev + 1, 5) to (start + 0, 12)
+- Code(Counter(3)) at (prev + 0, 13) to (start + 0, 21)
+- Code(Expression(1, Sub)) at (prev + 1, 1) to (start + 0, 2)
+    = (c3 - Zero)
+Highest counter ID seen: c3
 

tests/ui/codemap_tests/issue-28308.edition2021.stderr

@@ -1,11 +1,9 @@
-error[E0600]: cannot apply unary operator `!` to type `&'static str`
+error[E0308]: mismatched types
   --> $DIR/issue-28308.rs:6:13
    |
 LL |     assert!("foo");
-   |             ^^^^^ cannot apply unary operator `!`
-   |
-   = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
+   |             ^^^^^ expected `bool`, found `&str`
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0600`.
+For more information about this error, try `rustc --explain E0308`.

tests/ui/codemap_tests/issue-28308.rs

@@ -5,5 +5,5 @@
 fn main() {
     assert!("foo");
     //[edition2024]~^ ERROR mismatched types
-    //[edition2021]~^^ ERROR cannot apply unary operator `!` to type `&'static str`
+    //[edition2021]~^^ ERROR mismatched types
 }

tests/ui/consts/control-flow/assert.stderr

@@ -1,8 +1,8 @@
 error[E0080]: evaluation of constant value failed
-  --> $DIR/assert.rs:5:15
+  --> $DIR/assert.rs:5:23
    |
 LL | const _: () = assert!(false);
-   |               ^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: false', $DIR/assert.rs:5:15
+   |                       ^^^^^ the evaluated program panicked at 'assertion failed: false', $DIR/assert.rs:5:15
    |
    = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 

tests/ui/generics/post_monomorphization_error_backtrace.stderr

@@ -1,8 +1,8 @@
 error[E0080]: evaluation of `assert_zst::F::<u32>::V` failed
-  --> $DIR/post_monomorphization_error_backtrace.rs:6:23
+  --> $DIR/post_monomorphization_error_backtrace.rs:6:31
    |
 LL |         const V: () = assert!(std::mem::size_of::<T>() == 0);
-   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: std::mem::size_of::<T>() == 0', $DIR/post_monomorphization_error_backtrace.rs:6:23
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: std::mem::size_of::<T>() == 0', $DIR/post_monomorphization_error_backtrace.rs:6:23
    |
    = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -19,10 +19,10 @@ LL |     assert_zst::<U>()
    |     ^^^^^^^^^^^^^^^^^
 
 error[E0080]: evaluation of `assert_zst::F::<i32>::V` failed
-  --> $DIR/post_monomorphization_error_backtrace.rs:6:23
+  --> $DIR/post_monomorphization_error_backtrace.rs:6:31
    |
 LL |         const V: () = assert!(std::mem::size_of::<T>() == 0);
-   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: std::mem::size_of::<T>() == 0', $DIR/post_monomorphization_error_backtrace.rs:6:23
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: std::mem::size_of::<T>() == 0', $DIR/post_monomorphization_error_backtrace.rs:6:23
    |
    = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 

tests/ui/inline-const/const-expr-generic-err.stderr

@@ -1,8 +1,8 @@
 error[E0080]: evaluation of `foo::<i32>::{constant#0}` failed
-  --> $DIR/const-expr-generic-err.rs:4:13
+  --> $DIR/const-expr-generic-err.rs:4:21
    |
 LL |     const { assert!(std::mem::size_of::<T>() == 0); }
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: std::mem::size_of::<T>() == 0', $DIR/const-expr-generic-err.rs:4:13
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: std::mem::size_of::<T>() == 0', $DIR/const-expr-generic-err.rs:4:13
    |
    = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 

tests/ui/issues/issue-14091-2.rs

@@ -13,5 +13,5 @@ fn main() {
     let x = BytePos(1);
 
     assert!(x, x);
-    //~^ ERROR cannot apply unary operator `!` to type `BytePos`
+    //~^ ERROR mismatched types
 }

tests/ui/issues/issue-14091-2.stderr

@@ -1,18 +1,9 @@
-error[E0600]: cannot apply unary operator `!` to type `BytePos`
+error[E0308]: mismatched types
   --> $DIR/issue-14091-2.rs:15:13
    |
 LL |     assert!(x, x);
-   |             ^ cannot apply unary operator `!`
-   |
-note: an implementation of `Not` might be missing for `BytePos`
-  --> $DIR/issue-14091-2.rs:6:1
-   |
-LL | pub struct BytePos(pub u32);
-   | ^^^^^^^^^^^^^^^^^^ must implement `Not`
-note: the trait `Not` must be implemented
-  --> $SRC_DIR/core/src/ops/bit.rs:LL:COL
-   = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
+   |             ^ expected `bool`, found `BytePos`
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0600`.
+For more information about this error, try `rustc --explain E0308`.

tests/ui/issues/issue-14091.stderr

@@ -3,8 +3,6 @@ error[E0308]: mismatched types
    |
 LL |     assert!(1,1);
    |             ^ expected `bool`, found integer
-   |
-   = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 1 previous error