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]

Author: alexcrichton

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/io/buffered.rs renamed to 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> {
-            Err(io::standard_error(io::EndOfFile))
+        fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
+            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 {
-            fn write(&mut self, _: &[u8]) -> io::IoResult<()> { Ok(()) }
+        impl old_io::Writer for S {
+            fn write(&mut self, _: &[u8]) -> old_io::IoResult<()> { Ok(()) }
         }
 
-        impl io::Reader for S {
-            fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
-                Err(io::standard_error(io::EndOfFile))
+        impl old_io::Reader for S {
+            fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
+                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/io/comm_adapters.rs renamed to 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 {
-                kind: io::BrokenPipe,
+            old_io::IoError {
+                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/io/extensions.rs renamed to 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 io;
+use old_io::{IoError, IoResult, Reader};
+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> {
-            Err(io::standard_error(io::EndOfFile))
+        fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
+            Err(old_io::standard_error(old_io::EndOfFile))
         }
     }
 
     struct ErroringReader;
 
     impl Reader for ErroringReader {
-        fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
-            Err(io::standard_error(io::InvalidInput))
+        fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
+            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))
             }
         }
     }