std: Rename io to old_io

In preparation for the I/O rejuvination of the standard library, this commit
renames the current `io` module to `old_io` in order to make room for the new
I/O modules. It is expected that the I/O RFCs will land incrementally over time
instead of all at once, and this provides a fresh clean path for new modules to
enter into as well as guaranteeing that all old infrastructure will remain in
place for some time.

As each `old_io` module is replaced it will be deprecated in-place for new
structures in `std::{io, fs, net}` (as appropriate).

This commit does *not* leave a reexport of `old_io as io` as the deprecation
lint does not currently warn on this form of use. This is quite a large breaking
change for all imports in existing code, but all functionality is retained
precisely as-is and path statements simply need to be renamed from `io` to
`old_io`.

[breaking-change]

src/libstd/lib.rs

@@ -79,7 +79,8 @@
 //! memory types, including [`atomic`](sync/atomic/index.html).
 //!
 //! Common types of I/O, including files, TCP, UDP, pipes, Unix domain sockets,
-//! timers, and process spawning, are defined in the [`io`](io/index.html) module.
+//! timers, and process spawning, are defined in the
+//! [`old_io`](old_io/index.html) module.
 //!
 //! Rust's I/O and concurrency depends on a small runtime interface
 //! that lives, along with its support code, in mod [`rt`](rt/index.html).
@@ -239,7 +240,7 @@ pub mod thread_local;
 pub mod dynamic_lib;
 pub mod ffi;
 pub mod fmt;
-pub mod io;
+pub mod old_io;
 pub mod os;
 pub mod path;
 pub mod rand;
@@ -284,7 +285,7 @@ mod std {
     pub use sync; // used for select!()
     pub use error; // used for try!()
     pub use fmt; // used for any formatting strings
-    pub use io; // used for println!()
+    pub use old_io; // used for println!()
     pub use option; // used for bitflags!{}
     pub use rt; // used for panic!()
     pub use vec; // used for vec![]

src/libstd/old_io/buffered.rs

@@ -14,7 +14,7 @@
 
 use cmp;
 use fmt;
-use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult};
+use old_io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult};
 use iter::{IteratorExt, ExactSizeIterator, repeat};
 use ops::Drop;
 use option::Option;
@@ -34,7 +34,7 @@ use vec::Vec;
 /// # Example
 ///
 /// ```rust
-/// use std::io::{BufferedReader, File};
+/// use std::old_io::{BufferedReader, File};
 ///
 /// let file = File::open(&Path::new("message.txt"));
 /// let mut reader = BufferedReader::new(file);
@@ -137,7 +137,7 @@ impl<R: Reader> Reader for BufferedReader<R> {
 /// # Example
 ///
 /// ```rust
-/// use std::io::{BufferedWriter, File};
+/// use std::old_io::{BufferedWriter, File};
 ///
 /// let file = File::create(&Path::new("message.txt")).unwrap();
 /// let mut writer = BufferedWriter::new(file);
@@ -324,7 +324,7 @@ impl<W: Reader> Reader for InternalBufferedWriter<W> {
 ///
 /// ```rust
 /// # #![allow(unused_must_use)]
-/// use std::io::{BufferedStream, File};
+/// use std::old_io::{BufferedStream, File};
 ///
 /// let file = File::open(&Path::new("message.txt"));
 /// let mut stream = BufferedStream::new(file);
@@ -437,13 +437,13 @@ mod test {
     pub struct NullStream;
 
     impl Reader for NullStream {
-        fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
+        fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
-            Err(io::standard_error(io::EndOfFile))
+            Err(old_io::standard_error(old_io::EndOfFile))
         }
     }
 
     impl Writer for NullStream {
-        fn write(&mut self, _: &[u8]) -> io::IoResult<()> { Ok(()) }
+        fn write(&mut self, _: &[u8]) -> old_io::IoResult<()> { Ok(()) }
     }
 
     /// A dummy reader intended at testing short-reads propagation.
@@ -452,9 +452,9 @@ mod test {
     }
 
     impl Reader for ShortReader {
-        fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
+        fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
             if self.lengths.is_empty() {
-                Err(io::standard_error(io::EndOfFile))
+                Err(old_io::standard_error(old_io::EndOfFile))
             } else {
                 Ok(self.lengths.remove(0))
             }
@@ -555,13 +555,13 @@ mod test {
     fn test_buffered_stream() {
         struct S;
 
-        impl io::Writer for S {
+        impl old_io::Writer for S {
-            fn write(&mut self, _: &[u8]) -> io::IoResult<()> { Ok(()) }
+            fn write(&mut self, _: &[u8]) -> old_io::IoResult<()> { Ok(()) }
         }
 
-        impl io::Reader for S {
+        impl old_io::Reader for S {
-            fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
+            fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
-                Err(io::standard_error(io::EndOfFile))
+                Err(old_io::standard_error(old_io::EndOfFile))
             }
         }
 
@@ -664,7 +664,7 @@ mod test {
 
         impl Writer for FailFlushWriter {
             fn write(&mut self, _buf: &[u8]) -> IoResult<()> { Ok(()) }
-            fn flush(&mut self) -> IoResult<()> { Err(io::standard_error(EndOfFile)) }
+            fn flush(&mut self) -> IoResult<()> { Err(old_io::standard_error(EndOfFile)) }
         }
 
         let writer = FailFlushWriter;

src/libstd/old_io/comm_adapters.rs

@@ -11,7 +11,7 @@
 use clone::Clone;
 use cmp;
 use sync::mpsc::{Sender, Receiver};
-use io;
+use old_io;
 use option::Option::{None, Some};
 use result::Result::{Ok, Err};
 use slice::{bytes, SliceExt};
@@ -24,7 +24,7 @@ use vec::Vec;
 ///
 /// ```
 /// use std::sync::mpsc::channel;
-/// use std::io::ChanReader;
+/// use std::old_io::ChanReader;
 ///
 /// let (tx, rx) = channel();
 /// # drop(tx);
@@ -70,7 +70,7 @@ impl Buffer for ChanReader {
             }
         }
         if self.closed {
-            Err(io::standard_error(io::EndOfFile))
+            Err(old_io::standard_error(old_io::EndOfFile))
         } else {
             Ok(&self.buf[self.pos..])
         }
@@ -102,7 +102,7 @@ impl Reader for ChanReader {
             }
         }
         if self.closed && num_read == 0 {
-            Err(io::standard_error(io::EndOfFile))
+            Err(old_io::standard_error(old_io::EndOfFile))
         } else {
             Ok(num_read)
         }
@@ -116,7 +116,7 @@ impl Reader for ChanReader {
 /// ```
 /// # #![allow(unused_must_use)]
 /// use std::sync::mpsc::channel;
-/// use std::io::ChanWriter;
+/// use std::old_io::ChanWriter;
 ///
 /// let (tx, rx) = channel();
 /// # drop(rx);
@@ -144,8 +144,8 @@ impl Clone for ChanWriter {
 impl Writer for ChanWriter {
     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
         self.tx.send(buf.to_vec()).map_err(|_| {
-            io::IoError {
+            old_io::IoError {
-                kind: io::BrokenPipe,
+                kind: old_io::BrokenPipe,
                 desc: "Pipe closed",
                 detail: None
             }
@@ -193,14 +193,14 @@ mod test {
 
         match reader.read(buf.as_mut_slice()) {
             Ok(..) => panic!(),
-            Err(e) => assert_eq!(e.kind, io::EndOfFile),
+            Err(e) => assert_eq!(e.kind, old_io::EndOfFile),
         }
         assert_eq!(a, buf);
 
         // Ensure it continues to panic in the same way.
         match reader.read(buf.as_mut_slice()) {
             Ok(..) => panic!(),
-            Err(e) => assert_eq!(e.kind, io::EndOfFile),
+            Err(e) => assert_eq!(e.kind, old_io::EndOfFile),
         }
         assert_eq!(a, buf);
     }
@@ -223,7 +223,7 @@ mod test {
         assert_eq!(Ok("how are you?".to_string()), reader.read_line());
         match reader.read_line() {
             Ok(..) => panic!(),
-            Err(e) => assert_eq!(e.kind, io::EndOfFile),
+            Err(e) => assert_eq!(e.kind, old_io::EndOfFile),
         }
     }
 
@@ -242,7 +242,7 @@ mod test {
 
         match writer.write_u8(1) {
             Ok(..) => panic!(),
-            Err(e) => assert_eq!(e.kind, io::BrokenPipe),
+            Err(e) => assert_eq!(e.kind, old_io::BrokenPipe),
         }
     }
 }

src/libstd/old_io/extensions.rs

@@ -15,8 +15,8 @@
 // FIXME: Not sure how this should be structured
 // FIXME: Iteration should probably be considered separately
 
-use io::{IoError, IoResult, Reader};
+use old_io::{IoError, IoResult, Reader};
-use io;
+use old_io;
 use iter::Iterator;
 use num::Int;
 use ops::FnOnce;
@@ -59,7 +59,7 @@ impl<'r, R: Reader> Iterator for Bytes<'r, R> {
     fn next(&mut self) -> Option<IoResult<u8>> {
         match self.reader.read_byte() {
             Ok(x) => Some(Ok(x)),
-            Err(IoError { kind: io::EndOfFile, .. }) => None,
+            Err(IoError { kind: old_io::EndOfFile, .. }) => None,
             Err(e) => Some(Err(e))
         }
     }
@@ -179,14 +179,14 @@ pub fn u64_from_be_bytes(data: &[u8], start: uint, size: uint) -> u64 {
 mod test {
     use prelude::v1::*;
     use io;
-    use io::{MemReader, BytesReader};
+    use old_io::{MemReader, BytesReader};
 
     struct InitialZeroByteReader {
         count: int,
     }
 
     impl Reader for InitialZeroByteReader {
-        fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
+        fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
             if self.count == 0 {
                 self.count = 1;
                 Ok(0)
@@ -200,16 +200,16 @@ mod test {
     struct EofReader;
 
     impl Reader for EofReader {
-        fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
+        fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
-            Err(io::standard_error(io::EndOfFile))
+            Err(old_io::standard_error(old_io::EndOfFile))
         }
     }
 
     struct ErroringReader;
 
     impl Reader for ErroringReader {
-        fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
+        fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
-            Err(io::standard_error(io::InvalidInput))
+            Err(old_io::standard_error(old_io::InvalidInput))
         }
     }
 
@@ -218,7 +218,7 @@ mod test {
     }
 
     impl Reader for PartialReader {
-        fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
+        fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
             if self.count == 0 {
                 self.count = 1;
                 buf[0] = 10;
@@ -237,13 +237,13 @@ mod test {
     }
 
     impl Reader for ErroringLaterReader {
-        fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
+        fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
             if self.count == 0 {
                 self.count = 1;
                 buf[0] = 10;
                 Ok(1)
             } else {
-                Err(io::standard_error(io::InvalidInput))
+                Err(old_io::standard_error(old_io::InvalidInput))
             }
         }
     }
@@ -253,7 +253,7 @@ mod test {
     }
 
     impl Reader for ThreeChunkReader {
-        fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
+        fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
             if self.count == 0 {
                 self.count = 1;
                 buf[0] = 10;
@@ -265,7 +265,7 @@ mod test {
                 buf[1] = 13;
                 Ok(2)
             } else {
-                Err(io::standard_error(io::EndOfFile))
+                Err(old_io::standard_error(old_io::EndOfFile))
             }
         }
     }

src/libstd/old_io/fs.rs

@@ -18,21 +18,21 @@
 //! At the top-level of the module are a set of freestanding functions, associated
 //! with various filesystem operations. They all operate on `Path` objects.
 //!
-//! All operations in this module, including those as part of `File` et al
+//! All operations in this module, including those as part of `File` et al block
-//! block the task during execution. In the event of failure, all functions/methods
+//! the task during execution. In the event of failure, all functions/methods
 //! will return an `IoResult` type with an `Err` value.
 //!
 //! Also included in this module is an implementation block on the `Path` object
-//! defined in `std::path::Path`. The impl adds useful methods about inspecting the
+//! defined in `std::path::Path`. The impl adds useful methods about inspecting
-//! metadata of a file. This includes getting the `stat` information, reading off
+//! the metadata of a file. This includes getting the `stat` information,
-//! particular bits of it, etc.
+//! reading off particular bits of it, etc.
 //!
 //! # Example
 //!
 //! ```rust
 //! # #![allow(unused_must_use)]
-//! use std::io::fs::PathExtensions;
+//! use std::old_io::fs::PathExtensions;
-//! use std::io::{File, fs};
+//! use std::old_io::{File, fs};
 //!
 //! let path = Path::new("foo.txt");
 //!
@@ -51,13 +51,13 @@
 //! ```
 
 use clone::Clone;
-use io::standard_error;
+use old_io::standard_error;
-use io::{FilePermission, Write, Open, FileAccess, FileMode, FileType};
+use old_io::{FilePermission, Write, Open, FileAccess, FileMode, FileType};
-use io::{IoResult, IoError, InvalidInput};
+use old_io::{IoResult, IoError, InvalidInput};
-use io::{FileStat, SeekStyle, Seek, Writer, Reader};
+use old_io::{FileStat, SeekStyle, Seek, Writer, Reader};
-use io::{Read, Truncate, ReadWrite, Append};
+use old_io::{Read, Truncate, ReadWrite, Append};
-use io::UpdateIoError;
+use old_io::UpdateIoError;
-use io;
+use old_io;
 use iter::{Iterator, Extend};
 use option::Option;
 use option::Option::{Some, None};
@@ -101,7 +101,7 @@ impl File {
     /// # Example
     ///
     /// ```rust,should_fail
-    /// use std::io::{File, Open, ReadWrite};
+    /// use std::old_io::{File, Open, ReadWrite};
     ///
     /// let p = Path::new("/some/file/path.txt");
     ///
@@ -170,7 +170,7 @@ impl File {
     /// # Example
     ///
     /// ```rust
-    /// use std::io::File;
+    /// use std::old_io::File;
     ///
     /// let contents = File::open(&Path::new("foo.txt")).read_to_end();
     /// ```
@@ -188,12 +188,12 @@ impl File {
     ///
     /// ```rust
     /// # #![allow(unused_must_use)]
-    /// use std::io::File;
+    /// use std::old_io::File;
     ///
     /// let mut f = File::create(&Path::new("foo.txt"));
     /// f.write(b"This is a sample file");
     /// # drop(f);
-    /// # ::std::io::fs::unlink(&Path::new("foo.txt"));
+    /// # ::std::old_io::fs::unlink(&Path::new("foo.txt"));
     /// ```
     pub fn create(path: &Path) -> IoResult<File> {
         File::open_mode(path, Truncate, Write)
@@ -265,7 +265,7 @@ impl File {
 ///
 /// ```rust
 /// # #![allow(unused_must_use)]
-/// use std::io::fs;
+/// use std::old_io::fs;
 ///
 /// let p = Path::new("/some/file/path.txt");
 /// fs::unlink(&p);
@@ -293,7 +293,7 @@ pub fn unlink(path: &Path) -> IoResult<()> {
 /// # Example
 ///
 /// ```rust
-/// use std::io::fs;
+/// use std::old_io::fs;
 ///
 /// let p = Path::new("/some/file/path.txt");
 /// match fs::stat(&p) {
@@ -333,7 +333,7 @@ pub fn lstat(path: &Path) -> IoResult<FileStat> {
 ///
 /// ```rust
 /// # #![allow(unused_must_use)]
-/// use std::io::fs;
+/// use std::old_io::fs;
 ///
 /// fs::rename(&Path::new("foo"), &Path::new("bar"));
 /// ```
@@ -359,7 +359,7 @@ pub fn rename(from: &Path, to: &Path) -> IoResult<()> {
 ///
 /// ```rust
 /// # #![allow(unused_must_use)]
-/// use std::io::fs;
+/// use std::old_io::fs;
 ///
 /// fs::copy(&Path::new("foo.txt"), &Path::new("bar.txt"));
 /// ```
@@ -386,7 +386,7 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
 
     if !from.is_file() {
         return update_err(Err(IoError {
-            kind: io::MismatchedFileTypeForOperation,
+            kind: old_io::MismatchedFileTypeForOperation,
             desc: "the source path is not an existing file",
             detail: None
         }), from, to)
@@ -408,12 +408,12 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
 /// ```rust
 /// # #![allow(unused_must_use)]
 /// use std::io;
-/// use std::io::fs;
+/// use std::old_io::fs;
 ///
-/// fs::chmod(&Path::new("file.txt"), io::USER_FILE);
+/// fs::chmod(&Path::new("file.txt"), old_io::USER_FILE);
-/// fs::chmod(&Path::new("file.txt"), io::USER_READ | io::USER_WRITE);
+/// fs::chmod(&Path::new("file.txt"), old_io::USER_READ | old_io::USER_WRITE);
-/// fs::chmod(&Path::new("dir"),      io::USER_DIR);
+/// fs::chmod(&Path::new("dir"),      old_io::USER_DIR);
-/// fs::chmod(&Path::new("file.exe"), io::USER_EXEC);
+/// fs::chmod(&Path::new("file.exe"), old_io::USER_EXEC);
 /// ```
 ///
 /// # Error
@@ -421,7 +421,7 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
 /// This function will return an error if the provided `path` doesn't exist, if
 /// the process lacks permissions to change the attributes of the file, or if
 /// some other I/O error is encountered.
-pub fn chmod(path: &Path, mode: io::FilePermission) -> IoResult<()> {
+pub fn chmod(path: &Path, mode: old_io::FilePermission) -> IoResult<()> {
     fs_imp::chmod(path, mode.bits() as uint)
            .update_err("couldn't chmod path", |e|
                format!("{}; path={}; mode={:?}", e, path.display(), mode))
@@ -470,10 +470,10 @@ pub fn readlink(path: &Path) -> IoResult<Path> {
 /// ```rust
 /// # #![allow(unused_must_use)]
 /// use std::io;
-/// use std::io::fs;
+/// use std::old_io::fs;
 ///
 /// let p = Path::new("/some/dir");
-/// fs::mkdir(&p, io::USER_RWX);
+/// fs::mkdir(&p, old_io::USER_RWX);
 /// ```
 ///
 /// # Error
@@ -492,7 +492,7 @@ pub fn mkdir(path: &Path, mode: FilePermission) -> IoResult<()> {
 ///
 /// ```rust
 /// # #![allow(unused_must_use)]
-/// use std::io::fs;
+/// use std::old_io::fs;
 ///
 /// let p = Path::new("/some/dir");
 /// fs::rmdir(&p);
@@ -513,12 +513,12 @@ pub fn rmdir(path: &Path) -> IoResult<()> {
 /// # Example
 ///
 /// ```rust
-/// use std::io::fs::PathExtensions;
+/// use std::old_io::fs::PathExtensions;
-/// use std::io::fs;
+/// use std::old_io::fs;
 /// use std::io;
 ///
 /// // one possible implementation of fs::walk_dir only visiting files
-/// fn visit_dirs<F>(dir: &Path, cb: &mut F) -> io::IoResult<()> where
+/// fn visit_dirs<F>(dir: &Path, cb: &mut F) -> old_io::IoResult<()> where
 ///     F: FnMut(&Path),
 /// {
 ///     if dir.is_dir() {
@@ -532,7 +532,7 @@ pub fn rmdir(path: &Path) -> IoResult<()> {
 ///         }
 ///         Ok(())
 ///     } else {
-///         Err(io::standard_error(io::InvalidInput))
+///         Err(old_io::standard_error(old_io::InvalidInput))
 ///     }
 /// }
 /// ```
@@ -664,7 +664,7 @@ pub fn rmdir_recursive(path: &Path) -> IoResult<()> {
                 // (eg: deleted by someone else since readdir)
                 match update_err(unlink(&child), path) {
                     Ok(()) => (),
-                    Err(ref e) if e.kind == io::FileNotFound => (),
+                    Err(ref e) if e.kind == old_io::FileNotFound => (),
                     Err(e) => return Err(e)
                 }
             }
@@ -675,7 +675,7 @@ pub fn rmdir_recursive(path: &Path) -> IoResult<()> {
             let result = update_err(rmdir(&rm_stack.pop().unwrap()), path);
             match result {
                 Ok(()) => (),
-                Err(ref e) if e.kind == io::FileNotFound => (),
+                Err(ref e) if e.kind == old_io::FileNotFound => (),
                 Err(e) => return Err(e)
             }
         }
@@ -709,7 +709,7 @@ impl Reader for File {
             Ok(read) => {
                 self.last_nread = read as int;
                 match read {
-                    0 => update_err(Err(standard_error(io::EndOfFile)), self),
+                    0 => update_err(Err(standard_error(old_io::EndOfFile)), self),
                     _ => Ok(read as uint)
                 }
             },
@@ -824,10 +824,10 @@ fn access_string(access: FileAccess) -> &'static str {
 #[allow(unused_mut)]
 mod test {
     use prelude::v1::*;
-    use io::{SeekSet, SeekCur, SeekEnd, Read, Open, ReadWrite, FileType};
+    use old_io::{SeekSet, SeekCur, SeekEnd, Read, Open, ReadWrite, FileType};
     use io;
     use str;
-    use io::fs::*;
+    use old_io::fs::*;
 
     macro_rules! check { ($e:expr) => (
         match $e {
@@ -863,7 +863,7 @@ mod test {
             // Gee, seeing how we're testing the fs module I sure hope that we
             // at least implement this correctly!
             let TempDir(ref p) = *self;
-            check!(io::fs::rmdir_recursive(p));
+            check!(old_io::fs::rmdir_recursive(p));
         }
     }
 
@@ -871,7 +871,7 @@ mod test {
         use os;
         use rand;
         let ret = os::tmpdir().join(format!("rust-{}", rand::random::<u32>()));
-        check!(io::fs::mkdir(&ret, io::USER_RWX));
+        check!(old_io::fs::mkdir(&ret, old_io::USER_RWX));
         TempDir(ret)
     }
 
@@ -1055,7 +1055,7 @@ mod test {
     fn file_test_stat_is_correct_on_is_dir() {
         let tmpdir = tmpdir();
         let filename = &tmpdir.join("file_stat_correct_on_is_dir");
-        check!(mkdir(filename, io::USER_RWX));
+        check!(mkdir(filename, old_io::USER_RWX));
         let stat_res_fn = check!(stat(filename));
         assert!(stat_res_fn.kind == FileType::Directory);
         let stat_res_meth = check!(filename.stat());
@@ -1067,7 +1067,7 @@ mod test {
     fn file_test_fileinfo_false_when_checking_is_file_on_a_directory() {
         let tmpdir = tmpdir();
         let dir = &tmpdir.join("fileinfo_false_on_dir");
-        check!(mkdir(dir, io::USER_RWX));
+        check!(mkdir(dir, old_io::USER_RWX));
         assert!(dir.is_file() == false);
         check!(rmdir(dir));
     }
@@ -1087,7 +1087,7 @@ mod test {
         let tmpdir = tmpdir();
         let dir = &tmpdir.join("before_and_after_dir");
         assert!(!dir.exists());
-        check!(mkdir(dir, io::USER_RWX));
+        check!(mkdir(dir, old_io::USER_RWX));
         assert!(dir.exists());
         assert!(dir.is_dir());
         check!(rmdir(dir));
@@ -1099,7 +1099,7 @@ mod test {
         use str;
         let tmpdir = tmpdir();
         let dir = &tmpdir.join("di_readdir");
-        check!(mkdir(dir, io::USER_RWX));
+        check!(mkdir(dir, old_io::USER_RWX));
         let prefix = "foo";
         for n in range(0i,3) {
             let f = dir.join(format!("{}.txt", n));
@@ -1130,14 +1130,14 @@ mod test {
     fn file_test_walk_dir() {
         let tmpdir = tmpdir();
         let dir = &tmpdir.join("walk_dir");
-        check!(mkdir(dir, io::USER_RWX));
+        check!(mkdir(dir, old_io::USER_RWX));
 
         let dir1 = &dir.join("01/02/03");
-        check!(mkdir_recursive(dir1, io::USER_RWX));
+        check!(mkdir_recursive(dir1, old_io::USER_RWX));
         check!(File::create(&dir1.join("04")));
 
         let dir2 = &dir.join("11/12/13");
-        check!(mkdir_recursive(dir2, io::USER_RWX));
+        check!(mkdir_recursive(dir2, old_io::USER_RWX));
         check!(File::create(&dir2.join("14")));
 
         let mut files = check!(walk_dir(dir));
@@ -1155,12 +1155,12 @@ mod test {
 
     #[test]
     fn mkdir_path_already_exists_error() {
-        use io::{IoError, PathAlreadyExists};
+        use old_io::{IoError, PathAlreadyExists};
 
         let tmpdir = tmpdir();
         let dir = &tmpdir.join("mkdir_error_twice");
-        check!(mkdir(dir, io::USER_RWX));
+        check!(mkdir(dir, old_io::USER_RWX));
-        match mkdir(dir, io::USER_RWX) {
+        match mkdir(dir, old_io::USER_RWX) {
             Err(IoError{kind:PathAlreadyExists,..}) => (),
             _ => assert!(false)
         };
@@ -1170,7 +1170,7 @@ mod test {
     fn recursive_mkdir() {
         let tmpdir = tmpdir();
         let dir = tmpdir.join("d1/d2");
-        check!(mkdir_recursive(&dir, io::USER_RWX));
+        check!(mkdir_recursive(&dir, old_io::USER_RWX));
         assert!(dir.is_dir())
     }
 
@@ -1180,10 +1180,10 @@ mod test {
         let dir = tmpdir.join("d1");
         let file = dir.join("f1");
 
-        check!(mkdir_recursive(&dir, io::USER_RWX));
+        check!(mkdir_recursive(&dir, old_io::USER_RWX));
         check!(File::create(&file));
 
-        let result = mkdir_recursive(&file, io::USER_RWX);
+        let result = mkdir_recursive(&file, old_io::USER_RWX);
 
         error!(result, "couldn't recursively mkdir");
         error!(result, "couldn't create directory");
@@ -1193,7 +1193,7 @@ mod test {
 
     #[test]
     fn recursive_mkdir_slash() {
-        check!(mkdir_recursive(&Path::new("/"), io::USER_RWX));
+        check!(mkdir_recursive(&Path::new("/"), old_io::USER_RWX));
     }
 
     // FIXME(#12795) depends on lstat to work on windows
@@ -1206,8 +1206,8 @@ mod test {
         let dtt = dt.join("t");
         let d2 = tmpdir.join("d2");
         let canary = d2.join("do_not_delete");
-        check!(mkdir_recursive(&dtt, io::USER_RWX));
+        check!(mkdir_recursive(&dtt, old_io::USER_RWX));
-        check!(mkdir_recursive(&d2, io::USER_RWX));
+        check!(mkdir_recursive(&d2, old_io::USER_RWX));
         check!(File::create(&canary).write(b"foo"));
         check!(symlink(&d2, &dt.join("d2")));
         check!(rmdir_recursive(&d1));
@@ -1225,7 +1225,7 @@ mod test {
 
         let mut dirpath = tmpdir.path().clone();
         dirpath.push(format!("test-가一ー你好"));
-        check!(mkdir(&dirpath, io::USER_RWX));
+        check!(mkdir(&dirpath, old_io::USER_RWX));
         assert!(dirpath.is_dir());
 
         let mut filepath = dirpath;
@@ -1243,7 +1243,7 @@ mod test {
         let tmpdir = tmpdir();
         let unicode = tmpdir.path();
         let unicode = unicode.join(format!("test-각丁ー再见"));
-        check!(mkdir(&unicode, io::USER_RWX));
+        check!(mkdir(&unicode, old_io::USER_RWX));
         assert!(unicode.exists());
         assert!(!Path::new("test/unicode-bogus-path-각丁ー再见").exists());
     }
@@ -1324,12 +1324,12 @@ mod test {
         let out = tmpdir.join("out.txt");
 
         check!(File::create(&input));
-        check!(chmod(&input, io::USER_READ));
+        check!(chmod(&input, old_io::USER_READ));
         check!(copy(&input, &out));
-        assert!(!check!(out.stat()).perm.intersects(io::USER_WRITE));
+        assert!(!check!(out.stat()).perm.intersects(old_io::USER_WRITE));
 
-        check!(chmod(&input, io::USER_FILE));
+        check!(chmod(&input, old_io::USER_FILE));
-        check!(chmod(&out, io::USER_FILE));
+        check!(chmod(&out, old_io::USER_FILE));
     }
 
     #[cfg(not(windows))] // FIXME(#10264) operation not permitted?
@@ -1405,16 +1405,16 @@ mod test {
         let file = tmpdir.join("in.txt");
 
         check!(File::create(&file));
-        assert!(check!(stat(&file)).perm.contains(io::USER_WRITE));
+        assert!(check!(stat(&file)).perm.contains(old_io::USER_WRITE));
-        check!(chmod(&file, io::USER_READ));
+        check!(chmod(&file, old_io::USER_READ));
-        assert!(!check!(stat(&file)).perm.contains(io::USER_WRITE));
+        assert!(!check!(stat(&file)).perm.contains(old_io::USER_WRITE));
 
-        match chmod(&tmpdir.join("foo"), io::USER_RWX) {
+        match chmod(&tmpdir.join("foo"), old_io::USER_RWX) {
             Ok(..) => panic!("wanted a panic"),
             Err(..) => {}
         }
 
-        check!(chmod(&file, io::USER_FILE));
+        check!(chmod(&file, old_io::USER_FILE));
     }
 
     #[test]
@@ -1422,7 +1422,7 @@ mod test {
         let tmpdir = tmpdir();
         let path = tmpdir.join("in.txt");
 
-        let mut file = check!(File::open_mode(&path, io::Open, io::ReadWrite));
+        let mut file = check!(File::open_mode(&path, old_io::Open, old_io::ReadWrite));
         check!(file.fsync());
         check!(file.datasync());
         check!(file.write(b"foo"));
@@ -1436,7 +1436,7 @@ mod test {
         let tmpdir = tmpdir();
         let path = tmpdir.join("in.txt");
 
-        let mut file = check!(File::open_mode(&path, io::Open, io::ReadWrite));
+        let mut file = check!(File::open_mode(&path, old_io::Open, old_io::ReadWrite));
         check!(file.write(b"foo"));
         check!(file.fsync());
 
@@ -1467,41 +1467,41 @@ mod test {
     fn open_flavors() {
         let tmpdir = tmpdir();
 
-        match File::open_mode(&tmpdir.join("a"), io::Open, io::Read) {
+        match File::open_mode(&tmpdir.join("a"), old_io::Open, old_io::Read) {
             Ok(..) => panic!(), Err(..) => {}
         }
 
         // Perform each one twice to make sure that it succeeds the second time
         // (where the file exists)
-        check!(File::open_mode(&tmpdir.join("b"), io::Open, io::Write));
+        check!(File::open_mode(&tmpdir.join("b"), old_io::Open, old_io::Write));
         assert!(tmpdir.join("b").exists());
-        check!(File::open_mode(&tmpdir.join("b"), io::Open, io::Write));
+        check!(File::open_mode(&tmpdir.join("b"), old_io::Open, old_io::Write));
 
-        check!(File::open_mode(&tmpdir.join("c"), io::Open, io::ReadWrite));
+        check!(File::open_mode(&tmpdir.join("c"), old_io::Open, old_io::ReadWrite));
         assert!(tmpdir.join("c").exists());
-        check!(File::open_mode(&tmpdir.join("c"), io::Open, io::ReadWrite));
+        check!(File::open_mode(&tmpdir.join("c"), old_io::Open, old_io::ReadWrite));
 
-        check!(File::open_mode(&tmpdir.join("d"), io::Append, io::Write));
+        check!(File::open_mode(&tmpdir.join("d"), old_io::Append, old_io::Write));
         assert!(tmpdir.join("d").exists());
-        check!(File::open_mode(&tmpdir.join("d"), io::Append, io::Write));
+        check!(File::open_mode(&tmpdir.join("d"), old_io::Append, old_io::Write));
 
-        check!(File::open_mode(&tmpdir.join("e"), io::Append, io::ReadWrite));
+        check!(File::open_mode(&tmpdir.join("e"), old_io::Append, old_io::ReadWrite));
         assert!(tmpdir.join("e").exists());
-        check!(File::open_mode(&tmpdir.join("e"), io::Append, io::ReadWrite));
+        check!(File::open_mode(&tmpdir.join("e"), old_io::Append, old_io::ReadWrite));
 
-        check!(File::open_mode(&tmpdir.join("f"), io::Truncate, io::Write));
+        check!(File::open_mode(&tmpdir.join("f"), old_io::Truncate, old_io::Write));
         assert!(tmpdir.join("f").exists());
-        check!(File::open_mode(&tmpdir.join("f"), io::Truncate, io::Write));
+        check!(File::open_mode(&tmpdir.join("f"), old_io::Truncate, old_io::Write));
 
-        check!(File::open_mode(&tmpdir.join("g"), io::Truncate, io::ReadWrite));
+        check!(File::open_mode(&tmpdir.join("g"), old_io::Truncate, old_io::ReadWrite));
         assert!(tmpdir.join("g").exists());
-        check!(File::open_mode(&tmpdir.join("g"), io::Truncate, io::ReadWrite));
+        check!(File::open_mode(&tmpdir.join("g"), old_io::Truncate, old_io::ReadWrite));
 
         check!(File::create(&tmpdir.join("h")).write("foo".as_bytes()));
-        check!(File::open_mode(&tmpdir.join("h"), io::Open, io::Read));
+        check!(File::open_mode(&tmpdir.join("h"), old_io::Open, old_io::Read));
         {
-            let mut f = check!(File::open_mode(&tmpdir.join("h"), io::Open,
+            let mut f = check!(File::open_mode(&tmpdir.join("h"), old_io::Open,
-                                               io::Read));
+                                               old_io::Read));
             match f.write("wut".as_bytes()) {
                 Ok(..) => panic!(), Err(..) => {}
             }
@@ -1509,15 +1509,15 @@ mod test {
         assert!(check!(stat(&tmpdir.join("h"))).size == 3,
                 "write/stat failed");
         {
-            let mut f = check!(File::open_mode(&tmpdir.join("h"), io::Append,
+            let mut f = check!(File::open_mode(&tmpdir.join("h"), old_io::Append,
-                                               io::Write));
+                                               old_io::Write));
             check!(f.write("bar".as_bytes()));
         }
         assert!(check!(stat(&tmpdir.join("h"))).size == 6,
                 "append didn't append");
         {
-            let mut f = check!(File::open_mode(&tmpdir.join("h"), io::Truncate,
+            let mut f = check!(File::open_mode(&tmpdir.join("h"), old_io::Truncate,
-                                               io::Write));
+                                               old_io::Write));
             check!(f.write("bar".as_bytes()));
         }
         assert!(check!(stat(&tmpdir.join("h"))).size == 3,
@@ -1529,8 +1529,9 @@ mod test {
         let tmpdir = tmpdir();
         let path = tmpdir.join("a");
         check!(File::create(&path));
-        // These numbers have to be bigger than the time in the day to account for timezones
+        // These numbers have to be bigger than the time in the day to account
-        // Windows in particular will fail in certain timezones with small enough values
+        // for timezones Windows in particular will fail in certain timezones
+        // with small enough values
         check!(change_file_times(&path, 100000, 200000));
         assert_eq!(check!(path.stat()).accessed, 100000);
         assert_eq!(check!(path.stat()).modified, 200000);
@@ -1565,7 +1566,7 @@ mod test {
         let tmpdir = tmpdir();
         let path = tmpdir.join("file");
         check!(File::create(&path));
-        check!(chmod(&path, io::USER_READ));
+        check!(chmod(&path, old_io::USER_READ));
         check!(unlink(&path));
     }
 }

src/libstd/old_io/mem.rs

@@ -15,8 +15,8 @@
 use cmp::min;
 use option::Option::None;
 use result::Result::{Err, Ok};
-use io;
+use old_io;
-use io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult};
+use old_io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult};
 use slice::{self, AsSlice, SliceExt};
 use vec::Vec;
 
@@ -25,14 +25,14 @@ const BUF_CAPACITY: uint = 128;
 fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64> {
     // compute offset as signed and clamp to prevent overflow
     let pos = match seek {
-        io::SeekSet => 0,
+        old_io::SeekSet => 0,
-        io::SeekEnd => end,
+        old_io::SeekEnd => end,
-        io::SeekCur => cur,
+        old_io::SeekCur => cur,
     } as i64;
 
     if offset + pos < 0 {
         Err(IoError {
-            kind: io::InvalidInput,
+            kind: old_io::InvalidInput,
             desc: "invalid seek to a negative offset",
             detail: None
         })
@@ -55,7 +55,7 @@ impl Writer for Vec<u8> {
 ///
 /// ```rust
 /// # #![allow(unused_must_use)]
-/// use std::io::MemWriter;
+/// use std::old_io::MemWriter;
 ///
 /// let mut w = MemWriter::new();
 /// w.write(&[0, 1, 2]);
@@ -111,7 +111,7 @@ impl Writer for MemWriter {
 ///
 /// ```rust
 /// # #![allow(unused_must_use)]
-/// use std::io::MemReader;
+/// use std::old_io::MemReader;
 ///
 /// let mut r = MemReader::new(vec!(0, 1, 2));
 ///
@@ -155,7 +155,7 @@ impl MemReader {
 impl Reader for MemReader {
     #[inline]
     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
-        if self.eof() { return Err(io::standard_error(io::EndOfFile)) }
+        if self.eof() { return Err(old_io::standard_error(old_io::EndOfFile)) }
 
         let write_len = min(buf.len(), self.buf.len() - self.pos);
         {
@@ -189,7 +189,7 @@ impl Buffer for MemReader {
         if self.pos < self.buf.len() {
             Ok(&self.buf[self.pos..])
         } else {
-            Err(io::standard_error(io::EndOfFile))
+            Err(old_io::standard_error(old_io::EndOfFile))
         }
     }
 
@@ -200,7 +200,7 @@ impl Buffer for MemReader {
 impl<'a> Reader for &'a [u8] {
     #[inline]
     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
-        if self.is_empty() { return Err(io::standard_error(io::EndOfFile)); }
+        if self.is_empty() { return Err(old_io::standard_error(old_io::EndOfFile)); }
 
         let write_len = min(buf.len(), self.len());
         {
@@ -219,7 +219,7 @@ impl<'a> Buffer for &'a [u8] {
     #[inline]
     fn fill_buf(&mut self) -> IoResult<&[u8]> {
         if self.is_empty() {
-            Err(io::standard_error(io::EndOfFile))
+            Err(old_io::standard_error(old_io::EndOfFile))
         } else {
             Ok(*self)
         }
@@ -241,7 +241,7 @@ impl<'a> Buffer for &'a [u8] {
 ///
 /// ```rust
 /// # #![allow(unused_must_use)]
-/// use std::io::BufWriter;
+/// use std::old_io::BufWriter;
 ///
 /// let mut buf = [0; 4];
 /// {
@@ -274,7 +274,7 @@ impl<'a> Writer for BufWriter<'a> {
         let dst_len = dst.len();
 
         if dst_len == 0 {
-            return Err(io::standard_error(io::EndOfFile));
+            return Err(old_io::standard_error(old_io::EndOfFile));
         }
 
         let src_len = src.len();
@@ -290,7 +290,7 @@ impl<'a> Writer for BufWriter<'a> {
 
             self.pos += dst_len;
 
-            Err(io::standard_error(io::ShortWrite(dst_len)))
+            Err(old_io::standard_error(old_io::ShortWrite(dst_len)))
         }
     }
 }
@@ -313,7 +313,7 @@ impl<'a> Seek for BufWriter<'a> {
 ///
 /// ```rust
 /// # #![allow(unused_must_use)]
-/// use std::io::BufReader;
+/// use std::old_io::BufReader;
 ///
 /// let buf = [0, 1, 2, 3];
 /// let mut r = BufReader::new(&buf);
@@ -345,7 +345,7 @@ impl<'a> BufReader<'a> {
 impl<'a> Reader for BufReader<'a> {
     #[inline]
     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
-        if self.eof() { return Err(io::standard_error(io::EndOfFile)) }
+        if self.eof() { return Err(old_io::standard_error(old_io::EndOfFile)) }
 
         let write_len = min(buf.len(), self.buf.len() - self.pos);
         {
@@ -379,7 +379,7 @@ impl<'a> Buffer for BufReader<'a> {
         if self.pos < self.buf.len() {
             Ok(&self.buf[self.pos..])
         } else {
-            Err(io::standard_error(io::EndOfFile))
+            Err(old_io::standard_error(old_io::EndOfFile))
         }
     }
 
@@ -390,7 +390,7 @@ impl<'a> Buffer for BufReader<'a> {
 #[cfg(test)]
 mod test {
     extern crate "test" as test_crate;
-    use io::{SeekSet, SeekCur, SeekEnd, Reader, Writer, Seek};
+    use old_io::{SeekSet, SeekCur, SeekEnd, Reader, Writer, Seek};
     use prelude::v1::{Ok, Err, range,  Vec, Buffer,  AsSlice, SliceExt};
     use prelude::v1::IteratorExt;
     use io;
@@ -432,8 +432,8 @@ mod test {
             writer.write(&[]).unwrap();
             assert_eq!(writer.tell(), Ok(8));
 
-            assert_eq!(writer.write(&[8, 9]).err().unwrap().kind, io::ShortWrite(1));
+            assert_eq!(writer.write(&[8, 9]).err().unwrap().kind, old_io::ShortWrite(1));
-            assert_eq!(writer.write(&[10]).err().unwrap().kind, io::EndOfFile);
+            assert_eq!(writer.write(&[10]).err().unwrap().kind, old_io::EndOfFile);
         }
         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
         assert_eq!(buf, b);
@@ -476,7 +476,7 @@ mod test {
 
         match writer.write(&[0, 0]) {
             Ok(..) => panic!(),
-            Err(e) => assert_eq!(e.kind, io::ShortWrite(1)),
+            Err(e) => assert_eq!(e.kind, old_io::ShortWrite(1)),
         }
     }
 

src/libstd/old_io/mod.rs

@@ -18,6 +18,24 @@
 
 //! I/O, including files, networking, timers, and processes
 //!
+//! > **Warning**: This module is currently called `old_io` for a reason! The
+//! > module is currently being redesigned in a number of RFCs. For more details
+//! > follow the RFC repository in connection with [RFC 517][base] or follow
+//! > some of these sub-RFCs
+//! >
+//! > * [String handling][osstr]
+//! > * [Core I/O support][core]
+//! > * [Deadlines][deadlines]
+//! > * [std::env][env]
+//! > * [std::process][process]
+//!
+//! [base]: https://github.com/rust-lang/rfcs/blob/master/text/0517-io-os-reform.md
+//! [osstr]: https://github.com/rust-lang/rfcs/pull/575
+//! [core]: https://github.com/rust-lang/rfcs/pull/576
+//! [deadlines]: https://github.com/rust-lang/rfcs/pull/577
+//! [env]: https://github.com/rust-lang/rfcs/pull/578
+//! [process]: https://github.com/rust-lang/rfcs/pull/579
+//!
 //! `std::io` provides Rust's basic I/O types,
 //! for reading and writing to files, TCP, UDP,
 //! and other types of sockets and pipes,
@@ -30,7 +48,7 @@
 //! * Read lines from stdin
 //!
 //!     ```rust
-//!     use std::io;
+//!     use std::old_io as io;
 //!
 //!     for line in io::stdin().lock().lines() {
 //!         print!("{}", line.unwrap());
@@ -40,7 +58,7 @@
 //! * Read a complete file
 //!
 //!     ```rust
-//!     use std::io::File;
+//!     use std::old_io::File;
 //!
 //!     let contents = File::open(&Path::new("message.txt")).read_to_end();
 //!     ```
@@ -49,19 +67,19 @@
 //!
 //!     ```rust
 //!     # #![allow(unused_must_use)]
-//!     use std::io::File;
+//!     use std::old_io::File;
 //!
 //!     let mut file = File::create(&Path::new("message.txt"));
 //!     file.write(b"hello, file!\n");
 //!     # drop(file);
-//!     # ::std::io::fs::unlink(&Path::new("message.txt"));
+//!     # ::std::old_io::fs::unlink(&Path::new("message.txt"));
 //!     ```
 //!
 //! * Iterate over the lines of a file
 //!
 //!     ```rust,no_run
-//!     use std::io::BufferedReader;
+//!     use std::old_io::BufferedReader;
-//!     use std::io::File;
+//!     use std::old_io::File;
 //!
 //!     let path = Path::new("message.txt");
 //!     let mut file = BufferedReader::new(File::open(&path));
@@ -73,8 +91,8 @@
 //! * Pull the lines of a file into a vector of strings
 //!
 //!     ```rust,no_run
-//!     use std::io::BufferedReader;
+//!     use std::old_io::BufferedReader;
-//!     use std::io::File;
+//!     use std::old_io::File;
 //!
 //!     let path = Path::new("message.txt");
 //!     let mut file = BufferedReader::new(File::open(&path));
@@ -85,7 +103,7 @@
 //!
 //!     ```rust
 //!     # #![allow(unused_must_use)]
-//!     use std::io::TcpStream;
+//!     use std::old_io::TcpStream;
 //!
 //!     # // connection doesn't fail if a server is running on 8080
 //!     # // locally, we still want to be type checking this code, so lets
@@ -103,8 +121,8 @@
 //!     # fn main() { }
 //!     # fn foo() {
 //!     # #![allow(dead_code)]
-//!     use std::io::{TcpListener, TcpStream};
+//!     use std::old_io::{TcpListener, TcpStream};
-//!     use std::io::{Acceptor, Listener};
+//!     use std::old_io::{Acceptor, Listener};
 //!     use std::thread::Thread;
 //!
 //!     let listener = TcpListener::bind("127.0.0.1:80");
@@ -166,14 +184,14 @@
 //!
 //! ```rust
 //! # #![allow(unused_must_use)]
-//! use std::io::File;
+//! use std::old_io::File;
 //!
 //! match File::create(&Path::new("diary.txt")).write(b"Met a girl.\n") {
 //!     Ok(()) => (), // succeeded
 //!     Err(e) => println!("failed to write to my diary: {}", e),
 //! }
 //!
-//! # ::std::io::fs::unlink(&Path::new("diary.txt"));
+//! # ::std::old_io::fs::unlink(&Path::new("diary.txt"));
 //! ```
 //!
 //! So what actually happens if `create` encounters an error?
@@ -199,7 +217,7 @@
 //! If you wanted to read several `u32`s from a file and return their product:
 //!
 //! ```rust
-//! use std::io::{File, IoResult};
+//! use std::old_io::{File, IoResult};
 //!
 //! fn file_product(p: &Path) -> IoResult<u32> {
 //!     let mut f = File::open(p);
@@ -925,9 +943,9 @@ unsafe fn slice_vec_capacity<'a, T>(v: &'a mut Vec<T>, start: uint, end: uint) -
 /// # Examples
 ///
 /// ```
-/// use std::io;
+/// use std::old_io as io;
-/// use std::io::ByRefReader;
+/// use std::old_io::ByRefReader;
-/// use std::io::util::LimitReader;
+/// use std::old_io::util::LimitReader;
 ///
 /// fn process_input<R: Reader>(r: R) {}
 ///
@@ -1254,8 +1272,8 @@ impl<'a> Writer for &'a mut (Writer+'a) {
 /// # Example
 ///
 /// ```
-/// use std::io::util::TeeReader;
+/// use std::old_io::util::TeeReader;
-/// use std::io::{stdin, ByRefWriter};
+/// use std::old_io::{stdin, ByRefWriter};
 ///
 /// fn process_input<R: Reader>(r: R) {}
 ///
@@ -1379,7 +1397,7 @@ pub trait Buffer: Reader {
     /// # Example
     ///
     /// ```rust
-    /// use std::io::BufReader;
+    /// use std::old_io::BufReader;
     ///
     /// let mut reader = BufReader::new(b"hello\nworld");
     /// assert_eq!("hello\n", &*reader.read_line().unwrap());
@@ -1601,7 +1619,7 @@ impl<'a, T, A: ?Sized + Acceptor<T>> Iterator for IncomingConnections<'a, A> {
 /// # Example
 ///
 /// ```
-/// use std::io;
+/// use std::old_io as io;
 ///
 /// let eof = io::standard_error(io::EndOfFile);
 /// let einval = io::standard_error(io::InvalidInput);
@@ -1691,7 +1709,7 @@ pub enum FileType {
 /// ```no_run
 /// # #![allow(unstable)]
 ///
-/// use std::io::fs::PathExtensions;
+/// use std::old_io::fs::PathExtensions;
 ///
 /// let info = match Path::new("foo.txt").stat() {
 ///     Ok(stat) => stat,

src/libstd/old_io/net/addrinfo.rs

@@ -20,8 +20,8 @@ pub use self::Flag::*;
 pub use self::Protocol::*;
 
 use iter::IteratorExt;
-use io::{IoResult};
+use old_io::{IoResult};
-use io::net::ip::{SocketAddr, IpAddr};
+use old_io::net::ip::{SocketAddr, IpAddr};
 use option::Option;
 use option::Option::{Some, None};
 use string::String;
@@ -114,7 +114,7 @@ fn lookup(hostname: Option<&str>, servname: Option<&str>, hint: Option<Hint>)
 mod test {
     use prelude::v1::*;
     use super::*;
-    use io::net::ip::*;
+    use old_io::net::ip::*;
 
     #[test]
     fn dns_smoke_test() {

src/libstd/old_io/net/ip.rs

@@ -19,8 +19,8 @@ pub use self::IpAddr::*;
 
 use boxed::Box;
 use fmt;
-use io::{self, IoResult, IoError};
+use old_io::{self, IoResult, IoError};
-use io::net;
+use old_io::net;
 use iter::{Iterator, IteratorExt};
 use ops::{FnOnce, FnMut};
 use option::Option;
@@ -406,9 +406,9 @@ impl FromStr for SocketAddr {
 /// ```rust,no_run
 /// # #![allow(unused_must_use)]
 ///
-/// use std::io::{TcpStream, TcpListener};
+/// use std::old_io::{TcpStream, TcpListener};
-/// use std::io::net::udp::UdpSocket;
+/// use std::old_io::net::udp::UdpSocket;
-/// use std::io::net::ip::{Ipv4Addr, SocketAddr};
+/// use std::old_io::net::ip::{Ipv4Addr, SocketAddr};
 ///
 /// fn main() {
 ///     // The following lines are equivalent modulo possible "localhost" name resolution
@@ -438,7 +438,7 @@ pub trait ToSocketAddr {
     fn to_socket_addr(&self) -> IoResult<SocketAddr> {
         self.to_socket_addr_all()
             .and_then(|v| v.into_iter().next().ok_or_else(|| IoError {
-                kind: io::InvalidInput,
+                kind: old_io::InvalidInput,
                 desc: "no address available",
                 detail: None
             }))
@@ -481,7 +481,7 @@ fn parse_and_resolve_socket_addr(s: &str) -> IoResult<Vec<SocketAddr>> {
             match $e {
                 Some(r) => r,
                 None => return Err(IoError {
-                    kind: io::InvalidInput,
+                    kind: old_io::InvalidInput,
                     desc: $msg,
                     detail: None
                 })
@@ -526,7 +526,7 @@ impl<'a> ToSocketAddr for &'a str {
         parse_and_resolve_socket_addr(*self)
             .and_then(|v| v.into_iter().next()
                 .ok_or_else(|| IoError {
-                    kind: io::InvalidInput,
+                    kind: old_io::InvalidInput,
                     desc: "no address available",
                     detail: None
                 })

src/libstd/old_io/net/mod.rs

@@ -10,7 +10,7 @@
 
 //! Networking I/O
 
-use io::{IoError, IoResult, InvalidInput};
+use old_io::{IoError, IoResult, InvalidInput};
 use ops::FnMut;
 use option::Option::None;
 use result::Result::{Ok, Err};

src/libstd/old_io/net/pipe.rs

@@ -24,7 +24,7 @@ use prelude::v1::*;
 
 use ffi::CString;
 use path::BytesContainer;
-use io::{Listener, Acceptor, IoResult, TimedOut, standard_error};
+use old_io::{Listener, Acceptor, IoResult, TimedOut, standard_error};
 use sys::pipe::UnixAcceptor as UnixAcceptorImp;
 use sys::pipe::UnixListener as UnixListenerImp;
 use sys::pipe::UnixStream as UnixStreamImp;
@@ -48,7 +48,7 @@ impl UnixStream {
     ///
     /// ```rust
     /// # #![allow(unused_must_use)]
-    /// use std::io::net::pipe::UnixStream;
+    /// use std::old_io::net::pipe::UnixStream;
     ///
     /// let server = Path::new("path/to/my/socket");
     /// let mut stream = UnixStream::connect(&server);
@@ -169,8 +169,8 @@ impl UnixListener {
     ///
     /// ```
     /// # fn foo() {
-    /// use std::io::net::pipe::UnixListener;
+    /// use std::old_io::net::pipe::UnixListener;
-    /// use std::io::{Listener, Acceptor};
+    /// use std::old_io::{Listener, Acceptor};
     ///
     /// let server = Path::new("/path/to/my/socket");
     /// let stream = UnixListener::bind(&server);
@@ -270,11 +270,11 @@ impl sys_common::AsInner<UnixAcceptorImp> for UnixAcceptor {
 mod tests {
     use prelude::v1::*;
 
-    use io::fs::PathExtensions;
+    use old_io::fs::PathExtensions;
-    use io::{EndOfFile, TimedOut, ShortWrite, IoError, ConnectionReset};
+    use old_io::{EndOfFile, TimedOut, ShortWrite, IoError, ConnectionReset};
-    use io::{NotConnected, BrokenPipe, FileNotFound, InvalidInput, OtherIoError};
+    use old_io::{NotConnected, BrokenPipe, FileNotFound, InvalidInput, OtherIoError};
-    use io::{PermissionDenied, Acceptor, Listener};
+    use old_io::{PermissionDenied, Acceptor, Listener};
-    use io::test::*;
+    use old_io::test::*;
     use super::*;
     use sync::mpsc::channel;
     use thread::Thread;

src/libstd/old_io/net/tcp.rs

@@ -18,11 +18,11 @@
 //! listener (socket server) implements the `Listener` and `Acceptor` traits.
 
 use clone::Clone;
-use io::IoResult;
+use old_io::IoResult;
 use result::Result::Err;
-use io::net::ip::{SocketAddr, ToSocketAddr};
+use old_io::net::ip::{SocketAddr, ToSocketAddr};
-use io::{Reader, Writer, Listener, Acceptor};
+use old_io::{Reader, Writer, Listener, Acceptor};
-use io::{standard_error, TimedOut};
+use old_io::{standard_error, TimedOut};
 use option::Option;
 use option::Option::{None, Some};
 use time::Duration;
@@ -41,7 +41,7 @@ use sys_common;
 /// # Example
 ///
 /// ```no_run
-/// use std::io::TcpStream;
+/// use std::old_io::TcpStream;
 ///
 /// {
 ///     let mut stream = TcpStream::connect("127.0.0.1:34254");
@@ -133,8 +133,8 @@ impl TcpStream {
     ///
     /// ```no_run
     /// # #![allow(unused_must_use)]
-    /// use std::io::timer;
+    /// use std::old_io::timer;
-    /// use std::io::TcpStream;
+    /// use std::old_io::TcpStream;
     /// use std::time::Duration;
     /// use std::thread::Thread;
     ///
@@ -276,8 +276,8 @@ impl sys_common::AsInner<TcpStreamImp> for TcpStream {
 ///
 /// ```
 /// # fn foo() {
-/// use std::io::{TcpListener, TcpStream};
+/// use std::old_io::{TcpListener, TcpStream};
-/// use std::io::{Acceptor, Listener};
+/// use std::old_io::{Acceptor, Listener};
 /// use std::thread::Thread;
 ///
 /// let listener = TcpListener::bind("127.0.0.1:80").unwrap();
@@ -373,8 +373,8 @@ impl TcpAcceptor {
     ///
     /// ```no_run
     /// # #![allow(unstable)]
-    /// use std::io::TcpListener;
+    /// use std::old_io::TcpListener;
-    /// use std::io::{Listener, Acceptor, TimedOut};
+    /// use std::old_io::{Listener, Acceptor, TimedOut};
     ///
     /// let mut a = TcpListener::bind("127.0.0.1:8482").listen().unwrap();
     ///
@@ -417,7 +417,7 @@ impl TcpAcceptor {
     ///
     /// ```
     /// # #![allow(unstable)]
-    /// use std::io::{TcpListener, Listener, Acceptor, EndOfFile};
+    /// use std::old_io::{TcpListener, Listener, Acceptor, EndOfFile};
     /// use std::thread::Thread;
     ///
     /// let mut a = TcpListener::bind("127.0.0.1:8482").listen().unwrap();
@@ -486,13 +486,13 @@ mod test {
 
     use sync::mpsc::channel;
     use thread::Thread;
-    use io::net::tcp::*;
+    use old_io::net::tcp::*;
-    use io::net::ip::*;
+    use old_io::net::ip::*;
-    use io::test::*;
+    use old_io::test::*;
-    use io::{EndOfFile, TimedOut, ShortWrite, IoError};
+    use old_io::{EndOfFile, TimedOut, ShortWrite, IoError};
-    use io::{ConnectionRefused, BrokenPipe, ConnectionAborted};
+    use old_io::{ConnectionRefused, BrokenPipe, ConnectionAborted};
-    use io::{ConnectionReset, NotConnected, PermissionDenied, OtherIoError};
+    use old_io::{ConnectionReset, NotConnected, PermissionDenied, OtherIoError};
-    use io::{Acceptor, Listener};
+    use old_io::{Acceptor, Listener};
 
     // FIXME #11530 this fails on android because tests are run as root
     #[cfg_attr(any(windows, target_os = "android"), ignore)]

src/libstd/old_io/net/udp.rs

@@ -16,8 +16,8 @@
 //! datagram protocol.
 
 use clone::Clone;
-use io::net::ip::{SocketAddr, IpAddr, ToSocketAddr};
+use old_io::net::ip::{SocketAddr, IpAddr, ToSocketAddr};
-use io::IoResult;
+use old_io::IoResult;
 use option::Option;
 use sys::udp::UdpSocket as UdpSocketImp;
 use sys_common;
@@ -34,8 +34,8 @@ use sys_common;
 /// # #![allow(unused_must_use)]
 /// #![feature(slicing_syntax)]
 ///
-/// use std::io::net::udp::UdpSocket;
+/// use std::old_io::net::udp::UdpSocket;
-/// use std::io::net::ip::{Ipv4Addr, SocketAddr};
+/// use std::old_io::net::ip::{Ipv4Addr, SocketAddr};
 /// fn main() {
 ///     let addr = SocketAddr { ip: Ipv4Addr(127, 0, 0, 1), port: 34254 };
 ///     let mut socket = match UdpSocket::bind(addr) {
@@ -181,9 +181,9 @@ mod test {
     use prelude::v1::*;
 
     use sync::mpsc::channel;
-    use io::net::ip::*;
+    use old_io::net::ip::*;
-    use io::test::*;
+    use old_io::test::*;
-    use io::{IoError, TimedOut, PermissionDenied, ShortWrite};
+    use old_io::{IoError, TimedOut, PermissionDenied, ShortWrite};
     use super::*;
     use thread::Thread;
 

src/libstd/old_io/pipe.rs

@@ -17,7 +17,7 @@
 
 use prelude::v1::*;
 
-use io::IoResult;
+use old_io::IoResult;
 use libc;
 use sync::Arc;
 
@@ -49,7 +49,7 @@ impl PipeStream {
     /// # #![allow(unused_must_use)]
     /// extern crate libc;
     ///
-    /// use std::io::pipe::PipeStream;
+    /// use std::old_io::pipe::PipeStream;
     ///
     /// fn main() {
     ///     let mut pipe = PipeStream::open(libc::STDERR_FILENO);
@@ -120,7 +120,7 @@ mod test {
     #[test]
     fn partial_read() {
         use os;
-        use io::pipe::PipeStream;
+        use old_io::pipe::PipeStream;
 
         let os::Pipe { reader, writer } = unsafe { os::pipe().unwrap() };
         let out = PipeStream::open(writer);

src/libstd/old_io/process.rs

@@ -21,9 +21,9 @@ use prelude::v1::*;
 use collections::HashMap;
 use ffi::CString;
 use fmt;
-use io::pipe::{PipeStream, PipePair};
+use old_io::pipe::{PipeStream, PipePair};
-use io::{IoResult, IoError};
+use old_io::{IoResult, IoError};
-use io;
+use old_io;
 use libc;
 use os;
 use path::BytesContainer;
@@ -58,7 +58,7 @@ use thread::Thread;
 /// # Example
 ///
 /// ```should_fail
-/// use std::io::Command;
+/// use std::old_io::Command;
 ///
 /// let mut child = match Command::new("/bin/cat").arg("file.txt").spawn() {
 ///     Ok(child) => child,
@@ -159,7 +159,7 @@ pub type EnvMap = HashMap<EnvKey, CString>;
 /// to be changed (for example, by adding arguments) prior to spawning:
 ///
 /// ```
-/// use std::io::Command;
+/// use std::old_io::Command;
 ///
 /// let mut process = match Command::new("sh").arg("-c").arg("echo hello").spawn() {
 ///   Ok(p) => p,
@@ -359,7 +359,7 @@ impl Command {
     /// # Example
     ///
     /// ```
-    /// use std::io::Command;
+    /// use std::old_io::Command;
     ///
     /// let output = match Command::new("cat").arg("foot.txt").output() {
     ///     Ok(output) => output,
@@ -380,7 +380,7 @@ impl Command {
     /// # Example
     ///
     /// ```
-    /// use std::io::Command;
+    /// use std::old_io::Command;
     ///
     /// let status = match Command::new("ls").status() {
     ///     Ok(status) => status,
@@ -583,7 +583,7 @@ impl Process {
         // newer process that happens to have the same (re-used) id
         if self.exit_code.is_some() {
             return Err(IoError {
-                kind: io::InvalidInput,
+                kind: old_io::InvalidInput,
                 desc: "invalid argument: can't kill an exited process",
                 detail: None,
             })
@@ -654,8 +654,8 @@ impl Process {
     ///
     /// ```no_run
     /// # #![allow(unstable)]
-    /// use std::io::{Command, IoResult};
+    /// use std::old_io::{Command, IoResult};
-    /// use std::io::process::ProcessExit;
+    /// use std::old_io::process::ProcessExit;
     ///
     /// fn run_gracefully(prog: &str) -> IoResult<ProcessExit> {
     ///     let mut p = try!(Command::new("long-running-process").spawn());
@@ -698,7 +698,7 @@ impl Process {
     /// fail.
     pub fn wait_with_output(mut self) -> IoResult<ProcessOutput> {
         drop(self.stdin.take());
-        fn read(stream: Option<io::PipeStream>) -> Receiver<IoResult<Vec<u8>>> {
+        fn read(stream: Option<old_io::PipeStream>) -> Receiver<IoResult<Vec<u8>>> {
             let (tx, rx) = channel();
             match stream {
                 Some(stream) => {
@@ -752,12 +752,12 @@ impl Drop for Process {
 
 #[cfg(test)]
 mod tests {
-    use io::{Truncate, Write, TimedOut, timer, process, FileNotFound};
+    use old_io::{Truncate, Write, TimedOut, timer, process, FileNotFound};
     use prelude::v1::{Ok, Err, range, drop, Some, None, Vec};
     use prelude::v1::{Path, String, Reader, Writer, Clone};
     use prelude::v1::{SliceExt, Str, StrExt, AsSlice, ToString, GenericPath};
-    use io::fs::PathExtensions;
+    use old_io::fs::PathExtensions;
-    use io::timer::*;
+    use old_io::timer::*;
     use rt::running_on_valgrind;
     use str;
     use super::{CreatePipe};

src/libstd/old_io/stdio.rs

@@ -21,7 +21,7 @@
 //! # #![allow(unused_must_use)]
 //! use std::io;
 //!
-//! let mut out = io::stdout();
+//! let mut out = old_io::stdout();
 //! out.write(b"Hello, world!");
 //! ```
 
@@ -32,7 +32,7 @@ use cell::RefCell;
 use clone::Clone;
 use failure::LOCAL_STDERR;
 use fmt;
-use io::{Reader, Writer, IoResult, IoError, OtherIoError, Buffer,
+use old_io::{Reader, Writer, IoResult, IoError, OtherIoError, Buffer,
          standard_error, EndOfFile, LineBufferedWriter, BufferedReader};
 use marker::{Sync, Send};
 use libc;
@@ -143,7 +143,7 @@ impl StdinReader {
     /// ```rust
     /// use std::io;
     ///
-    /// for line in io::stdin().lock().lines() {
+    /// for line in old_io::stdin().lock().lines() {
     ///     println!("{}", line.unwrap());
     /// }
     /// ```
@@ -539,7 +539,7 @@ mod tests {
 
     #[test]
     fn capture_stdout() {
-        use io::{ChanReader, ChanWriter};
+        use old_io::{ChanReader, ChanWriter};
 
         let (tx, rx) = channel();
         let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx));
@@ -552,7 +552,7 @@ mod tests {
 
     #[test]
     fn capture_stderr() {
-        use io::{ChanReader, ChanWriter, Reader};
+        use old_io::{ChanReader, ChanWriter, Reader};
 
         let (tx, rx) = channel();
         let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx));

src/libstd/old_io/tempfile.rs

@@ -10,8 +10,8 @@
 
 //! Temporary files and directories
 
-use io::{fs, IoError, IoErrorKind, IoResult};
+use old_io::{fs, IoError, IoErrorKind, IoResult};
-use io;
+use old_io;
 use iter::{IteratorExt, range};
 use ops::Drop;
 use option::Option;
@@ -29,7 +29,7 @@ use string::String;
 /// # Examples
 ///
 /// ```no_run
-/// use std::io::TempDir;
+/// use std::old_io::TempDir;
 ///
 /// {
 ///     // create a temporary directory
@@ -113,7 +113,7 @@ impl TempDir {
                 suffix
             };
             let path = tmpdir.join(leaf);
-            match fs::mkdir(&path, io::USER_RWX) {
+            match fs::mkdir(&path, old_io::USER_RWX) {
                 Ok(_) => return Ok(TempDir { path: Some(path), disarmed: false }),
                 Err(IoError{kind:IoErrorKind::PathAlreadyExists,..}) => (),
                 Err(e) => return Err(e)

src/libstd/old_io/test.rs

@@ -14,7 +14,7 @@ use prelude::v1::*;
 
 use libc;
 use os;
-use std::io::net::ip::*;
+use std::old_io::net::ip::*;
 use sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
 
 /// Get a port number, starting at 9600, for use in tests

src/libstd/old_io/timer.rs

@@ -17,7 +17,7 @@
 
 use sync::mpsc::{Receiver, Sender, channel};
 use time::Duration;
-use io::IoResult;
+use old_io::IoResult;
 use sys::timer::Callback;
 use sys::timer::Timer as TimerImp;
 
@@ -31,7 +31,7 @@ use sys::timer::Timer as TimerImp;
 ///
 /// ```
 /// # fn foo() {
-/// use std::io::Timer;
+/// use std::old_io::Timer;
 /// use std::time::Duration;
 ///
 /// let mut timer = Timer::new().unwrap();
@@ -50,11 +50,11 @@ use sys::timer::Timer as TimerImp;
 /// ```
 ///
 /// If only sleeping is necessary, then a convenience API is provided through
-/// the `io::timer` module.
+/// the `old_io::timer` module.
 ///
 /// ```
 /// # fn foo() {
-/// use std::io::timer;
+/// use std::old_io::timer;
 /// use std::time::Duration;
 ///
 /// // Put this task to sleep for 5 seconds
@@ -115,7 +115,7 @@ impl Timer {
     /// # Example
     ///
     /// ```rust
-    /// use std::io::Timer;
+    /// use std::old_io::Timer;
     /// use std::time::Duration;
     ///
     /// let mut timer = Timer::new().unwrap();
@@ -128,7 +128,7 @@ impl Timer {
     /// ```
     ///
     /// ```rust
-    /// use std::io::Timer;
+    /// use std::old_io::Timer;
     /// use std::time::Duration;
     ///
     /// // Incorrect, method chaining-style:
@@ -167,7 +167,7 @@ impl Timer {
     /// # Example
     ///
     /// ```rust
-    /// use std::io::Timer;
+    /// use std::old_io::Timer;
     /// use std::time::Duration;
     ///
     /// let mut timer = Timer::new().unwrap();
@@ -186,7 +186,7 @@ impl Timer {
     /// ```
     ///
     /// ```rust
-    /// use std::io::Timer;
+    /// use std::old_io::Timer;
     /// use std::time::Duration;
     ///
     /// // Incorrect, method chaining-style.

src/libstd/old_io/util.rs

@@ -12,7 +12,7 @@
 
 use prelude::v1::*;
 use cmp;
-use io;
+use old_io;
 use slice::bytes::MutableByteVector;
 
 /// Wraps a `Reader`, limiting the number of bytes that can be read from it.
@@ -42,9 +42,9 @@ impl<R: Reader> LimitReader<R> {
 }
 
 impl<R: Reader> Reader for LimitReader<R> {
-    fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
+    fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
         if self.limit == 0 {
-            return Err(io::standard_error(io::EndOfFile));
+            return Err(old_io::standard_error(old_io::EndOfFile));
         }
 
         let len = cmp::min(self.limit, buf.len());
@@ -58,11 +58,11 @@ impl<R: Reader> Reader for LimitReader<R> {
 }
 
 impl<R: Buffer> Buffer for LimitReader<R> {
-    fn fill_buf<'a>(&'a mut self) -> io::IoResult<&'a [u8]> {
+    fn fill_buf<'a>(&'a mut self) -> old_io::IoResult<&'a [u8]> {
         let amt = try!(self.inner.fill_buf());
         let buf = &amt[..cmp::min(amt.len(), self.limit)];
         if buf.len() == 0 {
-            Err(io::standard_error(io::EndOfFile))
+            Err(old_io::standard_error(old_io::EndOfFile))
         } else {
             Ok(buf)
         }
@@ -83,7 +83,7 @@ pub struct NullWriter;
 
 impl Writer for NullWriter {
     #[inline]
-    fn write(&mut self, _buf: &[u8]) -> io::IoResult<()> { Ok(()) }
+    fn write(&mut self, _buf: &[u8]) -> old_io::IoResult<()> { Ok(()) }
 }
 
 /// A `Reader` which returns an infinite stream of 0 bytes, like /dev/zero.
@@ -92,14 +92,14 @@ pub struct ZeroReader;
 
 impl Reader for ZeroReader {
     #[inline]
-    fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
+    fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
         buf.set_memory(0);
         Ok(buf.len())
     }
 }
 
 impl Buffer for ZeroReader {
-    fn fill_buf<'a>(&'a mut self) -> io::IoResult<&'a [u8]> {
+    fn fill_buf<'a>(&'a mut self) -> old_io::IoResult<&'a [u8]> {
         static DATA: [u8; 64] = [0; 64];
         Ok(DATA.as_slice())
     }
@@ -113,14 +113,14 @@ pub struct NullReader;
 
 impl Reader for NullReader {
     #[inline]
-    fn read(&mut self, _buf: &mut [u8]) -> io::IoResult<uint> {
+    fn read(&mut self, _buf: &mut [u8]) -> old_io::IoResult<uint> {
-        Err(io::standard_error(io::EndOfFile))
+        Err(old_io::standard_error(old_io::EndOfFile))
     }
 }
 
 impl Buffer for NullReader {
-    fn fill_buf<'a>(&'a mut self) -> io::IoResult<&'a [u8]> {
+    fn fill_buf<'a>(&'a mut self) -> old_io::IoResult<&'a [u8]> {
-        Err(io::standard_error(io::EndOfFile))
+        Err(old_io::standard_error(old_io::EndOfFile))
     }
     fn consume(&mut self, _amt: uint) {}
 }
@@ -143,7 +143,7 @@ impl<W> MultiWriter<W> where W: Writer {
 
 impl<W> Writer for MultiWriter<W> where W: Writer {
     #[inline]
-    fn write(&mut self, buf: &[u8]) -> io::IoResult<()> {
+    fn write(&mut self, buf: &[u8]) -> old_io::IoResult<()> {
         for writer in self.writers.iter_mut() {
             try!(writer.write(buf));
         }
@@ -151,7 +151,7 @@ impl<W> Writer for MultiWriter<W> where W: Writer {
     }
 
     #[inline]
-    fn flush(&mut self) -> io::IoResult<()> {
+    fn flush(&mut self) -> old_io::IoResult<()> {
         for writer in self.writers.iter_mut() {
             try!(writer.flush());
         }
@@ -176,13 +176,13 @@ impl<R: Reader, I: Iterator<Item=R>> ChainedReader<I, R> {
 }
 
 impl<R: Reader, I: Iterator<Item=R>> Reader for ChainedReader<I, R> {
-    fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
+    fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
         loop {
             let err = match self.cur_reader {
                 Some(ref mut r) => {
                     match r.read(buf) {
                         Ok(len) => return Ok(len),
-                        Err(ref e) if e.kind == io::EndOfFile => None,
+                        Err(ref e) if e.kind == old_io::EndOfFile => None,
                         Err(e) => Some(e),
                     }
                 }
@@ -194,7 +194,7 @@ impl<R: Reader, I: Iterator<Item=R>> Reader for ChainedReader<I, R> {
                 None => {}
             }
         }
-        Err(io::standard_error(io::EndOfFile))
+        Err(old_io::standard_error(old_io::EndOfFile))
     }
 }
 
@@ -221,7 +221,7 @@ impl<R: Reader, W: Writer> TeeReader<R, W> {
 }
 
 impl<R: Reader, W: Writer> Reader for TeeReader<R, W> {
-    fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
+    fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
         self.reader.read(buf).and_then(|len| {
             self.writer.write(&mut buf[..len]).map(|()| len)
         })
@@ -229,12 +229,12 @@ impl<R: Reader, W: Writer> Reader for TeeReader<R, W> {
 }
 
 /// Copies all data from a `Reader` to a `Writer`.
-pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> io::IoResult<()> {
+pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> old_io::IoResult<()> {
     let mut buf = [0; super::DEFAULT_BUF_SIZE];
     loop {
         let len = match r.read(&mut buf) {
             Ok(len) => len,
-            Err(ref e) if e.kind == io::EndOfFile => return Ok(()),
+            Err(ref e) if e.kind == old_io::EndOfFile => return Ok(()),
             Err(e) => return Err(e),
         };
         try!(w.write(&buf[..len]));
@@ -257,14 +257,14 @@ impl<T: Iterator<Item=u8>> IterReader<T> {
 
 impl<T: Iterator<Item=u8>> Reader for IterReader<T> {
     #[inline]
-    fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
+    fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
         let mut len = 0;
         for (slot, elt) in buf.iter_mut().zip(self.iter.by_ref()) {
             *slot = elt;
             len += 1;
         }
         if len == 0 && buf.len() != 0 {
-            Err(io::standard_error(io::EndOfFile))
+            Err(old_io::standard_error(old_io::EndOfFile))
         } else {
             Ok(len)
         }
@@ -275,7 +275,7 @@ impl<T: Iterator<Item=u8>> Reader for IterReader<T> {
 mod test {
     use prelude::v1::*;
 
-    use io::{MemReader, ByRefReader};
+    use old_io::{MemReader, ByRefReader};
     use io;
     use super::*;
 
@@ -347,12 +347,12 @@ mod test {
 
         struct TestWriter;
         impl Writer for TestWriter {
-            fn write(&mut self, _buf: &[u8]) -> io::IoResult<()> {
+            fn write(&mut self, _buf: &[u8]) -> old_io::IoResult<()> {
                 unsafe { writes += 1 }
                 Ok(())
             }
 
-            fn flush(&mut self) -> io::IoResult<()> {
+            fn flush(&mut self) -> old_io::IoResult<()> {
                 unsafe { flushes += 1 }
                 Ok(())
             }
@@ -400,7 +400,7 @@ mod test {
             let mut r = LimitReader::new(r.by_ref(), 3);
             assert_eq!(r.read_line(), Ok("012".to_string()));
             assert_eq!(r.limit(), 0);
-            assert_eq!(r.read_line().err().unwrap().kind, io::EndOfFile);
+            assert_eq!(r.read_line().err().unwrap().kind, old_io::EndOfFile);
         }
         {
             let mut r = LimitReader::new(r.by_ref(), 9);
@@ -432,7 +432,7 @@ mod test {
         assert_eq!(len, 2);
         assert!(buf == [6, 7, 5]);
 
-        assert_eq!(r.read(&mut buf).unwrap_err().kind, io::EndOfFile);
+        assert_eq!(r.read(&mut buf).unwrap_err().kind, old_io::EndOfFile);
     }
 
     #[test]