From fc875b087cdd844fa61204db30c287f3c3179d92 Mon Sep 17 00:00:00 2001 From: Jonathan Reem Date: Sat, 30 Jan 2016 16:39:03 -0800 Subject: [PATCH] Add issue number to guard map methods. --- src/libstd/sync/mutex.rs | 46 +++++++++++++--------- src/libstd/sync/rwlock.rs | 81 ++++++++++++++++++++++++--------------- 2 files changed, 78 insertions(+), 49 deletions(-) diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs index ab566f3f94583..a6ab54730762d 100644 --- a/src/libstd/sync/mutex.rs +++ b/src/libstd/sync/mutex.rs @@ -211,8 +211,10 @@ impl Mutex { /// this call will return an error once the mutex is acquired. #[stable(feature = "rust1", since = "1.0.0")] pub fn lock(&self) -> LockResult> { - unsafe { self.inner.lock.lock() } - unsafe { MutexGuard::new(&*self.inner, &self.data) } + unsafe { + self.inner.lock.lock(); + MutexGuard::new(&*self.inner, &self.data) + } } /// Attempts to acquire this lock. @@ -230,10 +232,12 @@ impl Mutex { /// acquired. #[stable(feature = "rust1", since = "1.0.0")] pub fn try_lock(&self) -> TryLockResult> { - if unsafe { self.inner.lock.try_lock() } { - Ok(try!(unsafe { MutexGuard::new(&*self.inner, &self.data) })) - } else { - Err(TryLockError::WouldBlock) + unsafe { + if self.inner.lock.try_lock() { + Ok(try!(MutexGuard::new(&*self.inner, &self.data))) + } else { + Err(TryLockError::WouldBlock) + } } } @@ -338,17 +342,21 @@ impl StaticMutex { /// Acquires this lock, see `Mutex::lock` #[inline] pub fn lock(&'static self) -> LockResult> { - unsafe { self.lock.lock() } - unsafe { MutexGuard::new(self, &DUMMY.0) } + unsafe { + self.lock.lock(); + MutexGuard::new(self, &DUMMY.0) + } } /// Attempts to grab this lock, see `Mutex::try_lock` #[inline] pub fn try_lock(&'static self) -> TryLockResult> { - if unsafe { self.lock.try_lock() } { - Ok(try!(unsafe { MutexGuard::new(self, &DUMMY.0) })) - } else { - Err(TryLockError::WouldBlock) + unsafe { + if self.lock.try_lock() { + Ok(try!(MutexGuard::new(self, &DUMMY.0))) + } else { + Err(TryLockError::WouldBlock) + } } } @@ -393,17 +401,18 @@ impl<'mutex, T: ?Sized> MutexGuard<'mutex, T> { /// let x = Mutex::new(vec![1, 2]); /// /// { - /// let y = MutexGuard::map(x.lock().unwrap(), |v| &mut v[0]); + /// let mut y = MutexGuard::map(x.lock().unwrap(), |v| &mut v[0]); /// *y = 3; /// } /// - /// assert_eq!(&*x.lock(), &[3, 2]); + /// assert_eq!(&*x.lock().unwrap(), &[3, 2]); /// ``` #[unstable(feature = "guard_map", reason = "recently added, needs RFC for stabilization", - issue = "0")] + issue = "27746")] pub fn map(this: Self, cb: F) -> MutexGuard<'mutex, U> - where F: FnOnce(&'mutex mut T) -> &'mutex mut U { + where F: FnOnce(&'mutex mut T) -> &'mutex mut U + { // Compute the new data while still owning the original lock // in order to correctly poison if the callback panics. let data = unsafe { ptr::read(&this.__data) }; @@ -411,8 +420,9 @@ impl<'mutex, T: ?Sized> MutexGuard<'mutex, T> { // We don't want to unlock the lock by running the destructor of the // original lock, so just read the fields we need and forget it. - let poison = unsafe { ptr::read(&this.__poison) }; - let lock = unsafe { ptr::read(&this.__lock) }; + let (poison, lock) = unsafe { + (ptr::read(&this.__poison), ptr::read(&this.__lock)) + }; mem::forget(this); MutexGuard { diff --git a/src/libstd/sync/rwlock.rs b/src/libstd/sync/rwlock.rs index 7c1fcd6dea7c7..2b3233b2dabef 100644 --- a/src/libstd/sync/rwlock.rs +++ b/src/libstd/sync/rwlock.rs @@ -177,8 +177,10 @@ impl RwLock { #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn read(&self) -> LockResult> { - unsafe { self.inner.lock.read() } - unsafe { RwLockReadGuard::new(&*self.inner, &self.data) } + unsafe { + self.inner.lock.read(); + RwLockReadGuard::new(&*self.inner, &self.data) + } } /// Attempts to acquire this rwlock with shared read access. @@ -201,10 +203,12 @@ impl RwLock { #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn try_read(&self) -> TryLockResult> { - if unsafe { self.inner.lock.try_read() } { - Ok(try!(unsafe { RwLockReadGuard::new(&*self.inner, &self.data) })) - } else { - Err(TryLockError::WouldBlock) + unsafe { + if self.inner.lock.try_read() { + Ok(try!(RwLockReadGuard::new(&*self.inner, &self.data))) + } else { + Err(TryLockError::WouldBlock) + } } } @@ -225,8 +229,10 @@ impl RwLock { #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn write(&self) -> LockResult> { - unsafe { self.inner.lock.write() } - unsafe { RwLockWriteGuard::new(&*self.inner, &self.data) } + unsafe { + self.inner.lock.write(); + RwLockWriteGuard::new(&*self.inner, &self.data) + } } /// Attempts to lock this rwlock with exclusive write access. @@ -249,10 +255,12 @@ impl RwLock { #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn try_write(&self) -> TryLockResult> { - if unsafe { self.inner.lock.try_write() } { - Ok(try!(unsafe { RwLockWriteGuard::new(&*self.inner, &self.data) })) - } else { - Err(TryLockError::WouldBlock) + unsafe { + if self.inner.lock.try_write() { + Ok(try!(RwLockWriteGuard::new(&*self.inner, &self.data))) + } else { + Err(TryLockError::WouldBlock) + } } } @@ -360,8 +368,10 @@ impl StaticRwLock { /// See `RwLock::read`. #[inline] pub fn read(&'static self) -> LockResult> { - unsafe { self.lock.read() } - unsafe { RwLockReadGuard::new(self, &DUMMY.0) } + unsafe { + self.lock.read(); + RwLockReadGuard::new(self, &DUMMY.0) + } } /// Attempts to acquire this lock with shared read access. @@ -370,10 +380,12 @@ impl StaticRwLock { #[inline] pub fn try_read(&'static self) -> TryLockResult> { - if unsafe { self.lock.try_read() } { - unsafe { Ok(try!(RwLockReadGuard::new(self, &DUMMY.0))) } - } else { - Err(TryLockError::WouldBlock) + unsafe { + if self.lock.try_read(){ + Ok(try!(RwLockReadGuard::new(self, &DUMMY.0))) + } else { + Err(TryLockError::WouldBlock) + } } } @@ -383,8 +395,10 @@ impl StaticRwLock { /// See `RwLock::write`. #[inline] pub fn write(&'static self) -> LockResult> { - unsafe { self.lock.write() } - unsafe { RwLockWriteGuard::new(self, &DUMMY.0) } + unsafe { + self.lock.write(); + RwLockWriteGuard::new(self, &DUMMY.0) + } } /// Attempts to lock this rwlock with exclusive write access. @@ -393,10 +407,12 @@ impl StaticRwLock { #[inline] pub fn try_write(&'static self) -> TryLockResult> { - if unsafe { self.lock.try_write() } { - Ok(unsafe { try!(RwLockWriteGuard::new(self, &DUMMY.0)) }) - } else { - Err(TryLockError::WouldBlock) + unsafe { + if self.lock.try_write() { + Ok(try!(RwLockWriteGuard::new(self, &DUMMY.0))) + } else { + Err(TryLockError::WouldBlock) + } } } @@ -439,9 +455,10 @@ impl<'rwlock, T: ?Sized> RwLockReadGuard<'rwlock, T> { /// ``` #[unstable(feature = "guard_map", reason = "recently added, needs RFC for stabilization", - issue = "0")] + issue = "27746")] pub fn map(this: Self, cb: F) -> RwLockReadGuard<'rwlock, U> - where F: FnOnce(&'rwlock T) -> &'rwlock U { + where F: FnOnce(&'rwlock T) -> &'rwlock U + { let new = RwLockReadGuard { __lock: this.__lock, __data: cb(this.__data) @@ -478,7 +495,7 @@ impl<'rwlock, T: ?Sized> RwLockWriteGuard<'rwlock, T> { /// let x = RwLock::new(vec![1, 2]); /// /// { - /// let y = RwLockWriteGuard::map(x.write().unwrap(), |v| &mut v[0]); + /// let mut y = RwLockWriteGuard::map(x.write().unwrap(), |v| &mut v[0]); /// assert_eq!(*y, 1); /// /// *y = 10; @@ -488,9 +505,10 @@ impl<'rwlock, T: ?Sized> RwLockWriteGuard<'rwlock, T> { /// ``` #[unstable(feature = "guard_map", reason = "recently added, needs RFC for stabilization", - issue = "0")] + issue = "27746")] pub fn map(this: Self, cb: F) -> RwLockWriteGuard<'rwlock, U> - where F: FnOnce(&'rwlock mut T) -> &'rwlock mut U { + where F: FnOnce(&'rwlock mut T) -> &'rwlock mut U + { // Compute the new data while still owning the original lock // in order to correctly poison if the callback panics. let data = unsafe { ptr::read(&this.__data) }; @@ -498,8 +516,9 @@ impl<'rwlock, T: ?Sized> RwLockWriteGuard<'rwlock, T> { // We don't want to unlock the lock by running the destructor of the // original lock, so just read the fields we need and forget it. - let poison = unsafe { ptr::read(&this.__poison) }; - let lock = unsafe { ptr::read(&this.__lock) }; + let (poison, lock) = unsafe { + (ptr::read(&this.__poison), ptr::read(&this.__lock)) + }; mem::forget(this); RwLockWriteGuard {