Auto merge of #25136 - alexcrichton:drop-the-two, r=aturon

* Remove the 2-suffix from some modules
* Remove some unused files
* Remove double-boxing for `ReentrantMutex`

33 files changed, 72 insertions, 239 deletions

diff --git a/src/libstd/fs.rs b/src/libstd/fs.rs
index 5a05c61e064..fc5405ea7f6 100644
--- a/src/libstd/fs.rs
+++ b/src/libstd/fs.rs
@@ -23,7 +23,7 @@ use fmt;
 use ffi::OsString;
 use io::{self, Error, ErrorKind, SeekFrom, Seek, Read, Write};
 use path::{Path, PathBuf};
-use sys::fs2 as fs_imp;
+use sys::fs as fs_imp;
 use sys_common::{AsInnerMut, FromInner, AsInner};
 use vec::Vec;
 
diff --git a/src/libstd/net/mod.rs b/src/libstd/net/mod.rs
index bf444ce671d..bff9774bcd0 100644
--- a/src/libstd/net/mod.rs
+++ b/src/libstd/net/mod.rs
@@ -15,7 +15,7 @@
 use prelude::v1::*;
 
 use io::{self, Error, ErrorKind};
-use sys_common::net2 as net_imp;
+use sys_common::net as net_imp;
 
 pub use self::ip::{IpAddr, Ipv4Addr, Ipv6Addr, Ipv6MulticastScope};
 pub use self::addr::{SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
diff --git a/src/libstd/net/tcp.rs b/src/libstd/net/tcp.rs
index c0d880877b5..db2cdb73198 100644
--- a/src/libstd/net/tcp.rs
+++ b/src/libstd/net/tcp.rs
@@ -17,7 +17,7 @@ use io::prelude::*;
 use fmt;
 use io;
 use net::{ToSocketAddrs, SocketAddr, Shutdown};
-use sys_common::net2 as net_imp;
+use sys_common::net as net_imp;
 use sys_common::{AsInner, FromInner};
 
 /// A structure which represents a TCP stream between a local socket and a
diff --git a/src/libstd/net/udp.rs b/src/libstd/net/udp.rs
index 4360f62c1bf..67c7096904d 100644
--- a/src/libstd/net/udp.rs
+++ b/src/libstd/net/udp.rs
@@ -16,7 +16,7 @@ use prelude::v1::*;
 use fmt;
 use io::{self, Error, ErrorKind};
 use net::{ToSocketAddrs, SocketAddr, IpAddr};
-use sys_common::net2 as net_imp;
+use sys_common::net as net_imp;
 use sys_common::{AsInner, FromInner};
 
 /// A User Datagram Protocol socket.
diff --git a/src/libstd/os/android/mod.rs b/src/libstd/os/android/mod.rs
index 346a903c4d9..a94abba5d12 100644
--- a/src/libstd/os/android/mod.rs
+++ b/src/libstd/os/android/mod.rs
@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs2::MetadataExt;
+    pub use sys::fs::MetadataExt;
 }
diff --git a/src/libstd/os/bitrig/mod.rs b/src/libstd/os/bitrig/mod.rs
index 01ea542b3b7..1fe5fdd4e14 100644
--- a/src/libstd/os/bitrig/mod.rs
+++ b/src/libstd/os/bitrig/mod.rs
@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs2::MetadataExt;
+    pub use sys::fs::MetadataExt;
 }
diff --git a/src/libstd/os/dragonfly/mod.rs b/src/libstd/os/dragonfly/mod.rs
index 677f8b706cd..d5c7c581733 100644
--- a/src/libstd/os/dragonfly/mod.rs
+++ b/src/libstd/os/dragonfly/mod.rs
@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs2::MetadataExt;
+    pub use sys::fs::MetadataExt;
 }
diff --git a/src/libstd/os/freebsd/mod.rs b/src/libstd/os/freebsd/mod.rs
index 73b6fd21137..28c9f8321f8 100644
--- a/src/libstd/os/freebsd/mod.rs
+++ b/src/libstd/os/freebsd/mod.rs
@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs2::MetadataExt;
+    pub use sys::fs::MetadataExt;
 }
diff --git a/src/libstd/os/ios/mod.rs b/src/libstd/os/ios/mod.rs
index d471cf12fe6..dd2878c6e38 100644
--- a/src/libstd/os/ios/mod.rs
+++ b/src/libstd/os/ios/mod.rs
@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs2::MetadataExt;
+    pub use sys::fs::MetadataExt;
 }
diff --git a/src/libstd/os/linux/mod.rs b/src/libstd/os/linux/mod.rs
index 43376a1baeb..d2f9bcc3bcf 100644
--- a/src/libstd/os/linux/mod.rs
+++ b/src/libstd/os/linux/mod.rs
@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs2::MetadataExt;
+    pub use sys::fs::MetadataExt;
 }
diff --git a/src/libstd/os/macos/mod.rs b/src/libstd/os/macos/mod.rs
index bc5ff5b25d2..6c96909f382 100644
--- a/src/libstd/os/macos/mod.rs
+++ b/src/libstd/os/macos/mod.rs
@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs2::MetadataExt;
+    pub use sys::fs::MetadataExt;
 }
diff --git a/src/libstd/os/nacl/mod.rs b/src/libstd/os/nacl/mod.rs
index 6baed039514..413bb72f6e1 100644
--- a/src/libstd/os/nacl/mod.rs
+++ b/src/libstd/os/nacl/mod.rs
@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs2::MetadataExt;
+    pub use sys::fs::MetadataExt;
 }
diff --git a/src/libstd/os/openbsd/mod.rs b/src/libstd/os/openbsd/mod.rs
index 1b1a1005590..5654a7a0229 100644
--- a/src/libstd/os/openbsd/mod.rs
+++ b/src/libstd/os/openbsd/mod.rs
@@ -15,5 +15,5 @@
 pub mod raw;
 
 pub mod fs {
-    pub use sys::fs2::MetadataExt;
+    pub use sys::fs::MetadataExt;
 }
diff --git a/src/libstd/process.rs b/src/libstd/process.rs
index 8f8699f4b9f..61398e16ba0 100644
--- a/src/libstd/process.rs
+++ b/src/libstd/process.rs
@@ -21,11 +21,11 @@ use fmt;
 use io::{self, Error, ErrorKind};
 use path;
 use sync::mpsc::{channel, Receiver};
-use sys::pipe2::{self, AnonPipe};
-use sys::process2::Command as CommandImp;
-use sys::process2::Process as ProcessImp;
-use sys::process2::ExitStatus as ExitStatusImp;
-use sys::process2::Stdio as StdioImp2;
+use sys::pipe::{self, AnonPipe};
+use sys::process::Command as CommandImp;
+use sys::process::Process as ProcessImp;
+use sys::process::ExitStatus as ExitStatusImp;
+use sys::process::Stdio as StdioImp2;
 use sys_common::{AsInner, AsInnerMut};
 use thread;
 
@@ -334,7 +334,7 @@ fn setup_io(io: &StdioImp, readable: bool)
         Null => (StdioImp2::None, None),
         Inherit => (StdioImp2::Inherit, None),
         Piped => {
-            let (reader, writer) = try!(pipe2::anon_pipe());
+            let (reader, writer) = try!(pipe::anon_pipe());
             if readable {
                 (StdioImp2::Piped(reader), Some(writer))
             } else {
diff --git a/src/libstd/sys/common/helper_thread.rs b/src/libstd/sys/common/helper_thread.rs
deleted file mode 100644
index 34a58f6c83a..00000000000
--- a/src/libstd/sys/common/helper_thread.rs
+++ /dev/null
@@ -1,170 +0,0 @@
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Implementation of the helper thread for the timer module
-//!
-//! This module contains the management necessary for the timer worker thread.
-//! This thread is responsible for performing the send()s on channels for timers
-//! that are using channels instead of a blocking call.
-//!
-//! The timer thread is lazily initialized, and it's shut down via the
-//! `shutdown` function provided. It must be maintained as an invariant that
-//! `shutdown` is only called when the entire program is finished. No new timers
-//! can be created in the future and there must be no active timers at that
-//! time.
-
-use prelude::v1::*;
-
-use boxed;
-use cell::UnsafeCell;
-use rt;
-use sync::{StaticMutex, StaticCondvar};
-use sync::mpsc::{channel, Sender, Receiver};
-use sys::helper_signal;
-
-use thread;
-
-/// A structure for management of a helper thread.
-///
-/// This is generally a static structure which tracks the lifetime of a helper
-/// thread.
-///
-/// The fields of this helper are all public, but they should not be used, this
-/// is for static initialization.
-pub struct Helper<M:Send> {
-    /// Internal lock which protects the remaining fields
-    pub lock: StaticMutex,
-    pub cond: StaticCondvar,
-
-    // You'll notice that the remaining fields are UnsafeCell<T>, and this is
-    // because all helper thread operations are done through &self, but we need
-    // these to be mutable (once `lock` is held).
-
-    /// Lazily allocated channel to send messages to the helper thread.
-    pub chan: UnsafeCell<*mut Sender<M>>,
-
-    /// OS handle used to wake up a blocked helper thread
-    pub signal: UnsafeCell<usize>,
-
-    /// Flag if this helper thread has booted and been initialized yet.
-    pub initialized: UnsafeCell<bool>,
-
-    /// Flag if this helper thread has shut down
-    pub shutdown: UnsafeCell<bool>,
-}
-
-unsafe impl<M:Send> Send for Helper<M> { }
-
-unsafe impl<M:Send> Sync for Helper<M> { }
-
-struct RaceBox(helper_signal::signal);
-
-unsafe impl Send for RaceBox {}
-unsafe impl Sync for RaceBox {}
-
-macro_rules! helper_init { (static $name:ident: Helper<$m:ty>) => (
-    static $name: Helper<$m> = Helper {
-        lock: ::sync::MUTEX_INIT,
-        cond: ::sync::CONDVAR_INIT,
-        chan: ::cell::UnsafeCell { value: 0 as *mut Sender<$m> },
-        signal: ::cell::UnsafeCell { value: 0 },
-        initialized: ::cell::UnsafeCell { value: false },
-        shutdown: ::cell::UnsafeCell { value: false },
-    };
-) }
-
-impl<M: Send> Helper<M> {
-    /// Lazily boots a helper thread, becoming a no-op if the helper has already
-    /// been spawned.
-    ///
-    /// This function will check to see if the thread has been initialized, and
-    /// if it has it returns quickly. If initialization has not happened yet,
-    /// the closure `f` will be run (inside of the initialization lock) and
-    /// passed to the helper thread in a separate task.
-    ///
-    /// This function is safe to be called many times.
-    pub fn boot<T, F>(&'static self, f: F, helper: fn(helper_signal::signal, Receiver<M>, T)) where
-        T: Send + 'static,
-        F: FnOnce() -> T,
-    {
-        unsafe {
-            let _guard = self.lock.lock().unwrap();
-            if *self.chan.get() as usize == 0 {
-                let (tx, rx) = channel();
-                *self.chan.get() = boxed::into_raw(box tx);
-                let (receive, send) = helper_signal::new();
-                *self.signal.get() = send as usize;
-
-                let receive = RaceBox(receive);
-
-                let t = f();
-                thread::spawn(move || {
-                    helper(receive.0, rx, t);
-                    let _g = self.lock.lock().unwrap();
-                    *self.shutdown.get() = true;
-                    self.cond.notify_one()
-                });
-
-                let _ = rt::at_exit(move || { self.shutdown() });
-                *self.initialized.get() = true;
-            } else if *self.chan.get() as usize == 1 {
-                panic!("cannot continue usage after shutdown");
-            }
-        }
-    }
-
-    /// Sends a message to a spawned worker thread.
-    ///
-    /// This is only valid if the worker thread has previously booted
-    pub fn send(&'static self, msg: M) {
-        unsafe {
-            let _guard = self.lock.lock().unwrap();
-
-            // Must send and *then* signal to ensure that the child receives the
-            // message. Otherwise it could wake up and go to sleep before we
-            // send the message.
-            assert!(*self.chan.get() as usize != 0);
-            assert!(*self.chan.get() as usize != 1,
-                    "cannot continue usage after shutdown");
-            (**self.chan.get()).send(msg).unwrap();
-            helper_signal::signal(*self.signal.get() as helper_signal::signal);
-        }
-    }
-
-    fn shutdown(&'static self) {
-        unsafe {
-            // Shut down, but make sure this is done inside our lock to ensure
-            // that we'll always receive the exit signal when the thread
-            // returns.
-            let mut guard = self.lock.lock().unwrap();
-
-            let ptr = *self.chan.get();
-            if ptr as usize == 1 {
-                panic!("cannot continue usage after shutdown");
-            }
-            // Close the channel by destroying it
-            let chan = Box::from_raw(*self.chan.get());
-            *self.chan.get() = 1 as *mut Sender<M>;
-            drop(chan);
-            helper_signal::signal(*self.signal.get() as helper_signal::signal);
-
-            // Wait for the child to exit
-            while !*self.shutdown.get() {
-                guard = self.cond.wait(guard).unwrap();
-            }
-            drop(guard);
-
-            // Clean up after ourselves
-            self.lock.destroy();
-            helper_signal::close(*self.signal.get() as helper_signal::signal);
-            *self.signal.get() = 0;
-        }
-    }
-}
diff --git a/src/libstd/sys/common/mod.rs b/src/libstd/sys/common/mod.rs
index 95294b813ea..b528575bbed 100644
--- a/src/libstd/sys/common/mod.rs
+++ b/src/libstd/sys/common/mod.rs
@@ -15,7 +15,7 @@ use prelude::v1::*;
 pub mod backtrace;
 pub mod condvar;
 pub mod mutex;
-pub mod net2;
+pub mod net;
 pub mod poison;
 pub mod remutex;
 pub mod rwlock;
diff --git a/src/libstd/sys/common/net2.rs b/src/libstd/sys/common/net.rs
index 7da7071670a..7da7071670a 100644
--- a/src/libstd/sys/common/net2.rs
+++ b/src/libstd/sys/common/net.rs
diff --git a/src/libstd/sys/common/remutex.rs b/src/libstd/sys/common/remutex.rs
index 48c74b8d89e..1a467580672 100644
--- a/src/libstd/sys/common/remutex.rs
+++ b/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
         }
     }
 
diff --git a/src/libstd/sys/unix/ext/fs.rs b/src/libstd/sys/unix/ext/fs.rs
index 39910f509f9..a6953437497 100644
--- a/src/libstd/sys/unix/ext/fs.rs
+++ b/src/libstd/sys/unix/ext/fs.rs
@@ -102,7 +102,7 @@ impl OpenOptionsExt for OpenOptions {
 }
 
 #[unstable(feature = "metadata_ext", reason = "recently added API")]
-pub struct Metadata(sys::fs2::FileAttr);
+pub struct Metadata(sys::fs::FileAttr);
 
 #[unstable(feature = "metadata_ext", reason = "recently added API")]
 pub trait MetadataExt {
@@ -111,7 +111,7 @@ pub trait MetadataExt {
 
 impl MetadataExt for fs::Metadata {
     fn as_raw(&self) -> &Metadata {
-        let inner: &sys::fs2::FileAttr = self.as_inner();
+        let inner: &sys::fs::FileAttr = self.as_inner();
         unsafe { mem::transmute(inner) }
     }
 }
@@ -187,7 +187,7 @@ impl DirEntryExt for fs::DirEntry {
 #[stable(feature = "rust1", since = "1.0.0")]
 pub fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> io::Result<()>
 {
-    sys::fs2::symlink(src.as_ref(), dst.as_ref())
+    sys::fs::symlink(src.as_ref(), dst.as_ref())
 }
 
 #[unstable(feature = "dir_builder", reason = "recently added API")]
diff --git a/src/libstd/sys/unix/ext/io.rs b/src/libstd/sys/unix/ext/io.rs
index c4a37241f64..79e59ddab5b 100644
--- a/src/libstd/sys/unix/ext/io.rs
+++ b/src/libstd/sys/unix/ext/io.rs
@@ -16,7 +16,7 @@ use fs;
 use net;
 use os::raw;
 use sys;
-use sys_common::{net2, AsInner, FromInner};
+use sys_common::{self, AsInner, FromInner};
 
 /// Raw file descriptors.
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -68,7 +68,7 @@ impl AsRawFd for fs::File {
 #[stable(feature = "from_raw_os", since = "1.1.0")]
 impl FromRawFd for fs::File {
     unsafe fn from_raw_fd(fd: RawFd) -> fs::File {
-        fs::File::from_inner(sys::fs2::File::from_inner(fd))
+        fs::File::from_inner(sys::fs::File::from_inner(fd))
     }
 }
 
@@ -89,20 +89,20 @@ impl AsRawFd for net::UdpSocket {
 impl FromRawFd for net::TcpStream {
     unsafe fn from_raw_fd(fd: RawFd) -> net::TcpStream {
         let socket = sys::net::Socket::from_inner(fd);
-        net::TcpStream::from_inner(net2::TcpStream::from_inner(socket))
+        net::TcpStream::from_inner(sys_common::net::TcpStream::from_inner(socket))
     }
 }
 #[stable(feature = "from_raw_os", since = "1.1.0")]
 impl FromRawFd for net::TcpListener {
     unsafe fn from_raw_fd(fd: RawFd) -> net::TcpListener {
         let socket = sys::net::Socket::from_inner(fd);
-        net::TcpListener::from_inner(net2::TcpListener::from_inner(socket))
+        net::TcpListener::from_inner(sys_common::net::TcpListener::from_inner(socket))
     }
 }
 #[stable(feature = "from_raw_os", since = "1.1.0")]
 impl FromRawFd for net::UdpSocket {
     unsafe fn from_raw_fd(fd: RawFd) -> net::UdpSocket {
         let socket = sys::net::Socket::from_inner(fd);
-        net::UdpSocket::from_inner(net2::UdpSocket::from_inner(socket))
+        net::UdpSocket::from_inner(sys_common::net::UdpSocket::from_inner(socket))
     }
 }
diff --git a/src/libstd/sys/unix/ext/process.rs b/src/libstd/sys/unix/ext/process.rs
index 8c9d0a86583..45d0d62a015 100644
--- a/src/libstd/sys/unix/ext/process.rs
+++ b/src/libstd/sys/unix/ext/process.rs
@@ -58,7 +58,7 @@ pub trait ExitStatusExt {
 impl ExitStatusExt for process::ExitStatus {
     fn signal(&self) -> Option<i32> {
         match *self.as_inner() {
-            sys::process2::ExitStatus::Signal(s) => Some(s),
+            sys::process::ExitStatus::Signal(s) => Some(s),
             _ => None
         }
     }
diff --git a/src/libstd/sys/unix/fs2.rs b/src/libstd/sys/unix/fs.rs
index 350161c751c..350161c751c 100644
--- a/src/libstd/sys/unix/fs2.rs
+++ b/src/libstd/sys/unix/fs.rs
diff --git a/src/libstd/sys/unix/mod.rs b/src/libstd/sys/unix/mod.rs
index 78b798d3bff..c1a4e8cee9e 100644
--- a/src/libstd/sys/unix/mod.rs
+++ b/src/libstd/sys/unix/mod.rs
@@ -33,13 +33,13 @@ pub mod c;
 pub mod condvar;
 pub mod ext;
 pub mod fd;
-pub mod fs2;
+pub mod fs;
 pub mod mutex;
 pub mod net;
 pub mod os;
 pub mod os_str;
-pub mod pipe2;
-pub mod process2;
+pub mod pipe;
+pub mod process;
 pub mod rwlock;
 pub mod stack_overflow;
 pub mod sync;
diff --git a/src/libstd/sys/unix/mutex.rs b/src/libstd/sys/unix/mutex.rs
index af814653c14..70d14f63dbc 100644
--- a/src/libstd/sys/unix/mutex.rs
+++ b/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) {
diff --git a/src/libstd/sys/unix/pipe2.rs b/src/libstd/sys/unix/pipe.rs
index e9d8c69fefb..e9d8c69fefb 100644
--- a/src/libstd/sys/unix/pipe2.rs
+++ b/src/libstd/sys/unix/pipe.rs
diff --git a/src/libstd/sys/unix/process2.rs b/src/libstd/sys/unix/process.rs
index 6f3c0fd63aa..290310f4ad9 100644
--- a/src/libstd/sys/unix/process2.rs
+++ b/src/libstd/sys/unix/process.rs
@@ -18,9 +18,9 @@ use fmt;
 use io::{self, Error, ErrorKind};
 use libc::{self, pid_t, c_void, c_int, gid_t, uid_t};
 use ptr;
-use sys::pipe2::AnonPipe;
+use sys::pipe::AnonPipe;
 use sys::{self, c, cvt, cvt_r};
-use sys::fs2::{File, OpenOptions};
+use sys::fs::{File, OpenOptions};
 
 ////////////////////////////////////////////////////////////////////////////////
 // Command
@@ -141,7 +141,7 @@ impl Process {
 
         let (envp, _a, _b) = make_envp(cfg.env.as_ref());
         let (argv, _a) = make_argv(&cfg.program, &cfg.args);
-        let (input, output) = try!(sys::pipe2::anon_pipe());
+        let (input, output) = try!(sys::pipe::anon_pipe());
 
         let pid = unsafe {
             match libc::fork() {
diff --git a/src/libstd/sys/windows/ext/fs.rs b/src/libstd/sys/windows/ext/fs.rs
index 23c1fcf4b3c..822e1b370c2 100644
--- a/src/libstd/sys/windows/ext/fs.rs
+++ b/src/libstd/sys/windows/ext/fs.rs
@@ -125,7 +125,7 @@ impl MetadataExt for Metadata {
 #[stable(feature = "rust1", since = "1.0.0")]
 pub fn symlink_file<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q)
                                                     -> io::Result<()> {
-    sys::fs2::symlink_inner(src.as_ref(), dst.as_ref(), false)
+    sys::fs::symlink_inner(src.as_ref(), dst.as_ref(), false)
 }
 
 /// Creates a new directory symlink on the filesystem.
@@ -146,5 +146,5 @@ pub fn symlink_file<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q)
 #[stable(feature = "rust1", since = "1.0.0")]
 pub fn symlink_dir<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q)
                                                    -> io::Result<()> {
-    sys::fs2::symlink_inner(src.as_ref(), dst.as_ref(), true)
+    sys::fs::symlink_inner(src.as_ref(), dst.as_ref(), true)
 }
diff --git a/src/libstd/sys/windows/ext/io.rs b/src/libstd/sys/windows/ext/io.rs
index eb48022f055..f4717eb2425 100644
--- a/src/libstd/sys/windows/ext/io.rs
+++ b/src/libstd/sys/windows/ext/io.rs
@@ -13,7 +13,7 @@
 use fs;
 use os::windows::raw;
 use net;
-use sys_common::{net2, AsInner, FromInner};
+use sys_common::{self, AsInner, FromInner};
 use sys;
 
 /// Raw HANDLEs.
@@ -61,7 +61,7 @@ impl AsRawHandle for fs::File {
 impl FromRawHandle for fs::File {
     unsafe fn from_raw_handle(handle: RawHandle) -> fs::File {
         let handle = handle as ::libc::HANDLE;
-        fs::File::from_inner(sys::fs2::File::from_inner(handle))
+        fs::File::from_inner(sys::fs::File::from_inner(handle))
     }
 }
 
@@ -113,20 +113,20 @@ impl AsRawSocket for net::UdpSocket {
 impl FromRawSocket for net::TcpStream {
     unsafe fn from_raw_socket(sock: RawSocket) -> net::TcpStream {
         let sock = sys::net::Socket::from_inner(sock);
-        net::TcpStream::from_inner(net2::TcpStream::from_inner(sock))
+        net::TcpStream::from_inner(sys_common::net::TcpStream::from_inner(sock))
     }
 }
 #[stable(feature = "from_raw_os", since = "1.1.0")]
 impl FromRawSocket for net::TcpListener {
     unsafe fn from_raw_socket(sock: RawSocket) -> net::TcpListener {
         let sock = sys::net::Socket::from_inner(sock);
-        net::TcpListener::from_inner(net2::TcpListener::from_inner(sock))
+        net::TcpListener::from_inner(sys_common::net::TcpListener::from_inner(sock))
     }
 }
 #[stable(feature = "from_raw_os", since = "1.1.0")]
 impl FromRawSocket for net::UdpSocket {
     unsafe fn from_raw_socket(sock: RawSocket) -> net::UdpSocket {
         let sock = sys::net::Socket::from_inner(sock);
-        net::UdpSocket::from_inner(net2::UdpSocket::from_inner(sock))
+        net::UdpSocket::from_inner(sys_common::net::UdpSocket::from_inner(sock))
     }
 }
diff --git a/src/libstd/sys/windows/fs2.rs b/src/libstd/sys/windows/fs.rs
index 03a56e2958a..03a56e2958a 100644
--- a/src/libstd/sys/windows/fs2.rs
+++ b/src/libstd/sys/windows/fs.rs
diff --git a/src/libstd/sys/windows/mod.rs b/src/libstd/sys/windows/mod.rs
index 5ae5f6f201b..4c30f0f8660 100644
--- a/src/libstd/sys/windows/mod.rs
+++ b/src/libstd/sys/windows/mod.rs
@@ -25,14 +25,14 @@ pub mod backtrace;
 pub mod c;
 pub mod condvar;
 pub mod ext;
-pub mod fs2;
+pub mod fs;
 pub mod handle;
 pub mod mutex;
 pub mod net;
 pub mod os;
 pub mod os_str;
-pub mod pipe2;
-pub mod process2;
+pub mod pipe;
+pub mod process;
 pub mod rwlock;
 pub mod stack_overflow;
 pub mod sync;
diff --git a/src/libstd/sys/windows/mutex.rs b/src/libstd/sys/windows/mutex.rs
index ca20858bb5b..9d2624f9418 100644
--- a/src/libstd/sys/windows/mutex.rs
+++ b/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) {
diff --git a/src/libstd/sys/windows/pipe2.rs b/src/libstd/sys/windows/pipe.rs
index b441d8beedb..b441d8beedb 100644
--- a/src/libstd/sys/windows/pipe2.rs
+++ b/src/libstd/sys/windows/pipe.rs
diff --git a/src/libstd/sys/windows/process2.rs b/src/libstd/sys/windows/process.rs
index 5aad5f668dd..032a349b00e 100644
--- a/src/libstd/sys/windows/process2.rs
+++ b/src/libstd/sys/windows/process.rs
@@ -26,9 +26,9 @@ use path::Path;
 use ptr;
 use sync::{StaticMutex, MUTEX_INIT};
 use sys::c;
-use sys::fs2::{OpenOptions, File};
+use sys::fs::{OpenOptions, File};
 use sys::handle::Handle;
-use sys::pipe2::AnonPipe;
+use sys::pipe::AnonPipe;
 use sys::stdio;
 use sys::{self, cvt};
 use sys_common::{AsInner, FromInner};