---

yaml
---
r: 206535
b: refs/heads/beta
c: 7529bd6
h: refs/heads/master
i:
  206533: 18017d4
  206531: 99b13b5
  206527: beef084
v: v3

Author: alexcrichton

[refs]

@@ -29,7 +29,7 @@ refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/batch: b7fd822592a4fb577552d93010c4a4e14f314346
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
-refs/heads/beta: a031325e83b8f050f840395239197ea87361ada5
+refs/heads/beta: 7529bd60c3cbc4c7b635ee43a89d5b14f6fb8bf7
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 579e31929feff51dcaf8d444648eff8de735f91a

branches/beta/src/libstd/sys/common/remutex.rs

@@ -19,9 +19,9 @@ use sys::mutex as sys;
 
 /// A re-entrant mutual exclusion
 ///
-/// This mutex will block *other* threads waiting for the lock to become available. The thread
-/// which has already locked the mutex can lock it multiple times without blocking, preventing a
-/// common source of deadlocks.
+/// This mutex will block *other* threads waiting for the lock to become
+/// available. The thread which has already locked the mutex can lock it
+/// multiple times without blocking, preventing a common source of deadlocks.
 pub struct ReentrantMutex<T> {
     inner: Box<sys::ReentrantMutex>,
     poison: poison::Flag,
@@ -51,10 +51,14 @@ impl<'a, T> !marker::Send for ReentrantMutexGuard<'a, T> {}
 impl<T> ReentrantMutex<T> {
     /// Creates a new reentrant mutex in an unlocked state.
     pub fn new(t: T) -> ReentrantMutex<T> {
-        ReentrantMutex {
-            inner: box unsafe { sys::ReentrantMutex::new() },
-            poison: poison::FLAG_INIT,
-            data: t,
+        unsafe {
+            let mut mutex = ReentrantMutex {
+                inner: box sys::ReentrantMutex::uninitialized(),
+                poison: poison::FLAG_INIT,
+                data: t,
+            };
+            mutex.inner.init();
+            return mutex
         }
     }
 

branches/beta/src/libstd/sys/unix/mutex.rs

@@ -69,30 +69,27 @@ impl Mutex {
     }
 }
 
-// FIXME: remove the box, because box happens twice now, once at the common layer and once here.
-// Box is necessary here, because mutex may not change address after it is intialised on some
-// platforms. Regular Mutex above handles this by offloading intialisation to the OS on first lock.
-// Sadly, as far as reentrant mutexes go, this scheme is not quite portable and we must initialise
-// when we create the mutex, in the `new`.
-pub struct ReentrantMutex { inner: Box<UnsafeCell<ffi::pthread_mutex_t>> }
+pub struct ReentrantMutex { inner: UnsafeCell<ffi::pthread_mutex_t> }
 
 unsafe impl Send for ReentrantMutex {}
 unsafe impl Sync for ReentrantMutex {}
 
 impl ReentrantMutex {
-    pub unsafe fn new() -> ReentrantMutex {
-        let mutex = ReentrantMutex { inner: box mem::uninitialized() };
+    pub unsafe fn uninitialized() -> ReentrantMutex {
+        ReentrantMutex { inner: mem::uninitialized() }
+    }
+
+    pub unsafe fn init(&mut self) {
         let mut attr: ffi::pthread_mutexattr_t = mem::uninitialized();
         let result = ffi::pthread_mutexattr_init(&mut attr as *mut _);
         debug_assert_eq!(result, 0);
         let result = ffi::pthread_mutexattr_settype(&mut attr as *mut _,
                                                     ffi::PTHREAD_MUTEX_RECURSIVE);
         debug_assert_eq!(result, 0);
-        let result = ffi::pthread_mutex_init(mutex.inner.get(), &attr as *const _);
+        let result = ffi::pthread_mutex_init(self.inner.get(), &attr as *const _);
         debug_assert_eq!(result, 0);
         let result = ffi::pthread_mutexattr_destroy(&mut attr as *mut _);
         debug_assert_eq!(result, 0);
-        mutex
     }
 
     pub unsafe fn lock(&self) {

branches/beta/src/libstd/sys/windows/mutex.rs

@@ -59,16 +59,18 @@ impl Mutex {
     }
 }
 
-pub struct ReentrantMutex { inner: Box<UnsafeCell<ffi::CRITICAL_SECTION>> }
+pub struct ReentrantMutex { inner: UnsafeCell<ffi::CRITICAL_SECTION> }
 
 unsafe impl Send for ReentrantMutex {}
 unsafe impl Sync for ReentrantMutex {}
 
 impl ReentrantMutex {
-    pub unsafe fn new() -> ReentrantMutex {
-        let mutex = ReentrantMutex { inner: box mem::uninitialized() };
-        ffi::InitializeCriticalSection(mutex.inner.get());
-        mutex
+    pub unsafe fn uninitialized() -> ReentrantMutex {
+        mem::uninitialized()
+    }
+
+    pub unsafe fn init(&mut self) {
+        ffi::InitializeCriticalSection(self.inner.get());
     }
 
     pub unsafe fn lock(&self) {