src/tools/clippy/clippy_lints/src/if_then_panic.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 IF_THEN_PANIC,
  30     style,
  31     "`panic!` and only a `panic!` in `if`-then statement"
  32 }
  33
  34 declare_lint_pass!(IfThenPanic => [IF_THEN_PANIC]);
  35
  36 impl LateLintPass<'_> for IfThenPanic {
  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 span = if let Some(panic_expn) = PanicExpn::parse(semi) {
  58                     match *panic_expn.format_args.value_args {
  59                         [] => panic_expn.format_args.format_string_span,
  60                         [.., last] => panic_expn.format_args.format_string_span.to(last.span),
  61                     }
  62                 } else {
  63                     if_chain! {
  64                         if let ExprKind::Block(block, _) = semi.kind;
  65                         if let Some(init) = block.expr;
  66                         if let ExprKind::Call(_, [format_args]) = init.kind;
  67
  68                         then {
  69                             format_args.span
  70                         } else {
  71                             return
  72                         }
  73                     }
  74                 };
  75                 let mut applicability = Applicability::MachineApplicable;
  76                 let sugg = snippet_with_applicability(cx, span, "..", &mut applicability);
  77                 let cond_sugg = if let ExprKind::DropTemps(e, ..) = cond.kind {
  78                     if let Expr{kind: ExprKind::Unary(UnOp::Not, not_expr), ..} = e {
  79                          sugg::Sugg::hir_with_applicability(cx, not_expr, "..", &mut applicability).maybe_par().to_string()
  80                     } else {
  81                        format!("!{}", sugg::Sugg::hir_with_applicability(cx, e, "..", &mut applicability).maybe_par())
  82                     }
  83                 } else {
  84                    format!("!{}", sugg::Sugg::hir_with_applicability(cx, cond, "..", &mut applicability).maybe_par())
  85                 };
  86
  87                 span_lint_and_sugg(
  88                     cx,
  89                     IF_THEN_PANIC,
  90                     expr.span,
  91                     "only a `panic!` in `if`-then statement",
  92                     "try",
  93                     format!("assert!({}, {});", cond_sugg, sugg),
  94                     Applicability::MachineApplicable,
  95                 );
  96             }
  97         }
  98     }
  99 }