implement feature lock_value_accessors and mutex_data_ptr

Author: connortsui20

library/std/src/sync/nonpoison/mutex.rs

@@ -1,16 +1,17 @@
 use crate::cell::UnsafeCell;
 use crate::fmt;
 use crate::marker::PhantomData;
-use crate::mem::ManuallyDrop;
+use crate::mem::{self, ManuallyDrop};
 use crate::ops::{Deref, DerefMut};
 use crate::ptr::NonNull;
 use crate::sync::nonpoison::{TryLockResult, WouldBlock};
 use crate::sys::sync as sys;
 
-/// A mutual exclusion primitive useful for protecting shared data.
+/// A mutual exclusion primitive useful for protecting shared data that does not keep track of
+/// lock poisoning.
 ///
 /// For more information about mutexes, check out the documentation for the poisoning variant of
-/// this lock (which can be found at [`poison::Mutex`])
+/// this lock (which can be found at [`poison::Mutex`]).
 ///
 /// # Examples
 ///
@@ -259,6 +260,7 @@ impl<T> Mutex<T> {
     ///
     /// ```
     /// #![feature(nonpoison_mutex)]
+    ///
     /// use std::sync::nonpoison::Mutex;
     ///
     /// let mutex = Mutex::new(0);
@@ -269,7 +271,72 @@ impl<T> Mutex<T> {
         Mutex { inner: sys::Mutex::new(), data: UnsafeCell::new(t) }
     }
 
-    // FIXME: Add `lock_value_accessors` feature methods.
+    /// Returns the contained value by cloning it.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(nonpoison_mutex)]
+    /// #![feature(lock_value_accessors)]
+    ///
+    /// use std::sync::nonpoison::Mutex;
+    ///
+    /// let mut mutex = Mutex::new(7);
+    ///
+    /// assert_eq!(mutex.get_cloned(), 7);
+    /// ```
+    #[unstable(feature = "lock_value_accessors", issue = "133407")]
+    pub fn get_cloned(&self) -> T
+    where
+        T: Clone,
+    {
+        self.lock().clone()
+    }
+
+    /// Sets the contained value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(nonpoison_mutex)]
+    /// #![feature(lock_value_accessors)]
+    ///
+    /// use std::sync::nonpoison::Mutex;
+    ///
+    /// let mut mutex = Mutex::new(7);
+    ///
+    /// assert_eq!(mutex.get_cloned(), 7);
+    /// mutex.set(11);
+    /// assert_eq!(mutex.get_cloned(), 11);
+    /// ```
+    #[unstable(feature = "lock_value_accessors", issue = "133407")]
+    pub fn set(&self, value: T) {
+        let old = self.replace(value);
+        if mem::needs_drop::<T>() {
+            drop(old)
+        }
+    }
+
+    /// Replaces the contained value with `value`, and returns the old contained value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(nonpoison_mutex)]
+    /// #![feature(lock_value_accessors)]
+    ///
+    /// use std::sync::nonpoison::Mutex;
+    ///
+    /// let mut mutex = Mutex::new(7);
+    ///
+    /// assert_eq!(mutex.replace(11), 7);
+    /// assert_eq!(mutex.get_cloned(), 11);
+    /// ```
+    #[unstable(feature = "lock_value_accessors", issue = "133407")]
+    pub fn replace(&self, value: T) -> T {
+        let mut guard = self.lock();
+        mem::replace(&mut *guard, value)
+    }
 }
 
 impl<T: ?Sized> Mutex<T> {
@@ -293,6 +360,7 @@ impl<T: ?Sized> Mutex<T> {
     ///
     /// ```
     /// #![feature(nonpoison_mutex)]
+    ///
     /// use std::sync::{Arc, nonpoison::Mutex};
     /// use std::thread;
     ///
@@ -329,6 +397,7 @@ impl<T: ?Sized> Mutex<T> {
     ///
     /// ```
     /// #![feature(nonpoison_mutex)]
+    ///
     /// use std::sync::{Arc, nonpoison::Mutex};
     /// use std::thread;
     ///
@@ -356,6 +425,7 @@ impl<T: ?Sized> Mutex<T> {
     ///
     /// ```
     /// #![feature(nonpoison_mutex)]
+    ///
     /// use std::sync::nonpoison::Mutex;
     ///
     /// let mutex = Mutex::new(0);
@@ -378,6 +448,7 @@ impl<T: ?Sized> Mutex<T> {
     ///
     /// ```
     /// #![feature(nonpoison_mutex)]
+    ///
     /// use std::sync::nonpoison::Mutex;
     ///
     /// let mut mutex = Mutex::new(0);
@@ -389,7 +460,16 @@ impl<T: ?Sized> Mutex<T> {
         self.data.get_mut()
     }
 
-    // FIXME: Add `mutex_data_ptr` feature method.
+    /// Returns a raw pointer to the underlying data.
+    ///
+    /// The returned pointer is always non-null and properly aligned, but it is
+    /// the user's responsibility to ensure that any reads and writes through it
+    /// are properly synchronized to avoid data races, and that it is not read
+    /// or written through after the mutex is dropped.
+    #[unstable(feature = "mutex_data_ptr", issue = "140368")]
+    pub fn data_ptr(&self) -> *mut T {
+        self.data.get()
+    }
 }
 
 #[unstable(feature = "nonpoison_mutex", issue = "134645")]

library/std/tests/sync/mutex.rs

@@ -10,7 +10,8 @@ use std::{hint, mem, thread};
 //
 // To write a test that uses both `poison::Mutex` and `nonpoison::Mutex`, simply call the macro
 // `maybe_unwrap!(...)` on the result of `mutex.lock()`. For the `poison::Mutex`, it will unwrap the
-// `LockResult`, but for the `nonpoison::Mutex` it will do nothing.
+// `Result` (usually `LockResult`, but it could be other kinds of results), but for the
+// `nonpoison::Mutex` it will do nothing.
 //
 // The `poison` test will have the same name, but with a suffix of `_unwrap_poisoned`.
 //
@@ -38,11 +39,11 @@ macro_rules! nonpoison_and_poison_unwrap_test {
         #[test]
         fn ${concat($name, _unwrap_poisoned)}() {
             #[allow(unused_imports)]
-            use ::std::sync::{Mutex, MappedMutexGuard, MutexGuard, LockResult};
+            use ::std::sync::{Mutex, MappedMutexGuard, MutexGuard};
 
             #[allow(unused_macros)]
             macro_rules! maybe_unwrap {
-                ($e:expr) => { LockResult::unwrap($e) };
+                ($e:expr) => { Result::unwrap($e) };
             }
 
             $($test_body)*
@@ -151,17 +152,6 @@ nonpoison_and_poison_unwrap_test!(
     }
 );
 
-// TODO(connor): make this a double test after implementing `lock_value_accessors` on `nonpoison`.
-#[test]
-fn test_get_cloned() {
-    #[derive(Clone, Eq, PartialEq, Debug)]
-    struct Cloneable(i32);
-
-    let m = Mutex::new(Cloneable(10));
-
-    assert_eq!(m.get_cloned().unwrap(), Cloneable(10));
-}
-
 nonpoison_and_poison_unwrap_test!(
     name: test_get_mut,
     test_body: {
@@ -171,41 +161,55 @@ nonpoison_and_poison_unwrap_test!(
     }
 );
 
-// TODO(connor): make this a double test after implementing `lock_value_accessors` on `nonpoison`.
-#[test]
-fn test_set() {
-    fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
-    where
-        T: Debug + Eq,
-    {
-        let m = Mutex::new(init());
+nonpoison_and_poison_unwrap_test!(
+    name: test_get_cloned,
+    test_body: {
+        #[derive(Clone, Eq, PartialEq, Debug)]
+        struct Cloneable(i32);
+
+        let m = Mutex::new(Cloneable(10));
 
-        assert_eq!(*m.lock().unwrap(), init());
-        m.set(value()).unwrap();
-        assert_eq!(*m.lock().unwrap(), value());
+        assert_eq!(maybe_unwrap!(m.get_cloned()), Cloneable(10));
     }
+);
 
-    inner(|| NonCopy(10), || NonCopy(20));
-    inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
-}
+nonpoison_and_poison_unwrap_test!(
+    name: test_set,
+    test_body: {
+        fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
+        where
+            T: Debug + Eq,
+        {
+            let m = Mutex::new(init());
 
-// TODO(connor): make this a double test after implementing `lock_value_accessors` on `nonpoison`.
-#[test]
-fn test_replace() {
-    fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
-    where
-        T: Debug + Eq,
-    {
-        let m = Mutex::new(init());
+            assert_eq!(*maybe_unwrap!(m.lock()), init());
+            maybe_unwrap!(m.set(value()));
+            assert_eq!(*maybe_unwrap!(m.lock()), value());
+        }
 
-        assert_eq!(*m.lock().unwrap(), init());
-        assert_eq!(m.replace(value()).unwrap(), init());
-        assert_eq!(*m.lock().unwrap(), value());
+        inner(|| NonCopy(10), || NonCopy(20));
+        inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
     }
+);
 
-    inner(|| NonCopy(10), || NonCopy(20));
-    inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
-}
+nonpoison_and_poison_unwrap_test!(
+    name: test_replace,
+    test_body: {
+        fn inner<T>(mut init: impl FnMut() -> T, mut value: impl FnMut() -> T)
+        where
+            T: Debug + Eq,
+        {
+            let m = Mutex::new(init());
+
+            assert_eq!(*maybe_unwrap!(m.lock()), init());
+            assert_eq!(maybe_unwrap!(m.replace(value())), init());
+            assert_eq!(*maybe_unwrap!(m.lock()), value());
+        }
+
+        inner(|| NonCopy(10), || NonCopy(20));
+        inner(|| NonCopyNeedsDrop(10), || NonCopyNeedsDrop(20));
+    }
+);
 
 #[test]
 fn test_mutex_arc_condvar() {