-use crate::consts::{constant, Constant};
+use clippy_utils::consts::{constant, Constant};
use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::higher;
use clippy_utils::source::snippet_opt;
use clippy_utils::{is_direct_expn_of, is_expn_of, match_panic_call};
use if_chain::if_chain;
use rustc_session::{declare_lint_pass, declare_tool_lint};
declare_clippy_lint! {
- /// **What it does:** Checks for `assert!(true)` and `assert!(false)` calls.
+ /// ### What it does
+ /// Checks for `assert!(true)` and `assert!(false)` calls.
///
- /// **Why is this bad?** Will be optimized out by the compiler or should probably be replaced by a
+ /// ### Why is this bad?
+ /// Will be optimized out by the compiler or should probably be replaced by a
/// `panic!()` or `unreachable!()`
///
- /// **Known problems:** None
+ /// ### Known problems
+ /// None
///
- /// **Example:**
+ /// ### Example
/// ```rust,ignore
/// assert!(false)
/// assert!(true)
&format!("`assert!(false, {})` should probably be replaced", panic_message),
None,
&format!("use `panic!({})` or `unreachable!({})`", panic_message, panic_message),
- )
+ );
};
if let Some(debug_assert_span) = is_expn_of(e.span, "debug_assert") {
return;
}
if_chain! {
- if let ExprKind::Unary(_, ref lit) = e.kind;
+ if let ExprKind::Unary(_, lit) = e.kind;
if let Some((Constant::Bool(is_true), _)) = constant(cx, cx.typeck_results(), lit);
if is_true;
then {
if assert_span.from_expansion() {
return;
}
- if let Some(assert_match) = match_assert_with_message(&cx, e) {
+ if let Some(assert_match) = match_assert_with_message(cx, e) {
match assert_match {
// matched assert but not message
AssertKind::WithoutMessage(false) => lint_false_without_message(),
/// where `message` is any expression and `c` is a constant bool.
fn match_assert_with_message<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<AssertKind> {
if_chain! {
- if let ExprKind::If(ref cond, ref then, _) = expr.kind;
- if let ExprKind::Unary(UnOp::Not, ref expr) = cond.kind;
+ if let Some(higher::If { cond, then, .. }) = higher::If::hir(expr);
+ if let ExprKind::Unary(UnOp::Not, expr) = cond.kind;
// bind the first argument of the `assert!` macro
if let Some((Constant::Bool(is_true), _)) = constant(cx, cx.typeck_results(), expr);
// block
- if let ExprKind::Block(ref block, _) = then.kind;
+ if let ExprKind::Block(block, _) = then.kind;
if block.stmts.is_empty();
if let Some(block_expr) = &block.expr;
// inner block is optional. unwrap it if it exists, or use the expression as is otherwise.
if let Some(begin_panic_call) = match block_expr.kind {
- ExprKind::Block(ref inner_block, _) => &inner_block.expr,
+ ExprKind::Block(inner_block, _) => &inner_block.expr,
_ => &block.expr,
};
// function call
- if let Some(args) = match_panic_call(cx, begin_panic_call);
- if args.len() == 1;
+ if let Some(arg) = match_panic_call(cx, begin_panic_call);
// bind the second argument of the `assert!` macro if it exists
- if let panic_message = snippet_opt(cx, args[0].span);
+ if let panic_message = snippet_opt(cx, arg.span);
// second argument of begin_panic is irrelevant
// as is the second match arm
then {