Use PhantomPinned in RWLock to enforce Pin usage.

Author: m-ou-se

library/std/src/sys_common/rwlock.rs

@@ -1,3 +1,4 @@
+use crate::marker::PhantomPinned;
 use crate::pin::Pin;
 use crate::sys::rwlock as imp;
 
@@ -6,22 +7,25 @@ use crate::sys::rwlock as imp;
 /// This structure is entirely unsafe and serves as the lowest layer of a
 /// cross-platform binding of system rwlocks. It is recommended to use the
 /// safer types at the top level of this crate instead of this type.
-pub struct RWLock(imp::RWLock);
+pub struct RWLock {
+    inner: imp::RWLock,
+    _pinned: PhantomPinned,
+}
 
 impl RWLock {
     /// Creates a new reader-writer lock for use.
     ///
     /// Behavior is undefined if the reader-writer lock is moved after it is
     /// first used with any of the functions below.
     pub const fn new() -> RWLock {
-        RWLock(imp::RWLock::new())
+        RWLock { inner: imp::RWLock::new(), _pinned: PhantomPinned }
     }
 
     /// Acquires shared access to the underlying lock, blocking the current
     /// thread to do so.
     #[inline]
     pub fn read(self: Pin<&Self>) {
-        unsafe { self.0.read() }
+        unsafe { self.inner.read() }
     }
 
     /// Attempts to acquire shared access to this lock, returning whether it
@@ -30,14 +34,14 @@ impl RWLock {
     /// This function does not block the current thread.
     #[inline]
     pub fn try_read(self: Pin<&Self>) -> bool {
-        unsafe { self.0.try_read() }
+        unsafe { self.inner.try_read() }
     }
 
     /// Acquires write access to the underlying lock, blocking the current thread
     /// to do so.
     #[inline]
     pub fn write(self: Pin<&Self>) {
-        unsafe { self.0.write() }
+        unsafe { self.inner.write() }
     }
 
     /// Attempts to acquire exclusive access to this lock, returning whether it
@@ -46,15 +50,15 @@ impl RWLock {
     /// This function does not block the current thread.
     #[inline]
     pub fn try_write(self: Pin<&Self>) -> bool {
-        unsafe { self.0.try_write() }
+        unsafe { self.inner.try_write() }
     }
 
     /// Unlocks previously acquired shared access to this lock.
     ///
     /// Behavior is undefined if the current thread does not have shared access.
     #[inline]
     pub unsafe fn read_unlock(self: Pin<&Self>) {
-        self.0.read_unlock()
+        self.inner.read_unlock()
     }
 
     /// Unlocks previously acquired exclusive access to this lock.
@@ -63,7 +67,7 @@ impl RWLock {
     /// exclusive access.
     #[inline]
     pub unsafe fn write_unlock(self: Pin<&Self>) {
-        self.0.write_unlock()
+        self.inner.write_unlock()
     }
 }
 
@@ -72,6 +76,6 @@ impl Drop for RWLock {
     fn drop(&mut self) {
         // SAFETY: The rwlock wasn't moved since using any of its
         // functions, because they all require a Pin.
-        unsafe { self.0.destroy() }
+        unsafe { self.inner.destroy() }
     }
 }