src/tools/clippy/clippy_lints/src/mutex_atomic.rs

   1 //! Checks for uses of mutex where an atomic value could be used
   2 //!
   3 //! This lint is **allow** by default
   4
   5 use clippy_utils::diagnostics::span_lint;
   6 use clippy_utils::ty::is_type_diagnostic_item;
   7 use rustc_hir::Expr;
   8 use rustc_lint::{LateContext, LateLintPass};
   9 use rustc_middle::ty::{self, Ty};
  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 usages of `Mutex<X>` where an atomic will do.
  16     ///
  17     /// ### Why is this bad?
  18     /// Using a mutex just to make access to a plain bool or
  19     /// reference sequential is shooting flies with cannons.
  20     /// `std::sync::atomic::AtomicBool` and `std::sync::atomic::AtomicPtr` are leaner and
  21     /// faster.
  22     ///
  23     /// On the other hand, `Mutex`es are, in general, easier to
  24     /// verify correctness. An atomic does not behave the same as
  25     /// an equivalent mutex. See [this issue](https://github.com/rust-lang/rust-clippy/issues/4295)'s commentary for more details.
  26     ///
  27     /// ### Known problems
  28     /// This lint cannot detect if the mutex is actually used
  29     /// for waiting before a critical section.
  30     ///
  31     /// ### Example
  32     /// ```rust
  33     /// # let y = true;
  34     /// # use std::sync::Mutex;
  35     /// let x = Mutex::new(&y);
  36     /// ```
  37     ///
  38     /// Use instead:
  39     /// ```rust
  40     /// # let y = true;
  41     /// # use std::sync::atomic::AtomicBool;
  42     /// let x = AtomicBool::new(y);
  43     /// ```
  44     #[clippy::version = "pre 1.29.0"]
  45     pub MUTEX_ATOMIC,
  46     restriction,
  47     "using a mutex where an atomic value could be used instead."
  48 }
  49
  50 declare_clippy_lint! {
  51     /// ### What it does
  52     /// Checks for usages of `Mutex<X>` where `X` is an integral
  53     /// type.
  54     ///
  55     /// ### Why is this bad?
  56     /// Using a mutex just to make access to a plain integer
  57     /// sequential is
  58     /// shooting flies with cannons. `std::sync::atomic::AtomicUsize` is leaner and faster.
  59     ///
  60     /// ### Known problems
  61     /// This lint cannot detect if the mutex is actually used
  62     /// for waiting before a critical section.
  63     ///
  64     /// ### Example
  65     /// ```rust
  66     /// # use std::sync::Mutex;
  67     /// let x = Mutex::new(0usize);
  68     /// ```
  69     ///
  70     /// Use instead:
  71     /// ```rust
  72     /// # use std::sync::atomic::AtomicUsize;
  73     /// let x = AtomicUsize::new(0usize);
  74     /// ```
  75     #[clippy::version = "pre 1.29.0"]
  76     pub MUTEX_INTEGER,
  77     nursery,
  78     "using a mutex for an integer type"
  79 }
  80
  81 declare_lint_pass!(Mutex => [MUTEX_ATOMIC, MUTEX_INTEGER]);
  82
  83 impl<'tcx> LateLintPass<'tcx> for Mutex {
  84     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  85         let ty = cx.typeck_results().expr_ty(expr);
  86         if let ty::Adt(_, subst) = ty.kind() {
  87             if is_type_diagnostic_item(cx, ty, sym::Mutex) {
  88                 let mutex_param = subst.type_at(0);
  89                 if let Some(atomic_name) = get_atomic_name(mutex_param) {
  90                     let msg = format!(
  91                         "consider using an `{atomic_name}` instead of a `Mutex` here; if you just want the locking \
  92                          behavior and not the internal type, consider using `Mutex<()>`"
  93                     );
  94                     match *mutex_param.kind() {
  95                         ty::Uint(t) if t != ty::UintTy::Usize => span_lint(cx, MUTEX_INTEGER, expr.span, &msg),
  96                         ty::Int(t) if t != ty::IntTy::Isize => span_lint(cx, MUTEX_INTEGER, expr.span, &msg),
  97                         _ => span_lint(cx, MUTEX_ATOMIC, expr.span, &msg),
  98                     };
  99                 }
 100             }
 101         }
 102     }
 103 }
 104
 105 fn get_atomic_name(ty: Ty<'_>) -> Option<&'static str> {
 106     match ty.kind() {
 107         ty::Bool => Some("AtomicBool"),
 108         ty::Uint(_) => Some("AtomicUsize"),
 109         ty::Int(_) => Some("AtomicIsize"),
 110         ty::RawPtr(_) => Some("AtomicPtr"),
 111         _ => None,
 112     }
 113 }