clippy_lints/src/if_let_mutex.rs

   1 use clippy_utils::diagnostics::span_lint_and_then;
   2 use clippy_utils::higher;
   3 use clippy_utils::ty::is_type_diagnostic_item;
   4 use clippy_utils::SpanlessEq;
   5 use if_chain::if_chain;
   6 use rustc_errors::Diagnostic;
   7 use rustc_hir::intravisit::{self as visit, Visitor};
   8 use rustc_hir::{Expr, ExprKind};
   9 use rustc_lint::{LateContext, LateLintPass};
  10 use rustc_session::{declare_lint_pass, declare_tool_lint};
  11 use rustc_span::sym;
  12
  13 declare_clippy_lint! {
  14     /// ### What it does
  15     /// Checks for `Mutex::lock` calls in `if let` expression
  16     /// with lock calls in any of the else blocks.
  17     ///
  18     /// ### Why is this bad?
  19     /// The Mutex lock remains held for the whole
  20     /// `if let ... else` block and deadlocks.
  21     ///
  22     /// ### Example
  23     /// ```rust,ignore
  24     /// if let Ok(thing) = mutex.lock() {
  25     ///     do_thing();
  26     /// } else {
  27     ///     mutex.lock();
  28     /// }
  29     /// ```
  30     /// Should be written
  31     /// ```rust,ignore
  32     /// let locked = mutex.lock();
  33     /// if let Ok(thing) = locked {
  34     ///     do_thing(thing);
  35     /// } else {
  36     ///     use_locked(locked);
  37     /// }
  38     /// ```
  39     #[clippy::version = "1.45.0"]
  40     pub IF_LET_MUTEX,
  41     correctness,
  42     "locking a `Mutex` in an `if let` block can cause deadlocks"
  43 }
  44
  45 declare_lint_pass!(IfLetMutex => [IF_LET_MUTEX]);
  46
  47 impl<'tcx> LateLintPass<'tcx> for IfLetMutex {
  48     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
  49         let mut arm_visit = ArmVisitor { found_mutex: None, cx };
  50         let mut op_visit = OppVisitor { found_mutex: None, cx };
  51         if let Some(higher::IfLet {
  52             let_expr,
  53             if_then,
  54             if_else: Some(if_else),
  55             ..
  56         }) = higher::IfLet::hir(cx, expr)
  57         {
  58             op_visit.visit_expr(let_expr);
  59             if let Some(op_mutex) = op_visit.found_mutex {
  60                 arm_visit.visit_expr(if_then);
  61                 arm_visit.visit_expr(if_else);
  62
  63                 if let Some(arm_mutex) = arm_visit.found_mutex_if_same_as(op_mutex) {
  64                     let diag = |diag: &mut Diagnostic| {
  65                         diag.span_label(
  66                             op_mutex.span,
  67                             "this Mutex will remain locked for the entire `if let`-block...",
  68                         );
  69                         diag.span_label(
  70                             arm_mutex.span,
  71                             "... and is tried to lock again here, which will always deadlock.",
  72                         );
  73                         diag.help("move the lock call outside of the `if let ...` expression");
  74                     };
  75                     span_lint_and_then(
  76                         cx,
  77                         IF_LET_MUTEX,
  78                         expr.span,
  79                         "calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock",
  80                         diag,
  81                     );
  82                 }
  83             }
  84         }
  85     }
  86 }
  87
  88 /// Checks if `Mutex::lock` is called in the `if let` expr.
  89 pub struct OppVisitor<'a, 'tcx> {
  90     found_mutex: Option<&'tcx Expr<'tcx>>,
  91     cx: &'a LateContext<'tcx>,
  92 }
  93
  94 impl<'tcx> Visitor<'tcx> for OppVisitor<'_, 'tcx> {
  95     fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
  96         if let Some(mutex) = is_mutex_lock_call(self.cx, expr) {
  97             self.found_mutex = Some(mutex);
  98             return;
  99         }
 100         visit::walk_expr(self, expr);
 101     }
 102 }
 103
 104 /// Checks if `Mutex::lock` is called in any of the branches.
 105 pub struct ArmVisitor<'a, 'tcx> {
 106     found_mutex: Option<&'tcx Expr<'tcx>>,
 107     cx: &'a LateContext<'tcx>,
 108 }
 109
 110 impl<'tcx> Visitor<'tcx> for ArmVisitor<'_, 'tcx> {
 111     fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
 112         if let Some(mutex) = is_mutex_lock_call(self.cx, expr) {
 113             self.found_mutex = Some(mutex);
 114             return;
 115         }
 116         visit::walk_expr(self, expr);
 117     }
 118 }
 119
 120 impl<'tcx, 'l> ArmVisitor<'tcx, 'l> {
 121     fn found_mutex_if_same_as(&self, op_mutex: &Expr<'_>) -> Option<&Expr<'_>> {
 122         self.found_mutex.and_then(|arm_mutex| {
 123             SpanlessEq::new(self.cx)
 124                 .eq_expr(op_mutex, arm_mutex)
 125                 .then_some(arm_mutex)
 126         })
 127     }
 128 }
 129
 130 fn is_mutex_lock_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
 131     if_chain! {
 132         if let ExprKind::MethodCall(path, self_arg, ..) = &expr.kind;
 133         if path.ident.as_str() == "lock";
 134         let ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
 135         if is_type_diagnostic_item(cx, ty, sym::Mutex);
 136         then {
 137             Some(self_arg)
 138         } else {
 139             None
 140         }
 141     }
 142 }