Add support for 'try_lock' (both with/without deadlock_detection).

Author: hydra

crates/epaint/src/mutex.rs

@@ -25,6 +25,11 @@ mod mutex_impl {
         pub fn lock(&self) -> MutexGuard<'_, T> {
             self.0.lock()
         }
+
+        #[inline(always)]
+        pub fn try_lock(&self) -> Option<MutexGuard<'_, T>> {
+            self.0.try_lock()
+        }
     }
 }
 
@@ -72,8 +77,12 @@ mod mutex_impl {
         }
 
         pub fn lock(&self) -> MutexGuard<'_, T> {
-            // Detect if we are recursively taking out a lock on this mutex.
+            let ptr = self.detect_recursive_lock();
+            MutexGuard(self.0.lock(), ptr)
+        }
 
+        /// Detect if we are recursively taking out a lock on this mutex.
+        fn detect_recursive_lock(&self) -> *const () {
             // use a pointer to the inner data as an id for this lock
             let ptr = std::ptr::from_ref::<parking_lot::Mutex<_>>(&self.0).cast::<()>();
 
@@ -82,7 +91,14 @@ mod mutex_impl {
                 held_locks.borrow_mut().insert(ptr);
             });
 
-            MutexGuard(self.0.lock(), ptr)
+            ptr
+        }
+
+        pub fn try_lock(&self) -> Option<MutexGuard<'_, T>> {
+            self.0.try_lock().map(|guard| {
+                let ptr = self.detect_recursive_lock();
+                MutexGuard(guard, ptr)
+            })
         }
 
         #[inline(always)]
@@ -389,6 +405,16 @@ mod tests {
         let _b = two.lock();
     }
 
+    #[test]
+    fn try_lock() {
+        let one = Mutex::new(());
+        let _a = one.try_lock().expect("lockable");
+        let _b = one.try_lock();
+        assert!(_b.is_none());
+        drop(_a);
+        let _c = one.try_lock().expect("lockable again");
+    }
+
     #[test]
     fn lock_multiple_threads() {
         use std::sync::Arc;