Add new const_new function to lock_api

This new constructor allows creating mutexes, reentrant mutexes and
RwLocks in a constant context on stable Rust by manually passing in the
underlying raw mutex / rwlock.

lock_api/src/mutex.rs

@@ -95,7 +95,7 @@ pub unsafe trait RawMutexTimed: RawMutex {
 /// it is protecting. The data can only be accessed through the RAII guards
 /// returned from `lock` and `try_lock`, which guarantees that the data is only
 /// ever accessed when the mutex is locked.
-pub struct Mutex<R: RawMutex, T: ?Sized> {
+pub struct Mutex<R, T: ?Sized> {
     raw: R,
     data: UnsafeCell<T>,
 }
@@ -131,6 +131,18 @@ impl<R: RawMutex, T> Mutex<R, T> {
     }
 }
 
+impl<R, T> Mutex<R, T> {
+    /// Creates a new mutex based on a pre-existing raw mutex. This allows
+    /// creating a mutex in a constant context on stable Rust.
+    #[inline]
+    pub const fn const_new(raw_mutex: R, val: T) -> Mutex<R, T> {
+        Mutex {
+            raw: raw_mutex,
+            data: UnsafeCell::new(val),
+        }
+    }
+}
+
 impl<R: RawMutex, T: ?Sized> Mutex<R, T> {
     /// # Safety
     ///

lock_api/src/remutex.rs

@@ -47,7 +47,7 @@ pub unsafe trait GetThreadId {
     fn nonzero_thread_id(&self) -> NonZeroUsize;
 }
 
-struct RawReentrantMutex<R: RawMutex, G: GetThreadId> {
+struct RawReentrantMutex<R, G> {
     owner: AtomicUsize,
     lock_count: Cell<usize>,
     mutex: R,
@@ -145,7 +145,7 @@ impl<R: RawMutexTimed, G: GetThreadId> RawReentrantMutex<R, G> {
 ///
 /// See [`Mutex`](struct.Mutex.html) for more details about the underlying mutex
 /// primitive.
-pub struct ReentrantMutex<R: RawMutex, G: GetThreadId, T: ?Sized> {
+pub struct ReentrantMutex<R, G, T: ?Sized> {
     raw: RawReentrantMutex<R, G>,
     data: UnsafeCell<T>,
 }
@@ -197,6 +197,28 @@ impl<R: RawMutex, G: GetThreadId, T> ReentrantMutex<R, G, T> {
     }
 }
 
+impl<R, G, T> ReentrantMutex<R, G, T> {
+    /// Creates a new reentrant mutex based on a pre-existing raw reentrant
+    /// mutex and a helper to get the thread ID. This allows creating a
+    /// reentrant mutex in a constant context on stable Rust.
+    #[inline]
+    pub const fn const_new(
+        raw_reentrant_mutex: R,
+        get_thread_id: G,
+        val: T,
+    ) -> ReentrantMutex<R, G, T> {
+        ReentrantMutex {
+            data: UnsafeCell::new(val),
+            raw: RawReentrantMutex {
+                owner: AtomicUsize::new(0),
+                lock_count: Cell::new(0),
+                mutex: raw_reentrant_mutex,
+                get_thread_id,
+            },
+        }
+    }
+}
+
 impl<R: RawMutex, G: GetThreadId, T: ?Sized> ReentrantMutex<R, G, T> {
     /// # Safety
     ///

lock_api/src/rwlock.rs

@@ -231,7 +231,7 @@ pub unsafe trait RawRwLockUpgradeTimed: RawRwLockUpgrade + RawRwLockTimed {
 /// allow concurrent access through readers. The RAII guards returned from the
 /// locking methods implement `Deref` (and `DerefMut` for the `write` methods)
 /// to allow access to the contained of the lock.
-pub struct RwLock<R: RawRwLock, T: ?Sized> {
+pub struct RwLock<R, T: ?Sized> {
     raw: R,
     data: UnsafeCell<T>,
 }
@@ -297,6 +297,19 @@ impl<R: RawRwLock, T> RwLock<R, T> {
     }
 }
 
+impl<R, T> RwLock<R, T> {
+    /// Creates a new new instance of an `RwLock<T>` based on a pre-existing
+    /// `RawRwLock<T>`. This allows creating a `RwLock<T>` in a constant context
+    /// on stable Rust.
+    #[inline]
+    pub const fn const_new(raw_rwlock: R, val: T) -> RwLock<R, T> {
+        RwLock {
+            data: UnsafeCell::new(val),
+            raw: raw_rwlock,
+        }
+    }
+}
+
 impl<R: RawRwLock, T: ?Sized> RwLock<R, T> {
     /// # Safety
     ///