Actually lint parking_lot in await_holding_lock

This adapts the paths for the parking_lot mutex guards, so that
parking_lot mutexes and RwLocks actually get linted. This is now also
tested.

Author: flip1995

clippy_utils/src/paths.rs

@@ -105,9 +105,9 @@ pub const OS_STRING_AS_OS_STR: [&str; 5] = ["std", "ffi", "os_str", "OsString",
 pub const OS_STR_TO_OS_STRING: [&str; 5] = ["std", "ffi", "os_str", "OsStr", "to_os_string"];
 pub const PARKING_LOT_RAWMUTEX: [&str; 3] = ["parking_lot", "raw_mutex", "RawMutex"];
 pub const PARKING_LOT_RAWRWLOCK: [&str; 3] = ["parking_lot", "raw_rwlock", "RawRwLock"];
-pub const PARKING_LOT_MUTEX_GUARD: [&str; 2] = ["parking_lot", "MutexGuard"];
-pub const PARKING_LOT_RWLOCK_READ_GUARD: [&str; 2] = ["parking_lot", "RwLockReadGuard"];
-pub const PARKING_LOT_RWLOCK_WRITE_GUARD: [&str; 2] = ["parking_lot", "RwLockWriteGuard"];
+pub const PARKING_LOT_MUTEX_GUARD: [&str; 3] = ["lock_api", "mutex", "MutexGuard"];
+pub const PARKING_LOT_RWLOCK_READ_GUARD: [&str; 3] = ["lock_api", "rwlock", "RwLockReadGuard"];
+pub const PARKING_LOT_RWLOCK_WRITE_GUARD: [&str; 3] = ["lock_api", "rwlock", "RwLockWriteGuard"];
 pub const PATH_BUF_AS_PATH: [&str; 4] = ["std", "path", "PathBuf", "as_path"];
 pub const PATH_TO_PATH_BUF: [&str; 4] = ["std", "path", "Path", "to_path_buf"];
 pub const PERMISSIONS: [&str; 3] = ["std", "fs", "Permissions"];

tests/ui/await_holding_lock.rs

@@ -1,88 +1,178 @@
 #![warn(clippy::await_holding_lock)]
 
-use std::sync::{Mutex, RwLock};
+// When adding or modifying a test, please do the same for parking_lot::Mutex.
+mod std_mutex {
+    use std::sync::{Mutex, RwLock};
 
-async fn bad(x: &Mutex<u32>) -> u32 {
-    let guard = x.lock().unwrap();
-    baz().await
-}
+    pub async fn bad(x: &Mutex<u32>) -> u32 {
+        let guard = x.lock().unwrap();
+        baz().await
+    }
 
-async fn good(x: &Mutex<u32>) -> u32 {
-    {
+    pub async fn good(x: &Mutex<u32>) -> u32 {
+        {
+            let guard = x.lock().unwrap();
+            let y = *guard + 1;
+        }
+        baz().await;
         let guard = x.lock().unwrap();
-        let y = *guard + 1;
+        47
     }
-    baz().await;
-    let guard = x.lock().unwrap();
-    47
-}
 
-pub async fn bad_rw(x: &RwLock<u32>) -> u32 {
-    let guard = x.read().unwrap();
-    baz().await
-}
+    pub async fn bad_rw(x: &RwLock<u32>) -> u32 {
+        let guard = x.read().unwrap();
+        baz().await
+    }
 
-pub async fn bad_rw_write(x: &RwLock<u32>) -> u32 {
-    let mut guard = x.write().unwrap();
-    baz().await
-}
+    pub async fn bad_rw_write(x: &RwLock<u32>) -> u32 {
+        let mut guard = x.write().unwrap();
+        baz().await
+    }
 
-pub async fn good_rw(x: &RwLock<u32>) -> u32 {
-    {
+    pub async fn good_rw(x: &RwLock<u32>) -> u32 {
+        {
+            let guard = x.read().unwrap();
+            let y = *guard + 1;
+        }
+        {
+            let mut guard = x.write().unwrap();
+            *guard += 1;
+        }
+        baz().await;
         let guard = x.read().unwrap();
-        let y = *guard + 1;
+        47
     }
-    {
-        let mut guard = x.write().unwrap();
-        *guard += 1;
+
+    pub async fn baz() -> u32 {
+        42
     }
-    baz().await;
-    let guard = x.read().unwrap();
-    47
-}
 
-async fn baz() -> u32 {
-    42
-}
+    pub async fn also_bad(x: &Mutex<u32>) -> u32 {
+        let first = baz().await;
+
+        let guard = x.lock().unwrap();
 
-async fn also_bad(x: &Mutex<u32>) -> u32 {
-    let first = baz().await;
+        let second = baz().await;
 
-    let guard = x.lock().unwrap();
+        let third = baz().await;
 
-    let second = baz().await;
+        first + second + third
+    }
+
+    pub async fn not_good(x: &Mutex<u32>) -> u32 {
+        let first = baz().await;
+
+        let second = {
+            let guard = x.lock().unwrap();
+            baz().await
+        };
 
-    let third = baz().await;
+        let third = baz().await;
 
-    first + second + third
+        first + second + third
+    }
+
+    #[allow(clippy::manual_async_fn)]
+    pub fn block_bad(x: &Mutex<u32>) -> impl std::future::Future<Output = u32> + '_ {
+        async move {
+            let guard = x.lock().unwrap();
+            baz().await
+        }
+    }
 }
 
-async fn not_good(x: &Mutex<u32>) -> u32 {
-    let first = baz().await;
+// When adding or modifying a test, please do the same for std::Mutex.
+mod parking_lot_mutex {
+    use parking_lot::{Mutex, RwLock};
 
-    let second = {
-        let guard = x.lock().unwrap();
+    pub async fn bad(x: &Mutex<u32>) -> u32 {
+        let guard = x.lock();
         baz().await
-    };
+    }
 
-    let third = baz().await;
+    pub async fn good(x: &Mutex<u32>) -> u32 {
+        {
+            let guard = x.lock();
+            let y = *guard + 1;
+        }
+        baz().await;
+        let guard = x.lock();
+        47
+    }
 
-    first + second + third
-}
+    pub async fn bad_rw(x: &RwLock<u32>) -> u32 {
+        let guard = x.read();
+        baz().await
+    }
 
-#[allow(clippy::manual_async_fn)]
-fn block_bad(x: &Mutex<u32>) -> impl std::future::Future<Output = u32> + '_ {
-    async move {
-        let guard = x.lock().unwrap();
+    pub async fn bad_rw_write(x: &RwLock<u32>) -> u32 {
+        let mut guard = x.write();
         baz().await
     }
+
+    pub async fn good_rw(x: &RwLock<u32>) -> u32 {
+        {
+            let guard = x.read();
+            let y = *guard + 1;
+        }
+        {
+            let mut guard = x.write();
+            *guard += 1;
+        }
+        baz().await;
+        let guard = x.read();
+        47
+    }
+
+    pub async fn baz() -> u32 {
+        42
+    }
+
+    pub async fn also_bad(x: &Mutex<u32>) -> u32 {
+        let first = baz().await;
+
+        let guard = x.lock();
+
+        let second = baz().await;
+
+        let third = baz().await;
+
+        first + second + third
+    }
+
+    pub async fn not_good(x: &Mutex<u32>) -> u32 {
+        let first = baz().await;
+
+        let second = {
+            let guard = x.lock();
+            baz().await
+        };
+
+        let third = baz().await;
+
+        first + second + third
+    }
+
+    #[allow(clippy::manual_async_fn)]
+    pub fn block_bad(x: &Mutex<u32>) -> impl std::future::Future<Output = u32> + '_ {
+        async move {
+            let guard = x.lock();
+            baz().await
+        }
+    }
 }
 
 fn main() {
-    let m = Mutex::new(100);
-    good(&m);
-    bad(&m);
-    also_bad(&m);
-    not_good(&m);
-    block_bad(&m);
+    let m = std::sync::Mutex::new(100);
+    std_mutex::good(&m);
+    std_mutex::bad(&m);
+    std_mutex::also_bad(&m);
+    std_mutex::not_good(&m);
+    std_mutex::block_bad(&m);
+
+    let m = parking_lot::Mutex::new(100);
+    parking_lot_mutex::good(&m);
+    parking_lot_mutex::bad(&m);
+    parking_lot_mutex::also_bad(&m);
+    parking_lot_mutex::not_good(&m);
 }