Auto merge of #23353 - alexcrichton:stabilize-os, r=aturon

This commit starts to organize the `std::os::$platform` modules and in the
process stabilizes some of the functionality contained within. The organization
of these modules will reflect the organization of the standard library itself
with extension traits for primitives in the same corresponding module.

The OS-specific modules will grow more functionality over time including
concrete types that are not extending functionality of other structures, and
these will either go into the closest module in `std::os::$platform` or they
will grow a new module in the hierarchy.

The following items are now stable:

* `os::{unix, windows}`
* `unix::ffi`
* `unix::ffi::OsStrExt`
* `unix::ffi::OsStrExt::{from_bytes, as_bytes, to_cstring}`
* `unix::ffi::OsString`
* `unix::ffi::OsStringExt::{from_vec, into_vec}`
* `unix::process`
* `unix::process::CommandExt`
* `unix::process::CommandExt::{uid, gid}`
* `unix::process::ExitStatusExt`
* `unix::process::ExitStatusExt::signal`
* `unix::prelude`
* `windows::ffi`
* `windows::ffi::OsStringExt`
* `windows::ffi::OsStringExt::from_wide`
* `windows::ffi::OsStrExt`
* `windows::ffi::OsStrExt::encode_wide`
* `windows::prelude`

The following items remain unstable:

* `unix::io`
* `unix::io::{Fd, AsRawFd}`
* `unix::fs::{PermissionsExt, OpenOptionsExt}`
* `windows::io`
* `windows::io::{Handle, AsRawHandle}`
* `windows::io::{Socket, AsRawSocket}`
* `windows::fs`
* `windows::fs::OpenOptionsExt`

Due to the reorgnization of the platform extension modules, this commit is a
breaking change. Most imports can be fixed by adding the relevant libstd module
in the `use` path (such as `ffi` or `fs`).

[breaking-change]

4 files changed, 178 insertions, 149 deletions

diff --git a/src/libstd/sys/windows/ext.rs b/src/libstd/sys/windows/ext.rs
index dc820a4ce45..7955397892b 100644
--- a/src/libstd/sys/windows/ext.rs
+++ b/src/libstd/sys/windows/ext.rs
@@ -14,197 +14,225 @@
 //! descriptors, and sockets, but its functionality will grow over
 //! time.
 
-#![unstable(feature = "std_misc")]
+#![stable(feature = "rust1", since = "1.0.0")]
 
-pub use sys_common::wtf8::{Wtf8Buf, EncodeWide};
+#[unstable(feature = "io_ext",
+           reason = "organization may change slightly and the primitives \
+                     provided may be tweaked")]
+pub mod io {
+    use fs;
+    use libc;
+    use net;
+    use sys_common::AsInner;
 
-use ffi::{OsStr, OsString};
-use fs::{self, OpenOptions};
-use libc;
-use net;
-use sys::os_str::Buf;
-use sys_common::{AsInner, FromInner, AsInnerMut};
+    #[allow(deprecated)]
+    use old_io;
 
-#[allow(deprecated)]
-use old_io;
+    /// Raw HANDLEs.
+    pub type Handle = libc::HANDLE;
 
-/// Raw HANDLEs.
-pub type Handle = libc::HANDLE;
+    /// Raw SOCKETs.
+    pub type Socket = libc::SOCKET;
 
-/// Raw SOCKETs.
-pub type Socket = libc::SOCKET;
+    /// Extract raw handles.
+    pub trait AsRawHandle {
+        /// Extract the raw handle, without taking any ownership.
+        fn as_raw_handle(&self) -> Handle;
+    }
 
-/// Extract raw handles.
-pub trait AsRawHandle {
-    /// Extract the raw handle, without taking any ownership.
-    fn as_raw_handle(&self) -> Handle;
-}
+    #[allow(deprecated)]
+    impl AsRawHandle for old_io::fs::File {
+        fn as_raw_handle(&self) -> Handle {
+            self.as_inner().handle()
+        }
+    }
 
-#[allow(deprecated)]
-impl AsRawHandle for old_io::fs::File {
-    fn as_raw_handle(&self) -> Handle {
-        self.as_inner().handle()
+    impl AsRawHandle for fs::File {
+        fn as_raw_handle(&self) -> Handle {
+            self.as_inner().handle().raw()
+        }
     }
-}
 
-impl AsRawHandle for fs::File {
-    fn as_raw_handle(&self) -> Handle {
-        self.as_inner().handle().raw()
+    #[allow(deprecated)]
+    impl AsRawHandle for old_io::pipe::PipeStream {
+        fn as_raw_handle(&self) -> Handle {
+            self.as_inner().handle()
+        }
     }
-}
 
-#[allow(deprecated)]
-impl AsRawHandle for old_io::pipe::PipeStream {
-    fn as_raw_handle(&self) -> Handle {
-        self.as_inner().handle()
+    #[allow(deprecated)]
+    impl AsRawHandle for old_io::net::pipe::UnixStream {
+        fn as_raw_handle(&self) -> Handle {
+            self.as_inner().handle()
+        }
     }
-}
 
-#[allow(deprecated)]
-impl AsRawHandle for old_io::net::pipe::UnixStream {
-    fn as_raw_handle(&self) -> Handle {
-        self.as_inner().handle()
+    #[allow(deprecated)]
+    impl AsRawHandle for old_io::net::pipe::UnixListener {
+        fn as_raw_handle(&self) -> Handle {
+            self.as_inner().handle()
+        }
     }
-}
 
-#[allow(deprecated)]
-impl AsRawHandle for old_io::net::pipe::UnixListener {
-    fn as_raw_handle(&self) -> Handle {
-        self.as_inner().handle()
+    #[allow(deprecated)]
+    impl AsRawHandle for old_io::net::pipe::UnixAcceptor {
+        fn as_raw_handle(&self) -> Handle {
+            self.as_inner().handle()
+        }
     }
-}
 
-#[allow(deprecated)]
-impl AsRawHandle for old_io::net::pipe::UnixAcceptor {
-    fn as_raw_handle(&self) -> Handle {
-        self.as_inner().handle()
+    /// Extract raw sockets.
+    pub trait AsRawSocket {
+        fn as_raw_socket(&self) -> Socket;
     }
-}
 
-/// Extract raw sockets.
-pub trait AsRawSocket {
-    fn as_raw_socket(&self) -> Socket;
-}
+    #[allow(deprecated)]
+    impl AsRawSocket for old_io::net::tcp::TcpStream {
+        fn as_raw_socket(&self) -> Socket {
+            self.as_inner().fd()
+        }
+    }
 
-#[allow(deprecated)]
-impl AsRawSocket for old_io::net::tcp::TcpStream {
-    fn as_raw_socket(&self) -> Socket {
-        self.as_inner().fd()
+    #[allow(deprecated)]
+    impl AsRawSocket for old_io::net::tcp::TcpListener {
+        fn as_raw_socket(&self) -> Socket {
+            self.as_inner().socket()
+        }
     }
-}
 
-#[allow(deprecated)]
-impl AsRawSocket for old_io::net::tcp::TcpListener {
-    fn as_raw_socket(&self) -> Socket {
-        self.as_inner().socket()
+    #[allow(deprecated)]
+    impl AsRawSocket for old_io::net::tcp::TcpAcceptor {
+        fn as_raw_socket(&self) -> Socket {
+            self.as_inner().socket()
+        }
     }
-}
 
-#[allow(deprecated)]
-impl AsRawSocket for old_io::net::tcp::TcpAcceptor {
-    fn as_raw_socket(&self) -> Socket {
-        self.as_inner().socket()
+    #[allow(deprecated)]
+    impl AsRawSocket for old_io::net::udp::UdpSocket {
+        fn as_raw_socket(&self) -> Socket {
+            self.as_inner().fd()
+        }
     }
-}
 
-#[allow(deprecated)]
-impl AsRawSocket for old_io::net::udp::UdpSocket {
-    fn as_raw_socket(&self) -> Socket {
-        self.as_inner().fd()
+    impl AsRawSocket for net::TcpStream {
+        fn as_raw_socket(&self) -> Socket { *self.as_inner().socket().as_inner() }
+    }
+    impl AsRawSocket for net::TcpListener {
+        fn as_raw_socket(&self) -> Socket { *self.as_inner().socket().as_inner() }
+    }
+    impl AsRawSocket for net::UdpSocket {
+        fn as_raw_socket(&self) -> Socket { *self.as_inner().socket().as_inner() }
     }
 }
 
-impl AsRawSocket for net::TcpStream {
-    fn as_raw_socket(&self) -> Socket { *self.as_inner().socket().as_inner() }
-}
-impl AsRawSocket for net::TcpListener {
-    fn as_raw_socket(&self) -> Socket { *self.as_inner().socket().as_inner() }
-}
-impl AsRawSocket for net::UdpSocket {
-    fn as_raw_socket(&self) -> Socket { *self.as_inner().socket().as_inner() }
-}
+/// Windows-specific extensions to the primitives in the `std::ffi` module.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub mod ffi {
+    use ffi::{OsString, OsStr};
+    use sys::os_str::Buf;
+    use sys_common::wtf8::Wtf8Buf;
+    use sys_common::{FromInner, AsInner};
 
-/// Windows-specific extensions to `OsString`.
-pub trait OsStringExt {
-    /// Create an `OsString` from a potentially ill-formed UTF-16 slice of 16-bit code units.
-    ///
-    /// This is lossless: calling `.encode_wide()` on the resulting string
-    /// will always return the original code units.
-    fn from_wide(wide: &[u16]) -> Self;
-}
+    pub use sys_common::wtf8::EncodeWide;
 
-impl OsStringExt for OsString {
-    fn from_wide(wide: &[u16]) -> OsString {
-        FromInner::from_inner(Buf { inner: Wtf8Buf::from_wide(wide) })
+    /// Windows-specific extensions to `OsString`.
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub trait OsStringExt {
+        /// Create an `OsString` from a potentially ill-formed UTF-16 slice of
+        /// 16-bit code units.
+        ///
+        /// This is lossless: calling `.encode_wide()` on the resulting string
+        /// will always return the original code units.
+        #[stable(feature = "rust1", since = "1.0.0")]
+        fn from_wide(wide: &[u16]) -> Self;
     }
-}
 
-/// Windows-specific extensions to `OsStr`.
-pub trait OsStrExt {
-    /// Re-encode an `OsStr` as a wide character sequence,
-    /// i.e. potentially ill-formed UTF-16.
-    ///
-    /// This is lossless. Note that the encoding does not include a final null.
-    fn encode_wide(&self) -> EncodeWide;
-}
+    #[stable(feature = "rust1", since = "1.0.0")]
+    impl OsStringExt for OsString {
+        fn from_wide(wide: &[u16]) -> OsString {
+            FromInner::from_inner(Buf { inner: Wtf8Buf::from_wide(wide) })
+        }
+    }
 
-impl OsStrExt for OsStr {
-    fn encode_wide(&self) -> EncodeWide {
-        self.as_inner().inner.encode_wide()
+    /// Windows-specific extensions to `OsStr`.
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub trait OsStrExt {
+        /// Re-encode an `OsStr` as a wide character sequence,
+        /// i.e. potentially ill-formed UTF-16.
+        ///
+        /// This is lossless. Note that the encoding does not include a final
+        /// null.
+        #[stable(feature = "rust1", since = "1.0.0")]
+        fn encode_wide(&self) -> EncodeWide;
     }
-}
 
-// Windows-specific extensions to `OpenOptions`
-pub trait OpenOptionsExt {
-    /// Override the `dwDesiredAccess` argument to the call to `CreateFile` with
-    /// the specified value.
-    fn desired_access(&mut self, access: i32) -> &mut Self;
-
-    /// Override the `dwCreationDisposition` argument to the call to
-    /// `CreateFile` with the specified value.
-    ///
-    /// This will override any values of the standard `create` flags, for
-    /// example.
-    fn creation_disposition(&mut self, val: i32) -> &mut Self;
-
-    /// Override the `dwFlagsAndAttributes` argument to the call to
-    /// `CreateFile` with the specified value.
-    ///
-    /// This will override any values of the standard flags on the `OpenOptions`
-    /// structure.
-    fn flags_and_attributes(&mut self, val: i32) -> &mut Self;
-
-    /// Override the `dwShareMode` argument to the call to `CreateFile` with the
-    /// specified value.
-    ///
-    /// This will override any values of the standard flags on the `OpenOptions`
-    /// structure.
-    fn share_mode(&mut self, val: i32) -> &mut Self;
+    #[stable(feature = "rust1", since = "1.0.0")]
+    impl OsStrExt for OsStr {
+        fn encode_wide(&self) -> EncodeWide {
+            self.as_inner().inner.encode_wide()
+        }
+    }
 }
 
-impl OpenOptionsExt for OpenOptions {
-    fn desired_access(&mut self, access: i32) -> &mut OpenOptions {
-        self.as_inner_mut().desired_access(access); self
-    }
-    fn creation_disposition(&mut self, access: i32) -> &mut OpenOptions {
-        self.as_inner_mut().creation_disposition(access); self
-    }
-    fn flags_and_attributes(&mut self, access: i32) -> &mut OpenOptions {
-        self.as_inner_mut().flags_and_attributes(access); self
-    }
-    fn share_mode(&mut self, access: i32) -> &mut OpenOptions {
-        self.as_inner_mut().share_mode(access); self
+/// Windows-specific extensions for the primitives in `std::fs`
+#[unstable(feature = "fs_ext", reason = "may require more thought/methods")]
+pub mod fs {
+    use fs::OpenOptions;
+    use sys_common::AsInnerMut;
+
+    /// Windows-specific extensions to `OpenOptions`
+    pub trait OpenOptionsExt {
+        /// Override the `dwDesiredAccess` argument to the call to `CreateFile`
+        /// with the specified value.
+        fn desired_access(&mut self, access: i32) -> &mut Self;
+
+        /// Override the `dwCreationDisposition` argument to the call to
+        /// `CreateFile` with the specified value.
+        ///
+        /// This will override any values of the standard `create` flags, for
+        /// example.
+        fn creation_disposition(&mut self, val: i32) -> &mut Self;
+
+        /// Override the `dwFlagsAndAttributes` argument to the call to
+        /// `CreateFile` with the specified value.
+        ///
+        /// This will override any values of the standard flags on the
+        /// `OpenOptions` structure.
+        fn flags_and_attributes(&mut self, val: i32) -> &mut Self;
+
+        /// Override the `dwShareMode` argument to the call to `CreateFile` with
+        /// the specified value.
+        ///
+        /// This will override any values of the standard flags on the
+        /// `OpenOptions` structure.
+        fn share_mode(&mut self, val: i32) -> &mut Self;
+    }
+
+    impl OpenOptionsExt for OpenOptions {
+        fn desired_access(&mut self, access: i32) -> &mut OpenOptions {
+            self.as_inner_mut().desired_access(access); self
+        }
+        fn creation_disposition(&mut self, access: i32) -> &mut OpenOptions {
+            self.as_inner_mut().creation_disposition(access); self
+        }
+        fn flags_and_attributes(&mut self, access: i32) -> &mut OpenOptions {
+            self.as_inner_mut().flags_and_attributes(access); self
+        }
+        fn share_mode(&mut self, access: i32) -> &mut OpenOptions {
+            self.as_inner_mut().share_mode(access); self
+        }
     }
 }
 
 /// A prelude for conveniently writing platform-specific code.
 ///
 /// Includes all extension traits, and some important type definitions.
+#[stable(feature = "rust1", since = "1.0.0")]
 pub mod prelude {
     #[doc(no_inline)]
-    pub use super::{Socket, Handle, AsRawSocket, AsRawHandle};
-    #[doc(no_inline)]
-    pub use super::{OsStrExt, OsStringExt};
+    pub use super::io::{Socket, Handle, AsRawSocket, AsRawHandle};
+    #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")]
+    pub use super::ffi::{OsStrExt, OsStringExt};
     #[doc(no_inline)]
-    pub use super::OpenOptionsExt;
+    pub use super::fs::OpenOptionsExt;
 }
diff --git a/src/libstd/sys/windows/mod.rs b/src/libstd/sys/windows/mod.rs
index 6b0f6a78c85..d02fe79fcdb 100644
--- a/src/libstd/sys/windows/mod.rs
+++ b/src/libstd/sys/windows/mod.rs
@@ -20,7 +20,7 @@ use libc;
 use mem;
 use num::Int;
 use old_io::{self, IoResult, IoError};
-use os::windows::{OsStrExt, OsStringExt};
+use os::windows::ffi::{OsStrExt, OsStringExt};
 use path::PathBuf;
 use sync::{Once, ONCE_INIT};
 
diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs
index ecd538abfb4..4f6c4c9aab3 100644
--- a/src/libstd/sys/windows/os.rs
+++ b/src/libstd/sys/windows/os.rs
@@ -13,7 +13,7 @@
 #![allow(bad_style)]
 
 use prelude::v1::*;
-use os::windows::*;
+use os::windows::prelude::*;
 
 use error::Error as StdError;
 use ffi::{OsString, OsStr, AsOsStr};
@@ -25,6 +25,7 @@ use mem;
 #[allow(deprecated)]
 use old_io::{IoError, IoResult};
 use ops::Range;
+use os::windows::ffi::EncodeWide;
 use path::{self, PathBuf};
 use ptr;
 use slice;
diff --git a/src/libstd/sys/windows/process2.rs b/src/libstd/sys/windows/process2.rs
index 8a6a485cbbe..4fbaabc9ecc 100644
--- a/src/libstd/sys/windows/process2.rs
+++ b/src/libstd/sys/windows/process2.rs
@@ -19,7 +19,7 @@ use fmt;
 use fs;
 use io::{self, Error};
 use libc::{self, c_void};
-use os::windows::OsStrExt;
+use os::windows::ffi::OsStrExt;
 use ptr;
 use sync::{StaticMutex, MUTEX_INIT};
 use sys::handle::Handle;