From 44a2af32ccc4c71c5e8bc9cb79c9042c6e608ce8 Mon Sep 17 00:00:00 2001 From: Mara Bos Date: Wed, 7 Oct 2020 14:08:33 +0200 Subject: Remove lifetime from StaticMutex and assume 'static. StaticMutex is only ever used with as a static (as the name already suggests). So it doesn't have to be generic over a lifetime, but can simply assume 'static. This 'static lifetime guarantees the object is never moved, so this is no longer a manually checked requirement for unsafe calls to lock(). --- library/std/src/sys_common/mutex.rs | 17 +++++------------ 1 file changed, 5 insertions(+), 12 deletions(-) (limited to 'library/std/src/sys_common') diff --git a/library/std/src/sys_common/mutex.rs b/library/std/src/sys_common/mutex.rs index 47fa7539330..f3e7efb955a 100644 --- a/library/std/src/sys_common/mutex.rs +++ b/library/std/src/sys_common/mutex.rs @@ -3,8 +3,7 @@ use crate::sys::mutex as imp; /// An OS-based mutual exclusion lock, meant for use in static variables. /// /// This mutex has a const constructor ([`StaticMutex::new`]), does not -/// implement `Drop` to cleanup resources, and causes UB when moved or used -/// reentrantly. +/// implement `Drop` to cleanup resources, and causes UB when used reentrantly. /// /// This mutex does not implement poisoning. /// @@ -16,11 +15,6 @@ unsafe impl Sync for StaticMutex {} impl StaticMutex { /// Creates a new mutex for use. - /// - /// Behavior is undefined if the mutex is moved after it is - /// first used with any of the functions below. - /// Also, the behavior is undefined if this mutex is ever used reentrantly, - /// i.e., `lock` is called by the thread currently holding the lock. pub const fn new() -> Self { Self(imp::Mutex::new()) } @@ -29,19 +23,18 @@ impl StaticMutex { /// will be unlocked. /// /// It is undefined behaviour to call this function while locked by the - /// same thread, or if the mutex has been moved since the last time this - /// was called. + /// same thread. #[inline] - pub unsafe fn lock(&self) -> StaticMutexGuard<'_> { + pub unsafe fn lock(&'static self) -> StaticMutexGuard { self.0.lock(); StaticMutexGuard(&self.0) } } #[must_use] -pub struct StaticMutexGuard<'a>(&'a imp::Mutex); +pub struct StaticMutexGuard(&'static imp::Mutex); -impl Drop for StaticMutexGuard<'_> { +impl Drop for StaticMutexGuard { #[inline] fn drop(&mut self) { unsafe { -- cgit 1.4.1-3-g733a5