src/tools/clippy/clippy_lints/src/manual_assert.rs

   1 use clippy_utils::diagnostics::span_lint_and_sugg;
   2 use clippy_utils::higher::PanicExpn;
   3 use clippy_utils::source::snippet_with_applicability;
   4 use clippy_utils::{is_expn_of, sugg};
   5 use rustc_errors::Applicability;
   6 use rustc_hir::{Block, Expr, ExprKind, StmtKind, UnOp};
   7 use rustc_lint::{LateContext, LateLintPass};
   8 use rustc_session::{declare_lint_pass, declare_tool_lint};
   9
  10 declare_clippy_lint! {
  11     /// ### What it does
  12     /// Detects `if`-then-`panic!` that can be replaced with `assert!`.
  13     ///
  14     /// ### Why is this bad?
  15     /// `assert!` is simpler than `if`-then-`panic!`.
  16     ///
  17     /// ### Example
  18     /// ```rust
  19     /// let sad_people: Vec<&str> = vec![];
  20     /// if !sad_people.is_empty() {
  21     ///     panic!("there are sad people: {:?}", sad_people);
  22     /// }
  23     /// ```
  24     /// Use instead:
  25     /// ```rust
  26     /// let sad_people: Vec<&str> = vec![];
  27     /// assert!(sad_people.is_empty(), "there are sad people: {:?}", sad_people);
  28     /// ```
  29     pub MANUAL_ASSERT,
  30     pedantic,
  31     "`panic!` and only a `panic!` in `if`-then statement"
  32 }
  33
  34 declare_lint_pass!(ManualAssert => [MANUAL_ASSERT]);
  35
  36 impl LateLintPass<'_> for ManualAssert {
  37     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
  38         if_chain! {
  39             if let Expr {
  40                 kind: ExprKind:: If(cond, Expr {
  41                     kind: ExprKind::Block(
  42                         Block {
  43                             stmts: [stmt],
  44                             ..
  45                         },
  46                         _),
  47                     ..
  48                 }, None),
  49                 ..
  50             } = &expr;
  51             if is_expn_of(stmt.span, "panic").is_some();
  52             if !matches!(cond.kind, ExprKind::Let(_, _, _));
  53             if let StmtKind::Semi(semi) = stmt.kind;
  54             if !cx.tcx.sess.source_map().is_multiline(cond.span);
  55
  56             then {
  57                 let call = if_chain! {
  58                     if let ExprKind::Block(block, _) = semi.kind;
  59                     if let Some(init) = block.expr;
  60                     then {
  61                         init
  62                     } else {
  63                         semi
  64                     }
  65                 };
  66                 let span = if let Some(panic_expn) = PanicExpn::parse(call) {
  67                     match *panic_expn.format_args.value_args {
  68                         [] => panic_expn.format_args.format_string_span,
  69                         [.., last] => panic_expn.format_args.format_string_span.to(last.span),
  70                     }
  71                 } else if let ExprKind::Call(_, [format_args]) = call.kind {
  72                     format_args.span
  73                 } else {
  74                     return
  75                 };
  76                 let mut applicability = Applicability::MachineApplicable;
  77                 let sugg = snippet_with_applicability(cx, span, "..", &mut applicability);
  78                 let cond_sugg = if let ExprKind::DropTemps(e, ..) = cond.kind {
  79                     if let Expr{kind: ExprKind::Unary(UnOp::Not, not_expr), ..} = e {
  80                          sugg::Sugg::hir_with_applicability(cx, not_expr, "..", &mut applicability).maybe_par().to_string()
  81                     } else {
  82                        format!("!{}", sugg::Sugg::hir_with_applicability(cx, e, "..", &mut applicability).maybe_par())
  83                     }
  84                 } else {
  85                    format!("!{}", sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability).maybe_par())
  86                 };
  87
  88                 span_lint_and_sugg(
  89                     cx,
  90                     MANUAL_ASSERT,
  91                     expr.span,
  92                     "only a `panic!` in `if`-then statement",
  93                     "try",
  94                     format!("assert!({}, {});", cond_sugg, sugg),
  95                     Applicability::MachineApplicable,
  96                 );
  97             }
  98         }
  99     }
 100 }