src/tools/clippy/clippy_lints/src/await_holding_invalid.rs

   1 use clippy_utils::diagnostics::span_lint_and_then;
   2 use clippy_utils::{match_def_path, paths};
   3 use rustc_data_structures::fx::FxHashMap;
   4 use rustc_hir::def_id::DefId;
   5 use rustc_hir::{AsyncGeneratorKind, Body, BodyId, GeneratorKind};
   6 use rustc_lint::{LateContext, LateLintPass};
   7 use rustc_middle::ty::GeneratorInteriorTypeCause;
   8 use rustc_session::{declare_tool_lint, impl_lint_pass};
   9 use rustc_span::{sym, Span};
  10
  11 use crate::utils::conf::DisallowedPath;
  12
  13 declare_clippy_lint! {
  14     /// ### What it does
  15     /// Checks for calls to await while holding a non-async-aware MutexGuard.
  16     ///
  17     /// ### Why is this bad?
  18     /// The Mutex types found in std::sync and parking_lot
  19     /// are not designed to operate in an async context across await points.
  20     ///
  21     /// There are two potential solutions. One is to use an async-aware Mutex
  22     /// type. Many asynchronous foundation crates provide such a Mutex type. The
  23     /// other solution is to ensure the mutex is unlocked before calling await,
  24     /// either by introducing a scope or an explicit call to Drop::drop.
  25     ///
  26     /// ### Known problems
  27     /// Will report false positive for explicitly dropped guards
  28     /// ([#6446](https://github.com/rust-lang/rust-clippy/issues/6446)). A workaround for this is
  29     /// to wrap the `.lock()` call in a block instead of explicitly dropping the guard.
  30     ///
  31     /// ### Example
  32     /// ```rust
  33     /// # use std::sync::Mutex;
  34     /// # async fn baz() {}
  35     /// async fn foo(x: &Mutex<u32>) {
  36     ///   let mut guard = x.lock().unwrap();
  37     ///   *guard += 1;
  38     ///   baz().await;
  39     /// }
  40     ///
  41     /// async fn bar(x: &Mutex<u32>) {
  42     ///   let mut guard = x.lock().unwrap();
  43     ///   *guard += 1;
  44     ///   drop(guard); // explicit drop
  45     ///   baz().await;
  46     /// }
  47     /// ```
  48     ///
  49     /// Use instead:
  50     /// ```rust
  51     /// # use std::sync::Mutex;
  52     /// # async fn baz() {}
  53     /// async fn foo(x: &Mutex<u32>) {
  54     ///   {
  55     ///     let mut guard = x.lock().unwrap();
  56     ///     *guard += 1;
  57     ///   }
  58     ///   baz().await;
  59     /// }
  60     ///
  61     /// async fn bar(x: &Mutex<u32>) {
  62     ///   {
  63     ///     let mut guard = x.lock().unwrap();
  64     ///     *guard += 1;
  65     ///   } // guard dropped here at end of scope
  66     ///   baz().await;
  67     /// }
  68     /// ```
  69     #[clippy::version = "1.45.0"]
  70     pub AWAIT_HOLDING_LOCK,
  71     suspicious,
  72     "inside an async function, holding a `MutexGuard` while calling `await`"
  73 }
  74
  75 declare_clippy_lint! {
  76     /// ### What it does
  77     /// Checks for calls to await while holding a `RefCell` `Ref` or `RefMut`.
  78     ///
  79     /// ### Why is this bad?
  80     /// `RefCell` refs only check for exclusive mutable access
  81     /// at runtime. Holding onto a `RefCell` ref across an `await` suspension point
  82     /// risks panics from a mutable ref shared while other refs are outstanding.
  83     ///
  84     /// ### Known problems
  85     /// Will report false positive for explicitly dropped refs
  86     /// ([#6353](https://github.com/rust-lang/rust-clippy/issues/6353)). A workaround for this is
  87     /// to wrap the `.borrow[_mut]()` call in a block instead of explicitly dropping the ref.
  88     ///
  89     /// ### Example
  90     /// ```rust
  91     /// # use std::cell::RefCell;
  92     /// # async fn baz() {}
  93     /// async fn foo(x: &RefCell<u32>) {
  94     ///   let mut y = x.borrow_mut();
  95     ///   *y += 1;
  96     ///   baz().await;
  97     /// }
  98     ///
  99     /// async fn bar(x: &RefCell<u32>) {
 100     ///   let mut y = x.borrow_mut();
 101     ///   *y += 1;
 102     ///   drop(y); // explicit drop
 103     ///   baz().await;
 104     /// }
 105     /// ```
 106     ///
 107     /// Use instead:
 108     /// ```rust
 109     /// # use std::cell::RefCell;
 110     /// # async fn baz() {}
 111     /// async fn foo(x: &RefCell<u32>) {
 112     ///   {
 113     ///      let mut y = x.borrow_mut();
 114     ///      *y += 1;
 115     ///   }
 116     ///   baz().await;
 117     /// }
 118     ///
 119     /// async fn bar(x: &RefCell<u32>) {
 120     ///   {
 121     ///     let mut y = x.borrow_mut();
 122     ///     *y += 1;
 123     ///   } // y dropped here at end of scope
 124     ///   baz().await;
 125     /// }
 126     /// ```
 127     #[clippy::version = "1.49.0"]
 128     pub AWAIT_HOLDING_REFCELL_REF,
 129     suspicious,
 130     "inside an async function, holding a `RefCell` ref while calling `await`"
 131 }
 132
 133 declare_clippy_lint! {
 134     /// ### What it does
 135     /// Allows users to configure types which should not be held across `await`
 136     /// suspension points.
 137     ///
 138     /// ### Why is this bad?
 139     /// There are some types which are perfectly "safe" to be used concurrently
 140     /// from a memory access perspective but will cause bugs at runtime if they
 141     /// are held in such a way.
 142     ///
 143     /// ### Example
 144     ///
 145     /// ```toml
 146     /// await-holding-invalid-types = [
 147     ///   # You can specify a type name
 148     ///   "CustomLockType",
 149     ///   # You can (optionally) specify a reason
 150     ///   { path = "OtherCustomLockType", reason = "Relies on a thread local" }
 151     /// ]
 152     /// ```
 153     ///
 154     /// ```rust
 155     /// # async fn baz() {}
 156     /// struct CustomLockType;
 157     /// struct OtherCustomLockType;
 158     /// async fn foo() {
 159     ///   let _x = CustomLockType;
 160     ///   let _y = OtherCustomLockType;
 161     ///   baz().await; // Lint violation
 162     /// }
 163     /// ```
 164     #[clippy::version = "1.62.0"]
 165     pub AWAIT_HOLDING_INVALID_TYPE,
 166     suspicious,
 167     "holding a type across an await point which is not allowed to be held as per the configuration"
 168 }
 169
 170 impl_lint_pass!(AwaitHolding => [AWAIT_HOLDING_LOCK, AWAIT_HOLDING_REFCELL_REF, AWAIT_HOLDING_INVALID_TYPE]);
 171
 172 #[derive(Debug)]
 173 pub struct AwaitHolding {
 174     conf_invalid_types: Vec<DisallowedPath>,
 175     def_ids: FxHashMap<DefId, DisallowedPath>,
 176 }
 177
 178 impl AwaitHolding {
 179     pub(crate) fn new(conf_invalid_types: Vec<DisallowedPath>) -> Self {
 180         Self {
 181             conf_invalid_types,
 182             def_ids: FxHashMap::default(),
 183         }
 184     }
 185 }
 186
 187 impl LateLintPass<'_> for AwaitHolding {
 188     fn check_crate(&mut self, cx: &LateContext<'_>) {
 189         for conf in &self.conf_invalid_types {
 190             let segs: Vec<_> = conf.path().split("::").collect();
 191             for id in clippy_utils::def_path_def_ids(cx, &segs) {
 192                 self.def_ids.insert(id, conf.clone());
 193             }
 194         }
 195     }
 196
 197     fn check_body(&mut self, cx: &LateContext<'_>, body: &'_ Body<'_>) {
 198         use AsyncGeneratorKind::{Block, Closure, Fn};
 199         if let Some(GeneratorKind::Async(Block | Closure | Fn)) = body.generator_kind {
 200             let body_id = BodyId {
 201                 hir_id: body.value.hir_id,
 202             };
 203             let typeck_results = cx.tcx.typeck_body(body_id);
 204             self.check_interior_types(
 205                 cx,
 206                 typeck_results.generator_interior_types.as_ref().skip_binder(),
 207                 body.value.span,
 208             );
 209         }
 210     }
 211 }
 212
 213 impl AwaitHolding {
 214     fn check_interior_types(&self, cx: &LateContext<'_>, ty_causes: &[GeneratorInteriorTypeCause<'_>], span: Span) {
 215         for ty_cause in ty_causes {
 216             if let rustc_middle::ty::Adt(adt, _) = ty_cause.ty.kind() {
 217                 if is_mutex_guard(cx, adt.did()) {
 218                     span_lint_and_then(
 219                         cx,
 220                         AWAIT_HOLDING_LOCK,
 221                         ty_cause.span,
 222                         "this `MutexGuard` is held across an `await` point",
 223                         |diag| {
 224                             diag.help(
 225                                 "consider using an async-aware `Mutex` type or ensuring the \
 226                                 `MutexGuard` is dropped before calling await",
 227                             );
 228                             diag.span_note(
 229                                 ty_cause.scope_span.unwrap_or(span),
 230                                 "these are all the `await` points this lock is held through",
 231                             );
 232                         },
 233                     );
 234                 } else if is_refcell_ref(cx, adt.did()) {
 235                     span_lint_and_then(
 236                         cx,
 237                         AWAIT_HOLDING_REFCELL_REF,
 238                         ty_cause.span,
 239                         "this `RefCell` reference is held across an `await` point",
 240                         |diag| {
 241                             diag.help("ensure the reference is dropped before calling `await`");
 242                             diag.span_note(
 243                                 ty_cause.scope_span.unwrap_or(span),
 244                                 "these are all the `await` points this reference is held through",
 245                             );
 246                         },
 247                     );
 248                 } else if let Some(disallowed) = self.def_ids.get(&adt.did()) {
 249                     emit_invalid_type(cx, ty_cause.span, disallowed);
 250                 }
 251             }
 252         }
 253     }
 254 }
 255
 256 fn emit_invalid_type(cx: &LateContext<'_>, span: Span, disallowed: &DisallowedPath) {
 257     span_lint_and_then(
 258         cx,
 259         AWAIT_HOLDING_INVALID_TYPE,
 260         span,
 261         &format!(
 262             "`{}` may not be held across an `await` point per `clippy.toml`",
 263             disallowed.path()
 264         ),
 265         |diag| {
 266             if let Some(reason) = disallowed.reason() {
 267                 diag.note(reason);
 268             }
 269         },
 270     );
 271 }
 272
 273 fn is_mutex_guard(cx: &LateContext<'_>, def_id: DefId) -> bool {
 274     cx.tcx.is_diagnostic_item(sym::MutexGuard, def_id)
 275         || cx.tcx.is_diagnostic_item(sym::RwLockReadGuard, def_id)
 276         || cx.tcx.is_diagnostic_item(sym::RwLockWriteGuard, def_id)
 277         || match_def_path(cx, def_id, &paths::PARKING_LOT_MUTEX_GUARD)
 278         || match_def_path(cx, def_id, &paths::PARKING_LOT_RWLOCK_READ_GUARD)
 279         || match_def_path(cx, def_id, &paths::PARKING_LOT_RWLOCK_WRITE_GUARD)
 280 }
 281
 282 fn is_refcell_ref(cx: &LateContext<'_>, def_id: DefId) -> bool {
 283     match_def_path(cx, def_id, &paths::REFCELL_REF) || match_def_path(cx, def_id, &paths::REFCELL_REFMUT)
 284 }