try_upgrade

Author: ShrigmaDev

Diff for: library/std/src/sync/poison/rwlock.rs

@@ -3,10 +3,12 @@ use crate::fmt;
 use crate::marker::PhantomData;
 use crate::mem::{self, ManuallyDrop, forget};
 use crate::ops::{Deref, DerefMut};
-use crate::ptr::NonNull;
+use crate::ptr::{NonNull};
 use crate::sync::{LockResult, PoisonError, TryLockError, TryLockResult, poison};
 use crate::sys::sync as sys;
 
+
+
 /// A reader-writer lock
 ///
 /// This type of lock allows a number of readers or at most one writer at any
@@ -919,19 +921,31 @@ impl<'a, T: ?Sized> RwLockReadGuard<'a, T> {
         }
     }
 
+    #[unstable(feature = "rwlock_try_upgrade", issue = "138559")]
     pub fn try_upgrade(orig: Self) -> Result<RwLockWriteGuard<'a, T>, RwLockReadGuard<'a, T>> {
-        let read_lock = orig.inner_lock;
+        let rwl = &RwLock{
+            data: UnsafeCell::new(orig.data.as_ptr().read()),
+            poison: poison::Flag::new(),
+            inner: *orig.inner_lock,
+        };
 
         // don't call the destructor
         forget(orig);
 
         // SAFETY: We have ownership of the read guard, so it must be in read mode already
-        match unsafe { read_lock.try_upgrade() } {
-            true => Ok(RwLockWriteGuard::new(read_lock).unwrap_or_else(PoisonError::into_inner)),
-            false => Err(RwLockReadGuard::new(read_lock).unwrap_or_else(PoisonError::into_inner)),
+        match unsafe { rwl.inner.try_upgrade() } {
+            true => Ok(RwLockWriteGuard::new(rwl).unwrap_or_else(PoisonError::into_inner)),
+            false => Err(RwLockReadGuard::new(rwl).unwrap_or_else(PoisonError::into_inner)),
         }
     }
 }
+fn f<'a, T>(a: sys::RwLock, b: NonNull<T>) -> RwLock<T>{
+     unsafe {RwLock{
+        inner: a,
+        data: UnsafeCell::new(b.as_ptr().read()),
+        poison: poison::Flag::new(),
+    }}
+}
 
 impl<'a, T: ?Sized> MappedRwLockReadGuard<'a, T> {
     /// Makes a [`MappedRwLockReadGuard`] for a component of the borrowed data,