diff --git a/compiler/rustc_builtin_macros/src/assert.rs b/compiler/rustc_builtin_macros/src/assert.rs
index 35a0857fe51ce..62edb0d4d682f 100644
--- a/compiler/rustc_builtin_macros/src/assert.rs
+++ b/compiler/rustc_builtin_macros/src/assert.rs
@@ -3,9 +3,9 @@ mod context;
 use crate::edition_panic::use_panic_2021;
 use crate::errors;
 use rustc_ast::ptr::P;
-use rustc_ast::token;
 use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::{DelimSpan, TokenStream};
+use rustc_ast::{self as ast, token};
 use rustc_ast::{DelimArgs, Expr, ExprKind, MacCall, Path, PathSegment, UnOp};
 use rustc_ast_pretty::pprust;
 use rustc_errors::PResult;
@@ -20,7 +20,7 @@ pub fn expand_assert<'cx>(
     span: Span,
     tts: TokenStream,
 ) -> MacroExpanderResult<'cx> {
-    let Assert { cond_expr, custom_message } = match parse_assert(cx, span, tts) {
+    let Assert { cond_expr, inner_cond_expr, custom_message } = match parse_assert(cx, span, tts) {
         Ok(assert) => assert,
         Err(err) => {
             let guar = err.emit();
@@ -70,7 +70,9 @@ pub fn expand_assert<'cx>(
     //
     // FIXME(c410-f3r) See https://github.com/rust-lang/rust/issues/96949
     else if cx.ecfg.features.generic_assert {
-        context::Context::new(cx, call_site_span).build(cond_expr, panic_path())
+        // 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())
     }
     // If `generic_assert` is not enabled, only outputs a literal "assertion failed: ..."
     // string
@@ -85,7 +87,7 @@ pub fn expand_assert<'cx>(
                 DUMMY_SP,
                 Symbol::intern(&format!(
                     "assertion failed: {}",
-                    pprust::expr_to_string(&cond_expr)
+                    pprust::expr_to_string(&inner_cond_expr)
                 )),
             )],
         );
@@ -95,8 +97,12 @@ pub fn expand_assert<'cx>(
     ExpandResult::Ready(MacEager::expr(expr))
 }
 
+// `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>,
 }
 
@@ -118,7 +124,7 @@ fn parse_assert<'a>(cx: &mut ExtCtxt<'a>, sp: Span, stream: TokenStream) -> PRes
         return Err(cx.dcx().create_err(errors::AssertRequiresBoolean { span: sp }));
     }
 
-    let cond_expr = parser.parse_expr()?;
+    let inner_cond_expr = parser.parse_expr()?;
 
     // Some crates use the `assert!` macro in the following form (note extra semicolon):
     //
@@ -154,7 +160,54 @@ fn parse_assert<'a>(cx: &mut ExtCtxt<'a>, sp: Span, stream: TokenStream) -> PRes
         return parser.unexpected();
     }
 
-    Ok(Assert { cond_expr, custom_message })
+    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, span);
+    let local = P(ast::Local {
+        ty: Some(P(ast::Ty {
+            kind: ast::TyKind::Path(None, ast::Path::from_ident(Ident::new(sym::bool, span))),
+            id: ast::DUMMY_NODE_ID,
+            span,
+            tokens: None,
+        })),
+        pat: parser.mk_pat_ident(span, ast::BindingAnnotation::NONE, ident),
+        kind: ast::LocalKind::Init(cond_expr),
+        id: ast::DUMMY_NODE_ID,
+        span,
+        colon_sp: None,
+        attrs: Default::default(),
+        tokens: None,
+    });
+    // `{ let assert_macro: bool = $expr; assert_macro }``
+    parser.mk_expr(
+        span,
+        ast::ExprKind::Block(
+            parser.mk_block(
+                thin_vec![
+                    parser.mk_stmt(span, ast::StmtKind::Let(local)),
+                    parser.mk_stmt(
+                        span,
+                        ast::StmtKind::Expr(parser.mk_expr(
+                            span,
+                            ast::ExprKind::Path(None, ast::Path::from_ident(ident))
+                        )),
+                    ),
+                ],
+                ast::BlockCheckMode::Default,
+                span,
+            ),
+            None,
+        ),
+    )
 }
 
 fn parse_custom_message(parser: &mut Parser<'_>) -> Option<TokenStream> {
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index e27a5f937990e..22293f2d27887 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -3775,7 +3775,7 @@ impl<'a> Parser<'a> {
         P(Expr { kind, span, attrs, id: DUMMY_NODE_ID, tokens: None })
     }
 
-    pub(crate) fn mk_expr(&self, span: Span, kind: ExprKind) -> P<Expr> {
+    pub fn mk_expr(&self, span: Span, kind: ExprKind) -> P<Expr> {
         self.mk_expr_with_attrs(span, kind, AttrVec::new())
     }
 
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index 88ae1b5420fe7..613d9f777589e 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -1399,7 +1399,8 @@ impl<'a> Parser<'a> {
         })
     }
 
-    pub(super) fn mk_pat_ident(&self, span: Span, ann: BindingAnnotation, ident: Ident) -> P<Pat> {
+    // `pub` because we use it from `rustc_builtin_macros`.
+    pub fn mk_pat_ident(&self, span: Span, ann: BindingAnnotation, ident: Ident) -> P<Pat> {
         self.mk_pat(span, PatKind::Ident(ann, ident, None))
     }
 
diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
index fc907760531f7..35e81fa041097 100644
--- a/compiler/rustc_parse/src/parser/stmt.rs
+++ b/compiler/rustc_parse/src/parser/stmt.rs
@@ -833,12 +833,7 @@ impl<'a> Parser<'a> {
         Ok(Some(stmt))
     }
 
-    pub(super) fn mk_block(
-        &self,
-        stmts: ThinVec<Stmt>,
-        rules: BlockCheckMode,
-        span: Span,
-    ) -> P<Block> {
+    pub fn mk_block(&self, stmts: ThinVec<Stmt>, rules: BlockCheckMode, span: Span) -> P<Block> {
         P(Block {
             stmts,
             id: DUMMY_NODE_ID,
@@ -849,7 +844,7 @@ impl<'a> Parser<'a> {
         })
     }
 
-    pub(super) fn mk_stmt(&self, span: Span, kind: StmtKind) -> Stmt {
+    pub fn mk_stmt(&self, span: Span, kind: StmtKind) -> Stmt {
         Stmt { id: DUMMY_NODE_ID, kind, span }
     }
 
diff --git a/library/core/tests/bool.rs b/library/core/tests/bool.rs
index 47f6459915b3e..bcd6dc2abac6c 100644
--- a/library/core/tests/bool.rs
+++ b/library/core/tests/bool.rs
@@ -71,14 +71,14 @@ fn test_bool() {
 #[test]
 pub fn test_bool_not() {
     if !false {
-        assert!((true));
+        assert!(true);
     } else {
-        assert!((false));
+        assert!(false);
     }
     if !true {
-        assert!((false));
+        assert!(false);
     } else {
-        assert!((true));
+        assert!(true);
     }
 }
 
diff --git a/library/core/tests/ptr.rs b/library/core/tests/ptr.rs
index 659fbd255c168..29a7131144c9c 100644
--- a/library/core/tests/ptr.rs
+++ b/library/core/tests/ptr.rs
@@ -41,11 +41,11 @@ fn test() {
         let mut v1 = vec![0u16, 0u16, 0u16];
 
         copy(v0.as_ptr().offset(1), v1.as_mut_ptr().offset(1), 1);
-        assert!((v1[0] == 0u16 && v1[1] == 32001u16 && v1[2] == 0u16));
+        assert!(v1[0] == 0u16 && v1[1] == 32001u16 && v1[2] == 0u16);
         copy(v0.as_ptr().offset(2), v1.as_mut_ptr(), 1);
-        assert!((v1[0] == 32002u16 && v1[1] == 32001u16 && v1[2] == 0u16));
+        assert!(v1[0] == 32002u16 && v1[1] == 32001u16 && v1[2] == 0u16);
         copy(v0.as_ptr(), v1.as_mut_ptr().offset(2), 1);
-        assert!((v1[0] == 32002u16 && v1[1] == 32001u16 && v1[2] == 32000u16));
+        assert!(v1[0] == 32002u16 && v1[1] == 32001u16 && v1[2] == 32000u16);
     }
 }
 
diff --git a/library/std/src/env/tests.rs b/library/std/src/env/tests.rs
index fc7aee2973329..dfc17e807825d 100644
--- a/library/std/src/env/tests.rs
+++ b/library/std/src/env/tests.rs
@@ -13,7 +13,7 @@ fn test_self_exe_path() {
 
 #[test]
 fn test() {
-    assert!((!Path::new("test-path").is_absolute()));
+    assert!(!Path::new("test-path").is_absolute());
 
     #[cfg(not(target_env = "sgx"))]
     current_dir().unwrap();
diff --git a/src/tools/miri/tests/pass/binops.rs b/src/tools/miri/tests/pass/binops.rs
index 0988d7ccc4c6e..ea57e8973393e 100644
--- a/src/tools/miri/tests/pass/binops.rs
+++ b/src/tools/miri/tests/pass/binops.rs
@@ -2,23 +2,23 @@
 
 fn test_nil() {
     assert_eq!((), ());
-    assert!((!(() != ())));
-    assert!((!(() < ())));
-    assert!((() <= ()));
-    assert!((!(() > ())));
-    assert!((() >= ()));
+    assert!(!(() != ()));
+    assert!(!(() < ()));
+    assert!(() <= ());
+    assert!(!(() > ()));
+    assert!(() >= ());
 }
 
 fn test_bool() {
-    assert!((!(true < false)));
-    assert!((!(true <= false)));
-    assert!((true > false));
-    assert!((true >= false));
+    assert!(!(true < false));
+    assert!(!(true <= false));
+    assert!(true > false);
+    assert!(true >= false);
 
-    assert!((false < true));
-    assert!((false <= true));
-    assert!((!(false > true)));
-    assert!((!(false >= true)));
+    assert!(false < true);
+    assert!(false <= true);
+    assert!(!(false > true));
+    assert!(!(false >= true));
 
     // Bools support bitwise binops
     assert_eq!(false & false, false);
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/ok/0035_weird_exprs.rs b/src/tools/rust-analyzer/crates/parser/test_data/parser/ok/0035_weird_exprs.rs
index fb7d706b05b2a..361c1f3b6a452 100644
--- a/src/tools/rust-analyzer/crates/parser/test_data/parser/ok/0035_weird_exprs.rs
+++ b/src/tools/rust-analyzer/crates/parser/test_data/parser/ok/0035_weird_exprs.rs
@@ -64,8 +64,8 @@ fn notsure() {
 
 fn canttouchthis() -> usize {
     fn p() -> bool { true }
-    let _a = (assert!((true)) == (assert!(p())));
-    let _c = (assert!((p())) == ());
+    let _a = (assert!(true) == (assert!(p())));
+    let _c = (assert!(p()) == ());
     let _b: bool = (println!("{}", 0) == (return 0));
 }
 
diff --git a/tests/ui/binding/expr-match-generic.rs b/tests/ui/binding/expr-match-generic.rs
index 975eec42fd054..dcc069b9fb329 100644
--- a/tests/ui/binding/expr-match-generic.rs
+++ b/tests/ui/binding/expr-match-generic.rs
@@ -5,7 +5,7 @@ type compare<T> = extern "Rust" fn(T, T) -> bool;
 
 fn test_generic<T:Clone>(expected: T, eq: compare<T>) {
   let actual: T = match true { true => { expected.clone() }, _ => panic!("wat") };
-    assert!((eq(expected, actual)));
+    assert!(eq(expected, actual));
 }
 
 fn test_bool() {
diff --git a/tests/ui/binding/expr-match.rs b/tests/ui/binding/expr-match.rs
index 049beaaf51bf6..133995806634c 100644
--- a/tests/ui/binding/expr-match.rs
+++ b/tests/ui/binding/expr-match.rs
@@ -7,14 +7,14 @@
 
 fn test_basic() {
     let mut rs: bool = match true { true => { true } false => { false } };
-    assert!((rs));
+    assert!(rs);
     rs = match false { true => { false } false => { true } };
-    assert!((rs));
+    assert!(rs);
 }
 
 fn test_inferrence() {
     let rs = match true { true => { true } false => { false } };
-    assert!((rs));
+    assert!(rs);
 }
 
 fn test_alt_as_alt_head() {
@@ -25,7 +25,7 @@ fn test_alt_as_alt_head() {
           true => { false }
           false => { true }
         };
-    assert!((rs));
+    assert!(rs);
 }
 
 fn test_alt_as_block_result() {
@@ -34,7 +34,7 @@ fn test_alt_as_block_result() {
           true => { false }
           false => { match true { true => { true } false => { false } } }
         };
-    assert!((rs));
+    assert!(rs);
 }
 
 pub fn main() {
diff --git a/tests/ui/binop/binops.rs b/tests/ui/binop/binops.rs
index 0adbb49b14a37..7142190a45b9a 100644
--- a/tests/ui/binop/binops.rs
+++ b/tests/ui/binop/binops.rs
@@ -5,23 +5,23 @@
 
 fn test_nil() {
     assert_eq!((), ());
-    assert!((!(() != ())));
-    assert!((!(() < ())));
-    assert!((() <= ()));
-    assert!((!(() > ())));
-    assert!((() >= ()));
+    assert!(!(() != ()));
+    assert!(!(() < ()));
+    assert!(() <= ());
+    assert!(!(() > ()));
+    assert!(() >= ());
 }
 
 fn test_bool() {
-    assert!((!(true < false)));
-    assert!((!(true <= false)));
-    assert!((true > false));
-    assert!((true >= false));
+    assert!(!(true < false));
+    assert!(!(true <= false));
+    assert!(true > false);
+    assert!(true >= false);
 
-    assert!((false < true));
-    assert!((false <= true));
-    assert!((!(false > true)));
-    assert!((!(false >= true)));
+    assert!(false < true);
+    assert!(false <= true);
+    assert!(!(false > true));
+    assert!(!(false >= true));
 
     // Bools support bitwise binops
     assert_eq!(false & false, false);
@@ -76,9 +76,9 @@ fn test_class() {
   }
   assert_eq!(q, r);
   r.y = 17;
-  assert!((r.y != q.y));
+  assert!(r.y != q.y);
   assert_eq!(r.y, 17);
-  assert!((q != r));
+  assert!(q != r);
 }
 
 pub fn main() {
diff --git a/tests/ui/binop/structured-compare.rs b/tests/ui/binop/structured-compare.rs
index 164760cd7a040..7d1eff453028a 100644
--- a/tests/ui/binop/structured-compare.rs
+++ b/tests/ui/binop/structured-compare.rs
@@ -17,14 +17,14 @@ pub fn main() {
     let a = (1, 2, 3);
     let b = (1, 2, 3);
     assert_eq!(a, b);
-    assert!((a != (1, 2, 4)));
-    assert!((a < (1, 2, 4)));
-    assert!((a <= (1, 2, 4)));
-    assert!(((1, 2, 4) > a));
-    assert!(((1, 2, 4) >= a));
+    assert!(a != (1, 2, 4));
+    assert!(a < (1, 2, 4));
+    assert!(a <= (1, 2, 4));
+    assert!((1, 2, 4) > a);
+    assert!((1, 2, 4) >= a);
     let x = foo::large;
     let y = foo::small;
-    assert!((x != y));
+    assert!(x != y);
     assert_eq!(x, foo::large);
-    assert!((x != foo::small));
+    assert!(x != foo::small);
 }
diff --git a/tests/ui/cfg/conditional-compile.rs b/tests/ui/cfg/conditional-compile.rs
index f39663adda276..4d9a4d234aa88 100644
--- a/tests/ui/cfg/conditional-compile.rs
+++ b/tests/ui/cfg/conditional-compile.rs
@@ -85,7 +85,7 @@ pub fn main() {
 pub fn main() {
     // Exercise some of the configured items in ways that wouldn't be possible
     // if they had the bogus definition
-    assert!((b));
+    assert!(b);
     let _x: t = true;
     let _y: tg = tg::bar;
 
diff --git a/tests/ui/codemap_tests/issue-28308.rs b/tests/ui/codemap_tests/issue-28308.rs
index 81493f8c45311..3553c66ae16c4 100644
--- a/tests/ui/codemap_tests/issue-28308.rs
+++ b/tests/ui/codemap_tests/issue-28308.rs
@@ -1,4 +1,4 @@
 fn main() {
     assert!("foo");
-    //~^ ERROR cannot apply unary operator `!`
+    //~^ ERROR mismatched types
 }
diff --git a/tests/ui/codemap_tests/issue-28308.stderr b/tests/ui/codemap_tests/issue-28308.stderr
index efd8fa22fa5ce..f05cb30e64631 100644
--- a/tests/ui/codemap_tests/issue-28308.stderr
+++ b/tests/ui/codemap_tests/issue-28308.stderr
@@ -1,11 +1,12 @@
-error[E0600]: cannot apply unary operator `!` to type `&'static str`
-  --> $DIR/issue-28308.rs:2:5
+error[E0308]: mismatched types
+  --> $DIR/issue-28308.rs:2: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`
+   |             expected due to this
 
 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`.
diff --git a/tests/ui/else-if.rs b/tests/ui/else-if.rs
index 2161b28c58c93..26db3ec50306e 100644
--- a/tests/ui/else-if.rs
+++ b/tests/ui/else-if.rs
@@ -2,19 +2,19 @@
 
 pub fn main() {
     if 1 == 2 {
-        assert!((false));
+        assert!(false);
     } else if 2 == 3 {
-        assert!((false));
-    } else if 3 == 4 { assert!((false)); } else { assert!((true)); }
-    if 1 == 2 { assert!((false)); } else if 2 == 2 { assert!((true)); }
+        assert!(false);
+    } else if 3 == 4 { assert!(false); } else { assert!(true); }
+    if 1 == 2 { assert!(false); } else if 2 == 2 { assert!(true); }
     if 1 == 2 {
-        assert!((false));
+        assert!(false);
     } else if 2 == 2 {
         if 1 == 1 {
-            assert!((true));
-        } else { if 2 == 1 { assert!((false)); } else { assert!((false)); } }
+            assert!(true);
+        } else { if 2 == 1 { assert!(false); } else { assert!(false); } }
     }
     if 1 == 2 {
-        assert!((false));
-    } else { if 1 == 2 { assert!((false)); } else { assert!((true)); } }
+        assert!(false);
+    } else { if 1 == 2 { assert!(false); } else { assert!(true); } }
 }
diff --git a/tests/ui/expr-block.rs b/tests/ui/expr-block.rs
index bf626c9ead372..70f5c274c214d 100644
--- a/tests/ui/expr-block.rs
+++ b/tests/ui/expr-block.rs
@@ -4,7 +4,7 @@
 
 // Tests for standalone blocks as expressions
 
-fn test_basic() { let rs: bool = { true }; assert!((rs)); }
+fn test_basic() { let rs: bool = { true }; assert!(rs); }
 
 struct RS { v1: isize, v2: isize }
 
diff --git a/tests/ui/expr/if/expr-if.rs b/tests/ui/expr/if/expr-if.rs
index ae869c4b77a38..68c2fc2213015 100644
--- a/tests/ui/expr/if/expr-if.rs
+++ b/tests/ui/expr/if/expr-if.rs
@@ -1,43 +1,43 @@
 //@ run-pass
 // Tests for if as expressions
 
-fn test_if() { let rs: bool = if true { true } else { false }; assert!((rs)); }
+fn test_if() { let rs: bool = if true { true } else { false }; assert!(rs); }
 
 fn test_else() {
     let rs: bool = if false { false } else { true };
-    assert!((rs));
+    assert!(rs);
 }
 
 fn test_elseif1() {
     let rs: bool = if true { true } else if true { false } else { false };
-    assert!((rs));
+    assert!(rs);
 }
 
 fn test_elseif2() {
     let rs: bool = if false { false } else if true { true } else { false };
-    assert!((rs));
+    assert!(rs);
 }
 
 fn test_elseif3() {
     let rs: bool = if false { false } else if false { false } else { true };
-    assert!((rs));
+    assert!(rs);
 }
 
 fn test_inferrence() {
     let rs = if true { true } else { false };
-    assert!((rs));
+    assert!(rs);
 }
 
 fn test_if_as_if_condition() {
     let rs1 = if if false { false } else { true } { true } else { false };
-    assert!((rs1));
+    assert!(rs1);
     let rs2 = if if true { false } else { true } { false } else { true };
-    assert!((rs2));
+    assert!(rs2);
 }
 
 fn test_if_as_block_result() {
     let rs = if true { if false { false } else { true } } else { false };
-    assert!((rs));
+    assert!(rs);
 }
 
 pub fn main() {
diff --git a/tests/ui/for-loop-while/break.rs b/tests/ui/for-loop-while/break.rs
index 77774792262cd..442e07e148c57 100644
--- a/tests/ui/for-loop-while/break.rs
+++ b/tests/ui/for-loop-while/break.rs
@@ -8,18 +8,18 @@ pub fn main() {
     assert_eq!(i, 20);
     let xs = [1, 2, 3, 4, 5, 6];
     for x in &xs {
-        if *x == 3 { break; } assert!((*x <= 3));
+        if *x == 3 { break; } assert!(*x <= 3);
     }
     i = 0;
-    while i < 10 { i += 1; if i % 2 == 0 { continue; } assert!((i % 2 != 0)); }
+    while i < 10 { i += 1; if i % 2 == 0 { continue; } assert!(i % 2 != 0); }
     i = 0;
     loop {
-        i += 1; if i % 2 == 0 { continue; } assert!((i % 2 != 0));
+        i += 1; if i % 2 == 0 { continue; } assert!(i % 2 != 0);
         if i >= 10 { break; }
     }
     let ys = vec![1, 2, 3, 4, 5, 6];
     for x in &ys {
         if *x % 2 == 0 { continue; }
-        assert!((*x % 2 != 0));
+        assert!(*x % 2 != 0);
     }
 }
diff --git a/tests/ui/for-loop-while/while-cont.rs b/tests/ui/for-loop-while/while-cont.rs
index 1640b7e1803bd..73a08c26f9af6 100644
--- a/tests/ui/for-loop-while/while-cont.rs
+++ b/tests/ui/for-loop-while/while-cont.rs
@@ -3,7 +3,7 @@
 pub fn main() {
     let mut i = 1;
     while i > 0 {
-        assert!((i > 0));
+        assert!(i > 0);
         println!("{}", i);
         i -= 1;
         continue;
diff --git a/tests/ui/for-loop-while/while-loop-constraints-2.rs b/tests/ui/for-loop-while/while-loop-constraints-2.rs
index 654f6769902bd..1d2d9c2ecfe60 100644
--- a/tests/ui/for-loop-while/while-loop-constraints-2.rs
+++ b/tests/ui/for-loop-while/while-loop-constraints-2.rs
@@ -11,5 +11,5 @@ pub fn main() {
         while false { x = y; y = z; }
         println!("{}", y);
     }
-    assert!((y == 42 && z == 50));
+    assert!(y == 42 && z == 50);
 }
diff --git a/tests/ui/generics/generic-tag-match.rs b/tests/ui/generics/generic-tag-match.rs
index dd0291e9d8736..378b51df287b3 100644
--- a/tests/ui/generics/generic-tag-match.rs
+++ b/tests/ui/generics/generic-tag-match.rs
@@ -7,7 +7,7 @@ enum foo<T> { arm(T), }
 fn altfoo<T>(f: foo<T>) {
     let mut hit = false;
     match f { foo::arm::<T>(_x) => { println!("in arm"); hit = true; } }
-    assert!((hit));
+    assert!(hit);
 }
 
 pub fn main() { altfoo::<isize>(foo::arm::<isize>(10)); }
diff --git a/tests/ui/issues/issue-14091-2.rs b/tests/ui/issues/issue-14091-2.rs
index e2f6b18337266..23163b8cf481a 100644
--- a/tests/ui/issues/issue-14091-2.rs
+++ b/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
 }
diff --git a/tests/ui/issues/issue-14091-2.stderr b/tests/ui/issues/issue-14091-2.stderr
index ac8947670592a..15b65ffb3346e 100644
--- a/tests/ui/issues/issue-14091-2.stderr
+++ b/tests/ui/issues/issue-14091-2.stderr
@@ -1,18 +1,12 @@
-error[E0600]: cannot apply unary operator `!` to type `BytePos`
-  --> $DIR/issue-14091-2.rs:15:5
+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`
+   |             expected due to this
 
 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`.
diff --git a/tests/ui/issues/issue-14091.stderr b/tests/ui/issues/issue-14091.stderr
index 83879583b1f29..d696e7125970a 100644
--- a/tests/ui/issues/issue-14091.stderr
+++ b/tests/ui/issues/issue-14091.stderr
@@ -1,8 +1,11 @@
 error[E0308]: mismatched types
-  --> $DIR/issue-14091.rs:2:5
+  --> $DIR/issue-14091.rs:2:13
    |
 LL |     assert!(1,1);
-   |     ^^^^^^^^^^^^ expected `bool`, found integer
+   |             ^
+   |             |
+   |             expected `bool`, found integer
+   |             expected due to this
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/iterators/iter-range.rs b/tests/ui/iterators/iter-range.rs
index 9594729c06cf0..ec99331753989 100644
--- a/tests/ui/iterators/iter-range.rs
+++ b/tests/ui/iterators/iter-range.rs
@@ -2,7 +2,7 @@
 
 
 fn range_<F>(a: isize, b: isize, mut it: F) where F: FnMut(isize) {
-    assert!((a < b));
+    assert!(a < b);
     let mut i: isize = a;
     while i < b { it(i); i += 1; }
 }
diff --git a/tests/ui/lazy-and-or.rs b/tests/ui/lazy-and-or.rs
index f9dbeb68959a3..4691f9f27497b 100644
--- a/tests/ui/lazy-and-or.rs
+++ b/tests/ui/lazy-and-or.rs
@@ -1,12 +1,12 @@
 //@ run-pass
 
-fn incr(x: &mut isize) -> bool { *x += 1; assert!((false)); return false; }
+fn incr(x: &mut isize) -> bool { *x += 1; assert!(false); return false; }
 
 pub fn main() {
     let x = 1 == 2 || 3 == 3;
-    assert!((x));
+    assert!(x);
     let mut y: isize = 10;
     println!("{}", x || incr(&mut y));
     assert_eq!(y, 10);
-    if true && x { assert!((true)); } else { assert!((false)); }
+    if true && x { assert!(true); } else { assert!(false); }
 }
diff --git a/tests/ui/macros/syntax-extension-source-utils.rs b/tests/ui/macros/syntax-extension-source-utils.rs
index a16ebdc750424..2f88e508058c1 100644
--- a/tests/ui/macros/syntax-extension-source-utils.rs
+++ b/tests/ui/macros/syntax-extension-source-utils.rs
@@ -16,7 +16,7 @@ pub fn main() {
     assert_eq!(line!(), 16);
     assert_eq!(column!(), 16);
     assert_eq!(indirect_line!(), 18);
-    assert!((file!().ends_with("syntax-extension-source-utils.rs")));
+    assert!(file!().ends_with("syntax-extension-source-utils.rs"));
     assert_eq!(stringify!((2*3) + 5).to_string(), "(2*3) + 5".to_string());
     assert!(include!("syntax-extension-source-utils-files/includeme.\
                       fragment").to_string()
@@ -30,7 +30,7 @@ pub fn main() {
         include_bytes!("syntax-extension-source-utils-files/includeme.fragment")
         [1] == (42 as u8)); // '*'
     // The Windows tests are wrapped in an extra module for some reason
-    assert!((m1::m2::where_am_i().ends_with("m1::m2")));
+    assert!(m1::m2::where_am_i().ends_with("m1::m2"));
 
     assert_eq!((35, "(2*3) + 5"), (line!(), stringify!((2*3) + 5)));
 }
diff --git a/tests/ui/numbers-arithmetic/arith-unsigned.rs b/tests/ui/numbers-arithmetic/arith-unsigned.rs
index 5a285ceca32db..4a1bae438ca2e 100644
--- a/tests/ui/numbers-arithmetic/arith-unsigned.rs
+++ b/tests/ui/numbers-arithmetic/arith-unsigned.rs
@@ -3,22 +3,22 @@
 
 // Unsigned integer operations
 pub fn main() {
-    assert!((0u8 < 255u8));
-    assert!((0u8 <= 255u8));
-    assert!((255u8 > 0u8));
-    assert!((255u8 >= 0u8));
+    assert!(0u8 < 255u8);
+    assert!(0u8 <= 255u8);
+    assert!(255u8 > 0u8);
+    assert!(255u8 >= 0u8);
     assert_eq!(250u8 / 10u8, 25u8);
     assert_eq!(255u8 % 10u8, 5u8);
-    assert!((0u16 < 60000u16));
-    assert!((0u16 <= 60000u16));
-    assert!((60000u16 > 0u16));
-    assert!((60000u16 >= 0u16));
+    assert!(0u16 < 60000u16);
+    assert!(0u16 <= 60000u16);
+    assert!(60000u16 > 0u16);
+    assert!(60000u16 >= 0u16);
     assert_eq!(60000u16 / 10u16, 6000u16);
     assert_eq!(60005u16 % 10u16, 5u16);
-    assert!((0u32 < 4000000000u32));
-    assert!((0u32 <= 4000000000u32));
-    assert!((4000000000u32 > 0u32));
-    assert!((4000000000u32 >= 0u32));
+    assert!(0u32 < 4000000000u32);
+    assert!(0u32 <= 4000000000u32);
+    assert!(4000000000u32 > 0u32);
+    assert!(4000000000u32 >= 0u32);
     assert_eq!(4000000000u32 / 10u32, 400000000u32);
     assert_eq!(4000000005u32 % 10u32, 5u32);
     // 64-bit numbers have some flakiness yet. Not tested
diff --git a/tests/ui/numbers-arithmetic/float2.rs b/tests/ui/numbers-arithmetic/float2.rs
index 1b7add01cc631..515220fee9ffe 100644
--- a/tests/ui/numbers-arithmetic/float2.rs
+++ b/tests/ui/numbers-arithmetic/float2.rs
@@ -15,12 +15,12 @@ pub fn main() {
     let j = 3.1e+9f64;
     let k = 3.2e-10f64;
     assert_eq!(a, b);
-    assert!((c < b));
+    assert!(c < b);
     assert_eq!(c, d);
-    assert!((e < g));
-    assert!((f < h));
+    assert!(e < g);
+    assert!(f < h);
     assert_eq!(g, 1000000.0f32);
     assert_eq!(h, i);
-    assert!((j > k));
-    assert!((k < a));
+    assert!(j > k);
+    assert!(k < a);
 }
diff --git a/tests/ui/numbers-arithmetic/floatlits.rs b/tests/ui/numbers-arithmetic/floatlits.rs
index 21f19b69c49e7..2dab224201193 100644
--- a/tests/ui/numbers-arithmetic/floatlits.rs
+++ b/tests/ui/numbers-arithmetic/floatlits.rs
@@ -4,9 +4,9 @@
 
 pub fn main() {
     let f = 4.999999999999f64;
-    assert!((f > 4.90f64));
-    assert!((f < 5.0f64));
+    assert!(f > 4.90f64);
+    assert!(f < 5.0f64);
     let g = 4.90000000001e-10f64;
-    assert!((g > 5e-11f64));
-    assert!((g < 5e-9f64));
+    assert!(g > 5e-11f64);
+    assert!(g < 5e-9f64);
 }
diff --git a/tests/ui/stdlib-unit-tests/istr.rs b/tests/ui/stdlib-unit-tests/istr.rs
index f6298919425d1..2e9be27f81064 100644
--- a/tests/ui/stdlib-unit-tests/istr.rs
+++ b/tests/ui/stdlib-unit-tests/istr.rs
@@ -6,7 +6,7 @@ fn test_stack_assign() {
     let t: String = "a".to_string();
     assert_eq!(s, t);
     let u: String = "b".to_string();
-    assert!((s != u));
+    assert!(s != u);
 }
 
 fn test_heap_lit() { "a big string".to_string(); }
@@ -16,7 +16,7 @@ fn test_heap_assign() {
     let t: String = "a big ol' string".to_string();
     assert_eq!(s, t);
     let u: String = "a bad ol' string".to_string();
-    assert!((s != u));
+    assert!(s != u);
 }
 
 fn test_heap_log() {
diff --git a/tests/ui/stdlib-unit-tests/seq-compare.rs b/tests/ui/stdlib-unit-tests/seq-compare.rs
index 1be0569e17c09..4e3c9141e5f05 100644
--- a/tests/ui/stdlib-unit-tests/seq-compare.rs
+++ b/tests/ui/stdlib-unit-tests/seq-compare.rs
@@ -1,16 +1,16 @@
 //@ run-pass
 
 pub fn main() {
-    assert!(("hello".to_string() < "hellr".to_string()));
-    assert!(("hello ".to_string() > "hello".to_string()));
-    assert!(("hello".to_string() != "there".to_string()));
-    assert!((vec![1, 2, 3, 4] > vec![1, 2, 3]));
-    assert!((vec![1, 2, 3] < vec![1, 2, 3, 4]));
-    assert!((vec![1, 2, 4, 4] > vec![1, 2, 3, 4]));
-    assert!((vec![1, 2, 3, 4] < vec![1, 2, 4, 4]));
-    assert!((vec![1, 2, 3] <= vec![1, 2, 3]));
-    assert!((vec![1, 2, 3] <= vec![1, 2, 3, 3]));
-    assert!((vec![1, 2, 3, 4] > vec![1, 2, 3]));
+    assert!("hello".to_string() < "hellr".to_string());
+    assert!("hello ".to_string() > "hello".to_string());
+    assert!("hello".to_string() != "there".to_string());
+    assert!(vec![1, 2, 3, 4] > vec![1, 2, 3]);
+    assert!(vec![1, 2, 3] < vec![1, 2, 3, 4]);
+    assert!(vec![1, 2, 4, 4] > vec![1, 2, 3, 4]);
+    assert!(vec![1, 2, 3, 4] < vec![1, 2, 4, 4]);
+    assert!(vec![1, 2, 3] <= vec![1, 2, 3]);
+    assert!(vec![1, 2, 3] <= vec![1, 2, 3, 3]);
+    assert!(vec![1, 2, 3, 4] > vec![1, 2, 3]);
     assert_eq!(vec![1, 2, 3], vec![1, 2, 3]);
-    assert!((vec![1, 2, 3] != vec![1, 1, 3]));
+    assert!(vec![1, 2, 3] != vec![1, 1, 3]);
 }
diff --git a/tests/ui/structs-enums/class-impl-very-parameterized-trait.rs b/tests/ui/structs-enums/class-impl-very-parameterized-trait.rs
index 0b37192fc3b34..6caec1e2034ef 100644
--- a/tests/ui/structs-enums/class-impl-very-parameterized-trait.rs
+++ b/tests/ui/structs-enums/class-impl-very-parameterized-trait.rs
@@ -102,6 +102,6 @@ pub fn main() {
     let mut spotty: cat<cat_type> = cat::new(2, 57, cat_type::tuxedo);
     for _ in 0_usize..6 { spotty.speak(); }
     assert_eq!(spotty.len(), 8);
-    assert!((spotty.contains_key(&2)));
+    assert!(spotty.contains_key(&2));
     assert_eq!(spotty.get(&3), &cat_type::tuxedo);
 }
diff --git a/tests/ui/structs-enums/class-implement-trait-cross-crate.rs b/tests/ui/structs-enums/class-implement-trait-cross-crate.rs
index 7a5969451cb52..781ac6ad10d2c 100644
--- a/tests/ui/structs-enums/class-implement-trait-cross-crate.rs
+++ b/tests/ui/structs-enums/class-implement-trait-cross-crate.rs
@@ -53,7 +53,7 @@ fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
 pub fn main() {
   let mut nyan = cat(0_usize, 2, "nyan".to_string());
   nyan.eat();
-  assert!((!nyan.eat()));
+  assert!(!nyan.eat());
   for _ in 1_usize..10_usize { nyan.speak(); };
-  assert!((nyan.eat()));
+  assert!(nyan.eat());
 }
diff --git a/tests/ui/structs-enums/class-implement-traits.rs b/tests/ui/structs-enums/class-implement-traits.rs
index 04a7b706edbce..3a514ff9d7581 100644
--- a/tests/ui/structs-enums/class-implement-traits.rs
+++ b/tests/ui/structs-enums/class-implement-traits.rs
@@ -57,7 +57,7 @@ fn make_speak<C:noisy>(mut c: C) {
 pub fn main() {
     let mut nyan = cat(0_usize, 2, "nyan".to_string());
     nyan.eat();
-    assert!((!nyan.eat()));
+    assert!(!nyan.eat());
     for _ in 1_usize..10_usize {
         make_speak(nyan.clone());
     }
diff --git a/tests/ui/structs-enums/classes-cross-crate.rs b/tests/ui/structs-enums/classes-cross-crate.rs
index 0160d3fd85c08..6fb5f2e3cc9d7 100644
--- a/tests/ui/structs-enums/classes-cross-crate.rs
+++ b/tests/ui/structs-enums/classes-cross-crate.rs
@@ -7,7 +7,7 @@ use cci_class_4::kitties::cat;
 pub fn main() {
     let mut nyan = cat(0_usize, 2, "nyan".to_string());
     nyan.eat();
-    assert!((!nyan.eat()));
+    assert!(!nyan.eat());
     for _ in 1_usize..10_usize { nyan.speak(); };
-    assert!((nyan.eat()));
+    assert!(nyan.eat());
 }
diff --git a/tests/ui/structs-enums/classes.rs b/tests/ui/structs-enums/classes.rs
index d1c1922f4b547..05976f6a759af 100644
--- a/tests/ui/structs-enums/classes.rs
+++ b/tests/ui/structs-enums/classes.rs
@@ -45,7 +45,7 @@ fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
 pub fn main() {
   let mut nyan = cat(0_usize, 2, "nyan".to_string());
   nyan.eat();
-  assert!((!nyan.eat()));
+  assert!(!nyan.eat());
   for _ in 1_usize..10_usize { nyan.speak(); };
-  assert!((nyan.eat()));
+  assert!(nyan.eat());
 }
diff --git a/tests/ui/structs-enums/tag.rs b/tests/ui/structs-enums/tag.rs
index 16e6b2341cf61..542b517e66db7 100644
--- a/tests/ui/structs-enums/tag.rs
+++ b/tests/ui/structs-enums/tag.rs
@@ -25,6 +25,6 @@ impl PartialEq for colour {
     fn ne(&self, other: &colour) -> bool { !(*self).eq(other) }
 }
 
-fn f() { let x = colour::red(1, 2); let y = colour::green; assert!((x != y)); }
+fn f() { let x = colour::red(1, 2); let y = colour::green; assert!(x != y); }
 
 pub fn main() { f(); }
diff --git a/tests/ui/tag-type-args.rs b/tests/ui/tag-type-args.rs
index 75a54927443f2..e3bc89b759c8a 100644
--- a/tests/ui/tag-type-args.rs
+++ b/tests/ui/tag-type-args.rs
@@ -1,6 +1,6 @@
 enum Quux<T> { Bar }
 //~^ ERROR: parameter `T` is never used
 
-fn foo(c: Quux) { assert!((false)); } //~ ERROR missing generics for enum `Quux`
+fn foo(c: Quux) { assert!(false); } //~ ERROR missing generics for enum `Quux`
 
 fn main() { panic!(); }
diff --git a/tests/ui/tag-type-args.stderr b/tests/ui/tag-type-args.stderr
index def13832e1ae0..b56b13de6b11c 100644
--- a/tests/ui/tag-type-args.stderr
+++ b/tests/ui/tag-type-args.stderr
@@ -10,7 +10,7 @@ LL | enum Quux<T> { Bar }
 error[E0107]: missing generics for enum `Quux`
   --> $DIR/tag-type-args.rs:4:11
    |
-LL | fn foo(c: Quux) { assert!((false)); }
+LL | fn foo(c: Quux) { assert!(false); }
    |           ^^^^ expected 1 generic argument
    |
 note: enum defined here, with 1 generic parameter: `T`
@@ -20,7 +20,7 @@ LL | enum Quux<T> { Bar }
    |      ^^^^ -
 help: add missing generic argument
    |
-LL | fn foo(c: Quux<T>) { assert!((false)); }
+LL | fn foo(c: Quux<T>) { assert!(false); }
    |               +++
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/tail-cps.rs b/tests/ui/tail-cps.rs
index 6305e9ecdbcf1..fe99dadf7951c 100644
--- a/tests/ui/tail-cps.rs
+++ b/tests/ui/tail-cps.rs
@@ -1,6 +1,6 @@
 //@ run-pass
 
-fn checktrue(rs: bool) -> bool { assert!((rs)); return true; }
+fn checktrue(rs: bool) -> bool { assert!(rs); return true; }
 
 pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }
 
diff --git a/tests/ui/weird-exprs.rs b/tests/ui/weird-exprs.rs
index d856b06e260b8..e79c584e49088 100644
--- a/tests/ui/weird-exprs.rs
+++ b/tests/ui/weird-exprs.rs
@@ -34,7 +34,7 @@ fn what() {
     let i = &Cell::new(false);
     let dont = {||the(i)};
     dont();
-    assert!((i.get()));
+    assert!(i.get());
 }
 
 fn zombiejesus() {
@@ -69,8 +69,8 @@ fn notsure() {
 
 fn canttouchthis() -> usize {
     fn p() -> bool { true }
-    let _a = (assert!((true)) == (assert!(p())));
-    let _c = (assert!((p())) == ());
+    let _a = (assert!(true) == (assert!(p())));
+    let _c = (assert!(p()) == ());
     let _b: bool = (println!("{}", 0) == (return 0));
 }