Merge remote-tracking branch 'rust-lang/master'

Conflicts:
	src/libcore/cell.rs
	src/librustc_driver/test.rs
	src/libstd/old_io/net/tcp.rs
	src/libstd/old_io/process.rs

src/compiletest/compiletest.rs

@@ -32,8 +32,8 @@ extern crate getopts;
 extern crate log;
 
 use std::os;
-use std::io;
+use std::old_io;
-use std::io::fs;
+use std::old_io::fs;
 use std::str::FromStr;
 use std::thunk::Thunk;
 use getopts::{optopt, optflag, reqopt};
@@ -245,7 +245,7 @@ pub fn run_tests(config: &Config) {
     // sadly osx needs some file descriptor limits raised for running tests in
     // parallel (especially when we have lots and lots of child processes).
     // For context, see #8904
-    io::test::raise_fd_limit();
+    old_io::test::raise_fd_limit();
     // Prevent issue #21352 UAC blocking .exe containing 'patch' etc. on Windows
     // If #11207 is resolved (adding manifest to .exe) this becomes unnecessary
     os::setenv("__COMPAT_LAYER", "RunAsInvoker");

src/compiletest/errors.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 use self::WhichLine::*;
 
-use std::io::{BufferedReader, File};
+use std::old_io::{BufferedReader, File};
 
 pub struct ExpectedError {
     pub line: uint,

src/compiletest/header.rs

@@ -223,7 +223,7 @@ pub fn is_test_ignored(config: &Config, testfile: &Path) -> bool {
 fn iter_header<F>(testfile: &Path, mut it: F) -> bool where
     F: FnMut(&str) -> bool,
 {
-    use std::io::{BufferedReader, File};
+    use std::old_io::{BufferedReader, File};
 
     let mut rdr = BufferedReader::new(File::open(testfile).unwrap());
     for ln in rdr.lines() {

src/compiletest/procsrv.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::io::process::{ProcessExit, Command, Process, ProcessOutput};
+use std::old_io::process::{ProcessExit, Command, Process, ProcessOutput};
 use std::dynamic_lib::DynamicLibrary;
 
 fn add_target_env(cmd: &mut Command, lib_path: &str, aux_path: Option<&str>) {
@@ -47,7 +47,7 @@ pub fn run(lib_path: &str,
     match cmd.spawn() {
         Ok(mut process) => {
             for input in input.iter() {
-                process.stdin.as_mut().unwrap().write(input.as_bytes()).unwrap();
+                process.stdin.as_mut().unwrap().write_all(input.as_bytes()).unwrap();
             }
             let ProcessOutput { status, output, error } =
                 process.wait_with_output().unwrap();
@@ -79,7 +79,7 @@ pub fn run_background(lib_path: &str,
     match cmd.spawn() {
         Ok(mut process) => {
             for input in input.iter() {
-                process.stdin.as_mut().unwrap().write(input.as_bytes()).unwrap();
+                process.stdin.as_mut().unwrap().write_all(input.as_bytes()).unwrap();
             }
 
             Some(process)

src/compiletest/runtest.rs

@@ -23,14 +23,14 @@ use util;
 
 #[cfg(target_os = "windows")]
 use std::ascii::AsciiExt;
-use std::io::File;
+use std::old_io::File;
-use std::io::fs::PathExtensions;
+use std::old_io::fs::PathExtensions;
-use std::io::fs;
+use std::old_io::fs;
-use std::io::net::tcp;
+use std::old_io::net::tcp;
-use std::io::process::ProcessExit;
+use std::old_io::process::ProcessExit;
-use std::io::process;
+use std::old_io::process;
-use std::io::timer;
+use std::old_io::timer;
-use std::io;
+use std::old_io;
 use std::os;
 use std::iter::repeat;
 use std::str;
@@ -619,7 +619,7 @@ fn find_rust_src_root(config: &Config) -> Option<Path> {
 }
 
 fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path) {
-    use std::io::process::{Command, ProcessOutput};
+    use std::old_io::process::{Command, ProcessOutput};
 
     if config.lldb_python_dir.is_none() {
         fatal("Can't run LLDB test because LLDB's python path is not set.");
@@ -764,7 +764,7 @@ struct DebuggerCommands {
 
 fn parse_debugger_commands(file_path: &Path, debugger_prefix: &str)
                            -> DebuggerCommands {
-    use std::io::{BufferedReader, File};
+    use std::old_io::{BufferedReader, File};
 
     let command_directive = format!("{}-command", debugger_prefix);
     let check_directive = format!("{}-check", debugger_prefix);
@@ -1224,7 +1224,7 @@ fn compose_and_run_compiler(
 
 fn ensure_dir(path: &Path) {
     if path.is_dir() { return; }
-    fs::mkdir(path, io::USER_RWX).unwrap();
+    fs::mkdir(path, old_io::USER_RWX).unwrap();
 }
 
 fn compose_and_run(config: &Config, testfile: &Path,
@@ -1401,7 +1401,7 @@ fn dump_output(config: &Config, testfile: &Path, out: &str, err: &str) {
 fn dump_output_file(config: &Config, testfile: &Path,
                     out: &str, extension: &str) {
     let outfile = make_out_name(config, testfile, extension);
-    File::create(&outfile).write(out.as_bytes()).unwrap();
+    File::create(&outfile).write_all(out.as_bytes()).unwrap();
 }
 
 fn make_out_name(config: &Config, testfile: &Path, extension: &str) -> Path {

src/doc/trpl/guessing-game.md

@@ -75,14 +75,14 @@ Let's get to it! The first thing we need to do for our guessing game is
 allow our player to input a guess. Put this in your `src/main.rs`:
 
 ```{rust,no_run}
-use std::io;
+use std::old_io;
 
 fn main() {
     println!("Guess the number!");
 
     println!("Please input your guess.");
 
-    let input = io::stdin().read_line()
+    let input = old_io::stdin().read_line()
                            .ok()
                            .expect("Failed to read line");
 
@@ -121,7 +121,7 @@ explanatory text, and then an example. Let's try to modify our code to add in th
 `random` function and see what happens:
 
 ```{rust,ignore}
-use std::io;
+use std::old_io;
 use std::rand;
 
 fn main() {
@@ -133,7 +133,7 @@ fn main() {
 
     println!("Please input your guess.");
 
-    let input = io::stdin().read_line()
+    let input = old_io::stdin().read_line()
                            .ok()
                            .expect("Failed to read line");
 
@@ -180,7 +180,7 @@ This says "please give me a random `i32` value." We can change our code to use
 this hint:
 
 ```{rust,no_run}
-use std::io;
+use std::old_io;
 use std::rand;
 
 fn main() {
@@ -192,7 +192,7 @@ fn main() {
 
     println!("Please input your guess.");
 
-    let input = io::stdin().read_line()
+    let input = old_io::stdin().read_line()
                            .ok()
                            .expect("Failed to read line");
 
@@ -233,7 +233,7 @@ unsigned integer approach. If we want a random positive number, we should ask fo
 a random positive number. Our code looks like this now:
 
 ```{rust,no_run}
-use std::io;
+use std::old_io;
 use std::rand;
 
 fn main() {
@@ -245,7 +245,7 @@ fn main() {
 
     println!("Please input your guess.");
 
-    let input = io::stdin().read_line()
+    let input = old_io::stdin().read_line()
                            .ok()
                            .expect("Failed to read line");
 
@@ -276,7 +276,7 @@ two numbers. Let's add that in, along with a `match` statement to compare our
 guess to the secret number:
 
 ```{rust,ignore}
-use std::io;
+use std::old_io;
 use std::rand;
 use std::cmp::Ordering;
 
@@ -289,7 +289,7 @@ fn main() {
 
     println!("Please input your guess.");
 
-    let input = io::stdin().read_line()
+    let input = old_io::stdin().read_line()
                            .ok()
                            .expect("Failed to read line");
 
@@ -331,7 +331,7 @@ but we've given it unsigned integers. In this case, the fix is easy, because
 we wrote the `cmp` function! Let's change it to take `u32`s:
 
 ```{rust,ignore}
-use std::io;
+use std::old_io;
 use std::rand;
 use std::cmp::Ordering;
 
@@ -344,7 +344,7 @@ fn main() {
 
     println!("Please input your guess.");
 
-    let input = io::stdin().read_line()
+    let input = old_io::stdin().read_line()
                            .ok()
                            .expect("Failed to read line");
 
@@ -397,7 +397,7 @@ Anyway, we have a `String`, but we need a `u32`. What to do? Well, there's
 a function for that:
 
 ```{rust,ignore}
-let input = io::stdin().read_line()
+let input = old_io::stdin().read_line()
                        .ok()
                        .expect("Failed to read line");
 let input_num: Option<u32> = input.parse();
@@ -429,7 +429,7 @@ let input_num: Option<u32> = "5".parse(); // input_num: Option<u32>
 Anyway, with us now converting our input to a number, our code looks like this:
 
 ```{rust,ignore}
-use std::io;
+use std::old_io;
 use std::rand;
 use std::cmp::Ordering;
 
@@ -442,7 +442,7 @@ fn main() {
 
     println!("Please input your guess.");
 
-    let input = io::stdin().read_line()
+    let input = old_io::stdin().read_line()
                            .ok()
                            .expect("Failed to read line");
     let input_num: Option<u32> = input.parse();
@@ -479,7 +479,7 @@ need to unwrap the Option. If you remember from before, `match` is a great way
 to do that. Try this code:
 
 ```{rust,no_run}
-use std::io;
+use std::old_io;
 use std::rand;
 use std::cmp::Ordering;
 
@@ -492,7 +492,7 @@ fn main() {
 
     println!("Please input your guess.");
 
-    let input = io::stdin().read_line()
+    let input = old_io::stdin().read_line()
                            .ok()
                            .expect("Failed to read line");
     let input_num: Option<u32> = input.parse();
@@ -546,7 +546,7 @@ method we can use defined on them: `trim()`. One small modification, and our
 code looks like this:
 
 ```{rust,no_run}
-use std::io;
+use std::old_io;
 use std::rand;
 use std::cmp::Ordering;
 
@@ -559,7 +559,7 @@ fn main() {
 
     println!("Please input your guess.");
 
-    let input = io::stdin().read_line()
+    let input = old_io::stdin().read_line()
                            .ok()
                            .expect("Failed to read line");
     let input_num: Option<u32> = input.trim().parse();
@@ -620,7 +620,7 @@ As we already discussed, the `loop` keyword gives us an infinite loop.
 Let's add that in:
 
 ```{rust,no_run}
-use std::io;
+use std::old_io;
 use std::rand;
 use std::cmp::Ordering;
 
@@ -635,7 +635,7 @@ fn main() {
 
         println!("Please input your guess.");
 
-        let input = io::stdin().read_line()
+        let input = old_io::stdin().read_line()
                                .ok()
                                .expect("Failed to read line");
         let input_num: Option<u32> = input.trim().parse();
@@ -696,7 +696,7 @@ Ha! `quit` actually quits. As does any other non-number input. Well, this is
 suboptimal to say the least. First, let's actually quit when you win the game:
 
 ```{rust,no_run}
-use std::io;
+use std::old_io;
 use std::rand;
 use std::cmp::Ordering;
 
@@ -711,7 +711,7 @@ fn main() {
 
         println!("Please input your guess.");
 
-        let input = io::stdin().read_line()
+        let input = old_io::stdin().read_line()
                                .ok()
                                .expect("Failed to read line");
         let input_num: Option<u32> = input.trim().parse();
@@ -752,7 +752,7 @@ we don't want to quit, we just want to ignore it. Change that `return` to
 
 
 ```{rust,no_run}
-use std::io;
+use std::old_io;
 use std::rand;
 use std::cmp::Ordering;
 
@@ -767,7 +767,7 @@ fn main() {
 
         println!("Please input your guess.");
 
-        let input = io::stdin().read_line()
+        let input = old_io::stdin().read_line()
                                .ok()
                                .expect("Failed to read line");
         let input_num: Option<u32> = input.trim().parse();
@@ -831,7 +831,7 @@ think of what it is? That's right, we don't want to print out the secret number.
 It was good for testing, but it kind of ruins the game. Here's our final source:
 
 ```{rust,no_run}
-use std::io;
+use std::old_io;
 use std::rand;
 use std::cmp::Ordering;
 
@@ -844,7 +844,7 @@ fn main() {
 
         println!("Please input your guess.");
 
-        let input = io::stdin().read_line()
+        let input = old_io::stdin().read_line()
                                .ok()
                                .expect("Failed to read line");
         let input_num: Option<u32> = input.trim().parse();

src/doc/trpl/standard-input.md

@@ -8,7 +8,7 @@ and then prints it back out:
 fn main() {
     println!("Type something!");
 
-    let input = std::io::stdin().read_line().ok().expect("Failed to read line");
+    let input = std::old_io::stdin().read_line().ok().expect("Failed to read line");
 
     println!("{}", input);
 }
@@ -17,7 +17,7 @@ fn main() {
 Let's go over these chunks, one by one:
 
 ```{rust,ignore}
-std::io::stdin();
+std::old_io::stdin();
 ```
 
 This calls a function, `stdin()`, that lives inside the `std::io` module. As
@@ -28,7 +28,7 @@ Since writing the fully qualified name all the time is annoying, we can use
 the `use` statement to import it in:
 
 ```{rust}
-use std::io::stdin;
+use std::old_io::stdin;
 
 stdin();
 ```
@@ -37,20 +37,20 @@ However, it's considered better practice to not import individual functions, but
 to import the module, and only use one level of qualification:
 
 ```{rust}
-use std::io;
+use std::old_io;
 
-io::stdin();
+old_io::stdin();
 ```
 
 Let's update our example to use this style:
 
 ```{rust,ignore}
-use std::io;
+use std::old_io;
 
 fn main() {
     println!("Type something!");
 
-    let input = io::stdin().read_line().ok().expect("Failed to read line");
+    let input = old_io::stdin().read_line().ok().expect("Failed to read line");
 
     println!("{}", input);
 }
@@ -121,12 +121,12 @@ For now, this gives you enough of a basic understanding to work with.
 Back to the code we were working on! Here's a refresher:
 
 ```{rust,ignore}
-use std::io;
+use std::old_io;
 
 fn main() {
     println!("Type something!");
 
-    let input = io::stdin().read_line().ok().expect("Failed to read line");
+    let input = old_io::stdin().read_line().ok().expect("Failed to read line");
 
     println!("{}", input);
 }
@@ -136,14 +136,14 @@ With long lines like this, Rust gives you some flexibility with the whitespace.
 We _could_ write the example like this:
 
 ```{rust,ignore}
-use std::io;
+use std::old_io;
 
 fn main() {
     println!("Type something!");
 
     // here, we'll show the types at each step
 
-    let input = io::stdin() // std::io::stdio::StdinReader
+    let input = old_io::stdin() // std::old_io::stdio::StdinReader
                   .read_line() // IoResult<String>
                   .ok() // Option<String>
                   .expect("Failed to read line"); // String

src/libcore/cell.rs

@@ -10,39 +10,30 @@
 
 //! Shareable mutable containers.
 //!
-//! Values of the `Cell` and `RefCell` types may be mutated through
+//! Values of the `Cell<T>` and `RefCell<T>` types may be mutated through shared references (i.e.
-//! shared references (i.e. the common `&T` type), whereas most Rust
+//! the common `&T` type), whereas most Rust types can only be mutated through unique (`&mut T`)
-//! types can only be mutated through unique (`&mut T`) references. We
+//! references. We say that `Cell<T>` and `RefCell<T>` provide 'interior mutability', in contrast
-//! say that `Cell` and `RefCell` provide *interior mutability*, in
+//! with typical Rust types that exhibit 'inherited mutability'.
-//! contrast with typical Rust types that exhibit *inherited
-//! mutability*.
 //!
-//! Cell types come in two flavors: `Cell` and `RefCell`. `Cell`
+//! Cell types come in two flavors: `Cell<T>` and `RefCell<T>`. `Cell<T>` provides `get` and `set`
-//! provides `get` and `set` methods that change the
+//! methods that change the interior value with a single method call. `Cell<T>` though is only
-//! interior value with a single method call. `Cell` though is only
+//! compatible with types that implement `Copy`. For other types, one must use the `RefCell<T>`
-//! compatible with types that implement `Copy`. For other types,
+//! type, acquiring a write lock before mutating.
-//! one must use the `RefCell` type, acquiring a write lock before
-//! mutating.
 //!
-//! `RefCell` uses Rust's lifetimes to implement *dynamic borrowing*,
+//! `RefCell<T>` uses Rust's lifetimes to implement 'dynamic borrowing', a process whereby one can
-//! a process whereby one can claim temporary, exclusive, mutable
+//! claim temporary, exclusive, mutable access to the inner value. Borrows for `RefCell<T>`s are
-//! access to the inner value. Borrows for `RefCell`s are tracked *at
+//! tracked 'at runtime', unlike Rust's native reference types which are entirely tracked
-//! runtime*, unlike Rust's native reference types which are entirely
+//! statically, at compile time. Because `RefCell<T>` borrows are dynamic it is possible to attempt
-//! tracked statically, at compile time. Because `RefCell` borrows are
+//! to borrow a value that is already mutably borrowed; when this happens it results in task panic.
-//! dynamic it is possible to attempt to borrow a value that is
-//! already mutably borrowed; when this happens it results in task
-//! panic.
 //!
 //! # When to choose interior mutability
 //!
-//! The more common inherited mutability, where one must have unique
+//! The more common inherited mutability, where one must have unique access to mutate a value, is
-//! access to mutate a value, is one of the key language elements that
+//! one of the key language elements that enables Rust to reason strongly about pointer aliasing,
-//! enables Rust to reason strongly about pointer aliasing, statically
+//! statically preventing crash bugs. Because of that, inherited mutability is preferred, and
-//! preventing crash bugs. Because of that, inherited mutability is
+//! interior mutability is something of a last resort. Since cell types enable mutation where it
-//! preferred, and interior mutability is something of a last
+//! would otherwise be disallowed though, there are occasions when interior mutability might be
-//! resort. Since cell types enable mutation where it would otherwise
+//! appropriate, or even *must* be used, e.g.
-//! be disallowed though, there are occasions when interior
-//! mutability might be appropriate, or even *must* be used, e.g.
 //!
 //! * Introducing inherited mutability roots to shared types.
 //! * Implementation details of logically-immutable methods.
@@ -50,15 +41,13 @@
 //!
 //! ## Introducing inherited mutability roots to shared types
 //!
-//! Shared smart pointer types, including `Rc` and `Arc`, provide
+//! Shared smart pointer types, including `Rc<T>` and `Arc<T>`, provide containers that can be
-//! containers that can be cloned and shared between multiple parties.
+//! cloned and shared between multiple parties. Because the contained values may be
-//! Because the contained values may be multiply-aliased, they can
+//! multiply-aliased, they can only be borrowed as shared references, not mutable references.
-//! only be borrowed as shared references, not mutable references.
+//! Without cells it would be impossible to mutate data inside of shared boxes at all!
-//! Without cells it would be impossible to mutate data inside of
-//! shared boxes at all!
 //!
-//! It's very common then to put a `RefCell` inside shared pointer
+//! It's very common then to put a `RefCell<T>` inside shared pointer types to reintroduce
-//! types to reintroduce mutability:
+//! mutability:
 //!
 //! ```
 //! use std::collections::HashMap;
@@ -80,12 +69,10 @@
 //!
 //! ## Implementation details of logically-immutable methods
 //!
-//! Occasionally it may be desirable not to expose in an API that
+//! Occasionally it may be desirable not to expose in an API that there is mutation happening
-//! there is mutation happening "under the hood". This may be because
+//! "under the hood". This may be because logically the operation is immutable, but e.g. caching
-//! logically the operation is immutable, but e.g. caching forces the
+//! forces the implementation to perform mutation; or because you must employ mutation to implement
-//! implementation to perform mutation; or because you must employ
+//! a trait method that was originally defined to take `&self`.
-//! mutation to implement a trait method that was originally defined
-//! to take `&self`.
 //!
 //! ```
 //! use std::cell::RefCell;
@@ -123,13 +110,11 @@
 //!
 //! ## Mutating implementations of `clone`
 //!
-//! This is simply a special - but common - case of the previous:
+//! This is simply a special - but common - case of the previous: hiding mutability for operations
-//! hiding mutability for operations that appear to be immutable.
+//! that appear to be immutable. The `clone` method is expected to not change the source value, and
-//! The `clone` method is expected to not change the source value, and
+//! is declared to take `&self`, not `&mut self`. Therefore any mutation that happens in the
-//! is declared to take `&self`, not `&mut self`. Therefore any
+//! `clone` method must use cell types. For example, `Rc<T>` maintains its reference counts within a
-//! mutation that happens in the `clone` method must use cell
+//! `Cell<T>`.
-//! types. For example, `Rc` maintains its reference counts within a
-//! `Cell`.
 //!
 //! ```
 //! use std::cell::Cell;
@@ -153,10 +138,6 @@
 //! }
 //! ```
 //!
-// FIXME: Explain difference between Cell and RefCell
-// FIXME: Downsides to interior mutability
-// FIXME: Can't be shared between threads. Dynamic borrows
-// FIXME: Relationship to Atomic types and RWLock
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
@@ -169,6 +150,8 @@ use option::Option;
 use option::Option::{None, Some};
 
 /// A mutable memory location that admits only `Copy` data.
+///
+/// See the [module-level documentation](../index.html) for more.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Cell<T> {
     value: UnsafeCell<T>,
@@ -176,6 +159,14 @@ pub struct Cell<T> {
 
 impl<T:Copy> Cell<T> {
     /// Creates a new `Cell` containing the given value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::cell::Cell;
+    ///
+    /// let c = Cell::new(5);
+    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn new(value: T) -> Cell<T> {
         Cell {
@@ -184,6 +175,16 @@ impl<T:Copy> Cell<T> {
     }
 
     /// Returns a copy of the contained value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::cell::Cell;
+    ///
+    /// let c = Cell::new(5);
+    ///
+    /// let five = c.get();
+    /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn get(&self) -> T {
@@ -191,6 +192,16 @@ impl<T:Copy> Cell<T> {
     }
 
     /// Sets the contained value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::cell::Cell;
+    ///
+    /// let c = Cell::new(5);
+    ///
+    /// c.set(10);
+    /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn set(&self, value: T) {
@@ -201,9 +212,19 @@ impl<T:Copy> Cell<T> {
 
     /// Get a reference to the underlying `UnsafeCell`.
     ///
-    /// This can be used to circumvent `Cell`'s safety checks.
+    /// # Unsafety
     ///
     /// This function is `unsafe` because `UnsafeCell`'s field is public.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::cell::Cell;
+    ///
+    /// let c = Cell::new(5);
+    ///
+    /// let uc = unsafe { c.as_unsafe_cell() };
+    /// ```
     #[inline]
     #[unstable(feature = "core")]
     pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> {
@@ -237,6 +258,8 @@ impl<T:PartialEq + Copy> PartialEq for Cell<T> {
 }
 
 /// A mutable memory location with dynamically checked borrow rules
+///
+/// See the [module-level documentation](../index.html) for more.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct RefCell<T> {
     value: UnsafeCell<T>,
@@ -250,7 +273,15 @@ const UNUSED: BorrowFlag = 0;
 const WRITING: BorrowFlag = -1;
 
 impl<T> RefCell<T> {
-    /// Create a new `RefCell` containing `value`
+    /// Creates a new `RefCell` containing `value`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::cell::RefCell;
+    ///
+    /// let c = RefCell::new(5);
+    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn new(value: T) -> RefCell<T> {
         RefCell {
@@ -260,6 +291,16 @@ impl<T> RefCell<T> {
     }
 
     /// Consumes the `RefCell`, returning the wrapped value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::cell::RefCell;
+    ///
+    /// let c = RefCell::new(5);
+    ///
+    /// let five = c.into_inner();
+    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn into_inner(self) -> T {
         // Since this function takes `self` (the `RefCell`) by value, the
@@ -285,12 +326,39 @@ impl<T> RefCell<T> {
 
     /// Immutably borrows the wrapped value.
     ///
-    /// The borrow lasts until the returned `Ref` exits scope. Multiple
+    /// The borrow lasts until the returned `Ref` exits scope. Multiple immutable borrows can be
-    /// immutable borrows can be taken out at the same time.
+    /// taken out at the same time.
     ///
     /// # Panics
     ///
     /// Panics if the value is currently mutably borrowed.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::cell::RefCell;
+    ///
+    /// let c = RefCell::new(5);
+    ///
+    /// let borrowed_five = c.borrow();
+    /// let borrowed_five2 = c.borrow();
+    /// ```
+    ///
+    /// An example of panic:
+    ///
+    /// ```
+    /// use std::cell::RefCell;
+    /// use std::thread::Thread;
+    ///
+    /// let result = Thread::scoped(move || {
+    ///    let c = RefCell::new(5);
+    ///    let m = c.borrow_mut();
+    ///
+    ///    let b = c.borrow(); // this causes a panic
+    /// }).join();
+    ///
+    /// assert!(result.is_err());
+    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn borrow<'a>(&'a self) -> Ref<'a, T> {
         match self.try_borrow() {
@@ -315,12 +383,38 @@ impl<T> RefCell<T> {
 
     /// Mutably borrows the wrapped value.
     ///
-    /// The borrow lasts until the returned `RefMut` exits scope. The value
+    /// The borrow lasts until the returned `RefMut` exits scope. The value cannot be borrowed
-    /// cannot be borrowed while this borrow is active.
+    /// while this borrow is active.
     ///
     /// # Panics
     ///
     /// Panics if the value is currently borrowed.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::cell::RefCell;
+    ///
+    /// let c = RefCell::new(5);
+    ///
+    /// let borrowed_five = c.borrow_mut();
+    /// ```
+    ///
+    /// An example of panic:
+    ///
+    /// ```
+    /// use std::cell::RefCell;
+    /// use std::thread::Thread;
+    ///
+    /// let result = Thread::scoped(move || {
+    ///    let c = RefCell::new(5);
+    ///    let m = c.borrow_mut();
+    ///
+    ///    let b = c.borrow_mut(); // this causes a panic
+    /// }).join();
+    ///
+    /// assert!(result.is_err());
+    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn borrow_mut<'a>(&'a self) -> RefMut<'a, T> {
         match self.try_borrow_mut() {
@@ -403,6 +497,9 @@ impl<'b> Clone for BorrowRef<'b> {
 }
 
 /// Wraps a borrowed reference to a value in a `RefCell` box.
+/// A wrapper type for an immutably borrowed value from a `RefCell<T>`.
+///
+/// See the [module-level documentation](../index.html) for more.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Ref<'b, T:'b> {
     // FIXME #12808: strange name to try to avoid interfering with
@@ -461,7 +558,9 @@ impl<'b> BorrowRefMut<'b> {
     }
 }
 
-/// Wraps a mutable borrowed reference to a value in a `RefCell` box.
+/// A wrapper type for a mutably borrowed value from a `RefCell<T>`.
+///
+/// See the [module-level documentation](../index.html) for more.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct RefMut<'b, T:'b> {
     // FIXME #12808: strange name to try to avoid interfering with
@@ -490,28 +589,25 @@ impl<'b, T> DerefMut for RefMut<'b, T> {
 
 /// The core primitive for interior mutability in Rust.
 ///
-/// `UnsafeCell` type that wraps a type T and indicates unsafe interior
+/// `UnsafeCell<T>` is a type that wraps some `T` and indicates unsafe interior operations on the
-/// operations on the wrapped type. Types with an `UnsafeCell<T>` field are
+/// wrapped type. Types with an `UnsafeCell<T>` field are considered to have an 'unsafe interior'.
-/// considered to have an *unsafe interior*. The `UnsafeCell` type is the only
+/// The `UnsafeCell<T>` type is the only legal way to obtain aliasable data that is considered
-/// legal way to obtain aliasable data that is considered mutable. In general,
+/// mutable. In general, transmuting an `&T` type into an `&mut T` is considered undefined behavior.
-/// transmuting an &T type into an &mut T is considered undefined behavior.
 ///
-/// Although it is possible to put an `UnsafeCell<T>` into static item, it is
+/// Although it is possible to put an `UnsafeCell<T>` into static item, it is not permitted to take
-/// not permitted to take the address of the static item if the item is not
+/// the address of the static item if the item is not declared as mutable. This rule exists because
-/// declared as mutable. This rule exists because immutable static items are
+/// immutable static items are stored in read-only memory, and thus any attempt to mutate their
-/// stored in read-only memory, and thus any attempt to mutate their interior
+/// interior can cause segfaults. Immutable static items containing `UnsafeCell<T>` instances are
-/// can cause segfaults. Immutable static items containing `UnsafeCell<T>`
+/// still useful as read-only initializers, however, so we do not forbid them altogether.
-/// instances are still useful as read-only initializers, however, so we do not
-/// forbid them altogether.
 ///
-/// Types like `Cell` and `RefCell` use this type to wrap their internal data.
+/// Types like `Cell<T>` and `RefCell<T>` use this type to wrap their internal data.
 ///
-/// `UnsafeCell` doesn't opt-out from any kind, instead, types with an
+/// `UnsafeCell<T>` doesn't opt-out from any marker traits, instead, types with an `UnsafeCell<T>`
-/// `UnsafeCell` interior are expected to opt-out from kinds themselves.
+/// interior are expected to opt-out from those traits themselves.
 ///
-/// # Example:
+/// # Examples
 ///
-/// ```rust
+/// ```
 /// use std::cell::UnsafeCell;
 /// use std::marker::Sync;
 ///
@@ -522,9 +618,8 @@ impl<'b, T> DerefMut for RefMut<'b, T> {
 /// unsafe impl<T> Sync for NotThreadSafe<T> {}
 /// ```
 ///
-/// **NOTE:** `UnsafeCell<T>` fields are public to allow static initializers. It
+/// **NOTE:** `UnsafeCell<T>`'s fields are public to allow static initializers. It is not
-/// is not recommended to access its fields directly, `get` should be used
+/// recommended to access its fields directly, `get` should be used instead.
-/// instead.
 #[lang="unsafe"]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct UnsafeCell<T> {
@@ -540,22 +635,52 @@ impl<T> UnsafeCell<T> {
     /// Construct a new instance of `UnsafeCell` which will wrap the specified
     /// value.
     ///
-    /// All access to the inner value through methods is `unsafe`, and it is
+    /// All access to the inner value through methods is `unsafe`, and it is highly discouraged to
-    /// highly discouraged to access the fields directly.
+    /// access the fields directly.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::cell::UnsafeCell;
+    ///
+    /// let uc = UnsafeCell::new(5);
+    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn new(value: T) -> UnsafeCell<T> {
         UnsafeCell { value: value }
     }
 
     /// Gets a mutable pointer to the wrapped value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::cell::UnsafeCell;
+    ///
+    /// let uc = UnsafeCell::new(5);
+    ///
+    /// let five = uc.get();
+    /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn get(&self) -> *mut T { &self.value as *const T as *mut T }
 
     /// Unwraps the value
     ///
-    /// This function is unsafe because there is no guarantee that this or other
+    /// # Unsafety
-    /// tasks are currently inspecting the inner value.
+    ///
+    /// This function is unsafe because there is no guarantee that this or other threads are
+    /// currently inspecting the inner value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::cell::UnsafeCell;
+    ///
+    /// let uc = UnsafeCell::new(5);
+    ///
+    /// let five = unsafe { uc.into_inner() };
+    /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub unsafe fn into_inner(self) -> T { self.value }

src/libcore/error.rs

@@ -49,7 +49,7 @@
 //!
 //! ```
 //! use std::error::FromError;
-//! use std::io::{File, IoError};
+//! use std::old_io::{File, IoError};
 //! use std::os::{MemoryMap, MapError};
 //! use std::path::Path;
 //!

src/libcore/fmt/mod.rs

@@ -238,7 +238,7 @@ impl<'a> Display for Arguments<'a> {
     }
 }
 
-/// Format trait for the `:?` format. Useful for debugging, most all types
+/// Format trait for the `:?` format. Useful for debugging, all types
 /// should implement this.
 #[unstable(feature = "core",
            reason = "I/O and core have yet to be reconciled")]
@@ -249,7 +249,7 @@ pub trait Show {
     fn fmt(&self, &mut Formatter) -> Result;
 }
 
-/// Format trait for the `:?` format. Useful for debugging, most all types
+/// Format trait for the `:?` format. Useful for debugging, all types
 /// should implement this.
 #[unstable(feature = "core",
            reason = "I/O and core have yet to be reconciled")]

src/libcore/result.rs

@@ -95,7 +95,7 @@
 //! by the [`Writer`](../io/trait.Writer.html) trait:
 //!
 //! ```
-//! use std::io::IoError;
+//! use std::old_io::IoError;
 //!
 //! trait Writer {
 //!     fn write_line(&mut self, s: &str) -> Result<(), IoError>;
@@ -110,7 +110,7 @@
 //! something like this:
 //!
 //! ```{.ignore}
-//! use std::io::{File, Open, Write};
+//! use std::old_io::{File, Open, Write};
 //!
 //! let mut file = File::open_mode(&Path::new("valuable_data.txt"), Open, Write);
 //! // If `write_line` errors, then we'll never know, because the return
@@ -128,7 +128,7 @@
 //! a marginally useful message indicating why:
 //!
 //! ```{.no_run}
-//! use std::io::{File, Open, Write};
+//! use std::old_io::{File, Open, Write};
 //!
 //! let mut file = File::open_mode(&Path::new("valuable_data.txt"), Open, Write);
 //! file.write_line("important message").ok().expect("failed to write message");
@@ -138,7 +138,7 @@
 //! You might also simply assert success:
 //!
 //! ```{.no_run}
-//! # use std::io::{File, Open, Write};
+//! # use std::old_io::{File, Open, Write};
 //!
 //! # let mut file = File::open_mode(&Path::new("valuable_data.txt"), Open, Write);
 //! assert!(file.write_line("important message").is_ok());
@@ -148,7 +148,7 @@
 //! Or propagate the error up the call stack with `try!`:
 //!
 //! ```
-//! # use std::io::{File, Open, Write, IoError};
+//! # use std::old_io::{File, Open, Write, IoError};
 //! fn write_message() -> Result<(), IoError> {
 //!     let mut file = File::open_mode(&Path::new("valuable_data.txt"), Open, Write);
 //!     try!(file.write_line("important message"));
@@ -167,7 +167,7 @@
 //! It replaces this:
 //!
 //! ```
-//! use std::io::{File, Open, Write, IoError};
+//! use std::old_io::{File, Open, Write, IoError};
 //!
 //! struct Info {
 //!     name: String,
@@ -191,7 +191,7 @@
 //! With this:
 //!
 //! ```
-//! use std::io::{File, Open, Write, IoError};
+//! use std::old_io::{File, Open, Write, IoError};
 //!
 //! struct Info {
 //!     name: String,
@@ -445,7 +445,7 @@ impl<T, E> Result<T, E> {
     /// ignoring I/O and parse errors:
     ///
     /// ```
-    /// use std::io::IoResult;
+    /// use std::old_io::IoResult;
     ///
     /// let mut buffer = &mut b"1\n2\n3\n4\n";
     ///

src/libcoretest/fmt/num.rs

@@ -170,7 +170,7 @@ mod u32 {
     use test::Bencher;
     use core::fmt::radix;
     use std::rand::{weak_rng, Rng};
-    use std::io::util::NullWriter;
+    use std::old_io::util::NullWriter;
 
     #[bench]
     fn format_bin(b: &mut Bencher) {
@@ -213,7 +213,7 @@ mod i32 {
     use test::Bencher;
     use core::fmt::radix;
     use std::rand::{weak_rng, Rng};
-    use std::io::util::NullWriter;
+    use std::old_io::util::NullWriter;
 
     #[bench]
     fn format_bin(b: &mut Bencher) {

src/libgraphviz/lib.rs

@@ -96,7 +96,7 @@
 //! ```no_run
 //! # pub fn render_to<W:Writer>(output: &mut W) { unimplemented!() }
 //! pub fn main() {
-//!     use std::io::File;
+//!     use std::old_io::File;
 //!     let mut f = File::create(&Path::new("example1.dot"));
 //!     render_to(&mut f)
 //! }
@@ -188,7 +188,7 @@
 //! ```no_run
 //! # pub fn render_to<W:Writer>(output: &mut W) { unimplemented!() }
 //! pub fn main() {
-//!     use std::io::File;
+//!     use std::old_io::File;
 //!     let mut f = File::create(&Path::new("example2.dot"));
 //!     render_to(&mut f)
 //! }
@@ -252,7 +252,7 @@
 //! ```no_run
 //! # pub fn render_to<W:Writer>(output: &mut W) { unimplemented!() }
 //! pub fn main() {
-//!     use std::io::File;
+//!     use std::old_io::File;
 //!     let mut f = File::create(&Path::new("example3.dot"));
 //!     render_to(&mut f)
 //! }
@@ -283,7 +283,7 @@
 use self::LabelText::*;
 
 use std::borrow::IntoCow;
-use std::io;
+use std::old_io;
 use std::string::CowString;
 use std::vec::CowVec;
 
@@ -536,7 +536,7 @@ pub fn default_options() -> Vec<RenderOption> { vec![] }
 /// (Simple wrapper around `render_opts` that passes a default set of options.)
 pub fn render<'a, N:Clone+'a, E:Clone+'a, G:Labeller<'a,N,E>+GraphWalk<'a,N,E>, W:Writer>(
               g: &'a G,
-              w: &mut W) -> io::IoResult<()> {
+              w: &mut W) -> old_io::IoResult<()> {
     render_opts(g, w, &[])
 }
 
@@ -545,14 +545,14 @@ pub fn render<'a, N:Clone+'a, E:Clone+'a, G:Labeller<'a,N,E>+GraphWalk<'a,N,E>,
 pub fn render_opts<'a, N:Clone+'a, E:Clone+'a, G:Labeller<'a,N,E>+GraphWalk<'a,N,E>, W:Writer>(
               g: &'a G,
               w: &mut W,
-              options: &[RenderOption]) -> io::IoResult<()>
+              options: &[RenderOption]) -> old_io::IoResult<()>
 {
-    fn writeln<W:Writer>(w: &mut W, arg: &[&str]) -> io::IoResult<()> {
+    fn writeln<W:Writer>(w: &mut W, arg: &[&str]) -> old_io::IoResult<()> {
         for &s in arg.iter() { try!(w.write_str(s)); }
         w.write_char('\n')
     }
 
-    fn indent<W:Writer>(w: &mut W) -> io::IoResult<()> {
+    fn indent<W:Writer>(w: &mut W) -> old_io::IoResult<()> {
         w.write_str("    ")
     }
 
@@ -594,7 +594,7 @@ mod tests {
     use self::NodeLabels::*;
     use super::{Id, Labeller, Nodes, Edges, GraphWalk, render};
     use super::LabelText::{self, LabelStr, EscStr};
-    use std::io::IoResult;
+    use std::old_io::IoResult;
     use std::borrow::IntoCow;
     use std::iter::repeat;
 

src/liblog/lib.rs

@@ -181,8 +181,8 @@
 
 use std::cell::RefCell;
 use std::fmt;
-use std::io::LineBufferedWriter;
+use std::old_io::LineBufferedWriter;
-use std::io;
+use std::old_io;
 use std::mem;
 use std::os;
 use std::ptr;
@@ -239,7 +239,7 @@ pub trait Logger {
 }
 
 struct DefaultLogger {
-    handle: LineBufferedWriter<io::stdio::StdWriter>,
+    handle: LineBufferedWriter<old_io::stdio::StdWriter>,
 }
 
 /// Wraps the log level with fmt implementations.
@@ -301,7 +301,7 @@ pub fn log(level: u32, loc: &'static LogLocation, args: fmt::Arguments) {
     let mut logger = LOCAL_LOGGER.with(|s| {
         s.borrow_mut().take()
     }).unwrap_or_else(|| {
-        box DefaultLogger { handle: io::stderr() } as Box<Logger + Send>
+        box DefaultLogger { handle: old_io::stderr() } as Box<Logger + Send>
     });
     logger.log(&LogRecord {
         level: LogLevel(level),

src/librbml/io.rs

@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::io::{IoError, IoResult, SeekStyle};
+use std::old_io::{IoError, IoResult, SeekStyle};
-use std::io;
+use std::old_io;
 use std::slice;
 use std::iter::repeat;
 
@@ -18,14 +18,14 @@ static 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
         })
@@ -80,7 +80,7 @@ impl SeekableMemWriter {
 
 impl Writer for SeekableMemWriter {
     #[inline]
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> {
+    fn write_all(&mut self, buf: &[u8]) -> IoResult<()> {
         if self.pos == self.buf.len() {
             self.buf.push_all(buf)
         } else {
@@ -132,7 +132,7 @@ impl Seek for SeekableMemWriter {
 mod tests {
     extern crate test;
     use super::SeekableMemWriter;
-    use std::io;
+    use std::old_io;
     use std::iter::repeat;
     use test::Bencher;
 
@@ -148,23 +148,23 @@ mod tests {
         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
         assert_eq!(writer.get_ref(), b);
 
-        writer.seek(0, io::SeekSet).unwrap();
+        writer.seek(0, old_io::SeekSet).unwrap();
         assert_eq!(writer.tell(), Ok(0));
         writer.write(&[3, 4]).unwrap();
         let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
         assert_eq!(writer.get_ref(), b);
 
-        writer.seek(1, io::SeekCur).unwrap();
+        writer.seek(1, old_io::SeekCur).unwrap();
         writer.write(&[0, 1]).unwrap();
         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
         assert_eq!(writer.get_ref(), b);
 
-        writer.seek(-1, io::SeekEnd).unwrap();
+        writer.seek(-1, old_io::SeekEnd).unwrap();
         writer.write(&[1, 2]).unwrap();
         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
         assert_eq!(writer.get_ref(), b);
 
-        writer.seek(1, io::SeekEnd).unwrap();
+        writer.seek(1, old_io::SeekEnd).unwrap();
         writer.write(&[1]).unwrap();
         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
         assert_eq!(writer.get_ref(), b);
@@ -173,14 +173,14 @@ mod tests {
     #[test]
     fn seek_past_end() {
         let mut r = SeekableMemWriter::new();
-        r.seek(10, io::SeekSet).unwrap();
+        r.seek(10, old_io::SeekSet).unwrap();
         assert!(r.write(&[3]).is_ok());
     }
 
     #[test]
     fn seek_before_0() {
         let mut r = SeekableMemWriter::new();
-        assert!(r.seek(-1, io::SeekSet).is_err());
+        assert!(r.seek(-1, old_io::SeekSet).is_err());
     }
 
     fn do_bench_seekable_mem_writer(b: &mut Bencher, times: uint, len: uint) {

src/librbml/lib.rs

@@ -115,7 +115,7 @@ pub enum EbmlEncoderTag {
 pub enum Error {
     IntTooBig(uint),
     Expected(String),
-    IoError(std::io::IoError),
+    IoError(std::old_io::IoError),
     ApplicationError(String)
 }
 
@@ -131,7 +131,7 @@ pub mod reader {
     use std::char;
 
     use std::int;
-    use std::io::extensions::u64_from_be_bytes;
+    use std::old_io::extensions::u64_from_be_bytes;
     use std::mem::transmute;
     use std::num::Int;
     use std::option::Option;
@@ -689,9 +689,9 @@ pub mod reader {
 
 pub mod writer {
     use std::clone::Clone;
-    use std::io::extensions::u64_to_be_bytes;
+    use std::old_io::extensions::u64_to_be_bytes;
-    use std::io::{Writer, Seek};
+    use std::old_io::{Writer, Seek};
-    use std::io;
+    use std::old_io;
     use std::mem;
 
     use super::{ EsVec, EsMap, EsEnum, EsVecLen, EsVecElt, EsMapLen, EsMapKey,
@@ -702,7 +702,7 @@ pub mod writer {
     use serialize;
 
 
-    pub type EncodeResult = io::IoResult<()>;
+    pub type EncodeResult = old_io::IoResult<()>;
 
     // rbml writing
     pub struct Encoder<'a, W:'a> {
@@ -712,14 +712,14 @@ pub mod writer {
 
     fn write_sized_vuint<W: Writer>(w: &mut W, n: uint, size: uint) -> EncodeResult {
         match size {
-            1u => w.write(&[0x80u8 | (n as u8)]),
+            1u => w.write_all(&[0x80u8 | (n as u8)]),
-            2u => w.write(&[0x40u8 | ((n >> 8_u) as u8), n as u8]),
+            2u => w.write_all(&[0x40u8 | ((n >> 8_u) as u8), n as u8]),
-            3u => w.write(&[0x20u8 | ((n >> 16_u) as u8), (n >> 8_u) as u8,
+            3u => w.write_all(&[0x20u8 | ((n >> 16_u) as u8), (n >> 8_u) as u8,
                             n as u8]),
-            4u => w.write(&[0x10u8 | ((n >> 24_u) as u8), (n >> 16_u) as u8,
+            4u => w.write_all(&[0x10u8 | ((n >> 24_u) as u8), (n >> 16_u) as u8,
                             (n >> 8_u) as u8, n as u8]),
-            _ => Err(io::IoError {
+            _ => Err(old_io::IoError {
-                kind: io::OtherIoError,
+                kind: old_io::OtherIoError,
                 desc: "int too big",
                 detail: Some(format!("{}", n))
             })
@@ -731,8 +731,8 @@ pub mod writer {
         if n < 0x4000_u { return write_sized_vuint(w, n, 2u); }
         if n < 0x200000_u { return write_sized_vuint(w, n, 3u); }
         if n < 0x10000000_u { return write_sized_vuint(w, n, 4u); }
-        Err(io::IoError {
+        Err(old_io::IoError {
-            kind: io::OtherIoError,
+            kind: old_io::OtherIoError,
             desc: "int too big",
             detail: Some(format!("{}", n))
         })
@@ -764,16 +764,16 @@ pub mod writer {
             // Write a placeholder four-byte size.
             self.size_positions.push(try!(self.writer.tell()) as uint);
             let zeroes: &[u8] = &[0u8, 0u8, 0u8, 0u8];
-            self.writer.write(zeroes)
+            self.writer.write_all(zeroes)
         }
 
         pub fn end_tag(&mut self) -> EncodeResult {
             let last_size_pos = self.size_positions.pop().unwrap();
             let cur_pos = try!(self.writer.tell());
-            try!(self.writer.seek(last_size_pos as i64, io::SeekSet));
+            try!(self.writer.seek(last_size_pos as i64, old_io::SeekSet));
             let size = cur_pos as uint - last_size_pos - 4;
             try!(write_sized_vuint(self.writer, size, 4u));
-            let r = try!(self.writer.seek(cur_pos as i64, io::SeekSet));
+            let r = try!(self.writer.seek(cur_pos as i64, old_io::SeekSet));
 
             debug!("End tag (size = {:?})", size);
             Ok(r)
@@ -790,7 +790,7 @@ pub mod writer {
         pub fn wr_tagged_bytes(&mut self, tag_id: uint, b: &[u8]) -> EncodeResult {
             try!(write_vuint(self.writer, tag_id));
             try!(write_vuint(self.writer, b.len()));
-            self.writer.write(b)
+            self.writer.write_all(b)
         }
 
         pub fn wr_tagged_u64(&mut self, tag_id: uint, v: u64) -> EncodeResult {
@@ -843,12 +843,12 @@ pub mod writer {
 
         pub fn wr_bytes(&mut self, b: &[u8]) -> EncodeResult {
             debug!("Write {:?} bytes", b.len());
-            self.writer.write(b)
+            self.writer.write_all(b)
         }
 
         pub fn wr_str(&mut self, s: &str) -> EncodeResult {
             debug!("Write str: {:?}", s);
-            self.writer.write(s.as_bytes())
+            self.writer.write_all(s.as_bytes())
         }
     }
 
@@ -890,7 +890,7 @@ pub mod writer {
     }
 
     impl<'a, W: Writer + Seek> serialize::Encoder for Encoder<'a, W> {
-        type Error = io::IoError;
+        type Error = old_io::IoError;
 
         fn emit_nil(&mut self) -> EncodeResult {
             Ok(())

src/librustc/metadata/decoder.rs

@@ -34,8 +34,8 @@ use middle::astencode::vtable_decoder_helpers;
 
 use std::collections::HashMap;
 use std::hash::{self, Hash, SipHasher};
-use std::io::extensions::u64_from_be_bytes;
+use std::old_io::extensions::u64_from_be_bytes;
-use std::io;
+use std::old_io;
 use std::num::FromPrimitive;
 use std::rc::Rc;
 use std::str;
@@ -1178,7 +1178,7 @@ fn get_attributes(md: rbml::Doc) -> Vec<ast::Attribute> {
 }
 
 fn list_crate_attributes(md: rbml::Doc, hash: &Svh,
-                         out: &mut io::Writer) -> io::IoResult<()> {
+                         out: &mut old_io::Writer) -> old_io::IoResult<()> {
     try!(write!(out, "=Crate Attributes ({})=\n", *hash));
 
     let r = get_attributes(md);
@@ -1223,7 +1223,7 @@ pub fn get_crate_deps(data: &[u8]) -> Vec<CrateDep> {
     return deps;
 }
 
-fn list_crate_deps(data: &[u8], out: &mut io::Writer) -> io::IoResult<()> {
+fn list_crate_deps(data: &[u8], out: &mut old_io::Writer) -> old_io::IoResult<()> {
     try!(write!(out, "=External Dependencies=\n"));
     for dep in get_crate_deps(data).iter() {
         try!(write!(out, "{} {}-{}\n", dep.cnum, dep.name, dep.hash));
@@ -1262,7 +1262,7 @@ pub fn get_crate_name(data: &[u8]) -> String {
     maybe_get_crate_name(data).expect("no crate name in crate")
 }
 
-pub fn list_crate_metadata(bytes: &[u8], out: &mut io::Writer) -> io::IoResult<()> {
+pub fn list_crate_metadata(bytes: &[u8], out: &mut old_io::Writer) -> old_io::IoResult<()> {
     let hash = get_crate_hash(bytes);
     let md = rbml::Doc::new(bytes);
     try!(list_crate_attributes(md, &hash, out));

src/librustc/metadata/encoder.rs

@@ -122,7 +122,7 @@ fn encode_trait_ref<'a, 'tcx>(rbml_w: &mut Encoder,
 // Item info table encoding
 fn encode_family(rbml_w: &mut Encoder, c: char) {
     rbml_w.start_tag(tag_items_data_item_family);
-    rbml_w.writer.write(&[c as u8]);
+    rbml_w.writer.write_all(&[c as u8]);
     rbml_w.end_tag();
 }
 
@@ -149,7 +149,7 @@ fn encode_bounds_and_type<'a, 'tcx>(rbml_w: &mut Encoder,
 fn encode_variant_id(rbml_w: &mut Encoder, vid: DefId) {
     rbml_w.start_tag(tag_items_data_item_variant);
     let s = def_to_string(vid);
-    rbml_w.writer.write(s.as_bytes());
+    rbml_w.writer.write_all(s.as_bytes());
     rbml_w.end_tag();
 
     rbml_w.start_tag(tag_mod_child);
@@ -259,7 +259,7 @@ fn encode_symbol(ecx: &EncodeContext,
     match ecx.item_symbols.borrow().get(&id) {
         Some(x) => {
             debug!("encode_symbol(id={}, str={})", id, *x);
-            rbml_w.writer.write(x.as_bytes());
+            rbml_w.writer.write_all(x.as_bytes());
         }
         None => {
             ecx.diag.handler().bug(
@@ -274,14 +274,14 @@ fn encode_disr_val(_: &EncodeContext,
                    disr_val: ty::Disr) {
     rbml_w.start_tag(tag_disr_val);
     let s = disr_val.to_string();
-    rbml_w.writer.write(s.as_bytes());
+    rbml_w.writer.write_all(s.as_bytes());
     rbml_w.end_tag();
 }
 
 fn encode_parent_item(rbml_w: &mut Encoder, id: DefId) {
     rbml_w.start_tag(tag_items_data_parent_item);
     let s = def_to_string(id);
-    rbml_w.writer.write(s.as_bytes());
+    rbml_w.writer.write_all(s.as_bytes());
     rbml_w.end_tag();
 }
 
@@ -299,7 +299,7 @@ fn encode_struct_fields(rbml_w: &mut Encoder,
         encode_def_id(rbml_w, f.id);
         rbml_w.start_tag(tag_item_field_origin);
         let s = def_to_string(origin);
-        rbml_w.writer.write(s.as_bytes());
+        rbml_w.writer.write_all(s.as_bytes());
         rbml_w.end_tag();
         rbml_w.end_tag();
     }
@@ -636,17 +636,17 @@ fn encode_explicit_self(rbml_w: &mut Encoder,
     // Encode the base self type.
     match *explicit_self {
         ty::StaticExplicitSelfCategory => {
-            rbml_w.writer.write(&[ 's' as u8 ]);
+            rbml_w.writer.write_all(&[ 's' as u8 ]);
         }
         ty::ByValueExplicitSelfCategory => {
-            rbml_w.writer.write(&[ 'v' as u8 ]);
+            rbml_w.writer.write_all(&[ 'v' as u8 ]);
         }
         ty::ByBoxExplicitSelfCategory => {
-            rbml_w.writer.write(&[ '~' as u8 ]);
+            rbml_w.writer.write_all(&[ '~' as u8 ]);
         }
         ty::ByReferenceExplicitSelfCategory(_, m) => {
             // FIXME(#4846) encode custom lifetime
-            rbml_w.writer.write(&['&' as u8]);
+            rbml_w.writer.write_all(&['&' as u8]);
             encode_mutability(rbml_w, m);
         }
     }
@@ -656,21 +656,21 @@ fn encode_explicit_self(rbml_w: &mut Encoder,
     fn encode_mutability(rbml_w: &mut Encoder,
                          m: ast::Mutability) {
         match m {
-            ast::MutImmutable => { rbml_w.writer.write(&[ 'i' as u8 ]); }
+            ast::MutImmutable => { rbml_w.writer.write_all(&[ 'i' as u8 ]); }
-            ast::MutMutable => { rbml_w.writer.write(&[ 'm' as u8 ]); }
+            ast::MutMutable => { rbml_w.writer.write_all(&[ 'm' as u8 ]); }
         }
     }
 }
 
 fn encode_item_sort(rbml_w: &mut Encoder, sort: char) {
     rbml_w.start_tag(tag_item_trait_item_sort);
-    rbml_w.writer.write(&[ sort as u8 ]);
+    rbml_w.writer.write_all(&[ sort as u8 ]);
     rbml_w.end_tag();
 }
 
 fn encode_parent_sort(rbml_w: &mut Encoder, sort: char) {
     rbml_w.start_tag(tag_item_trait_parent_sort);
-    rbml_w.writer.write(&[ sort as u8 ]);
+    rbml_w.writer.write_all(&[ sort as u8 ]);
     rbml_w.end_tag();
 }
 
@@ -679,7 +679,7 @@ fn encode_provided_source(rbml_w: &mut Encoder,
     for source in source_opt.iter() {
         rbml_w.start_tag(tag_item_method_provided_source);
         let s = def_to_string(*source);
-        rbml_w.writer.write(s.as_bytes());
+        rbml_w.writer.write_all(s.as_bytes());
         rbml_w.end_tag();
     }
 }
@@ -926,7 +926,7 @@ fn encode_method_argument_names(rbml_w: &mut Encoder,
         rbml_w.start_tag(tag_method_argument_name);
         if let ast::PatIdent(_, ref path1, _) = arg.pat.node {
             let name = token::get_ident(path1.node);
-            rbml_w.writer.write(name.get().as_bytes());
+            rbml_w.writer.write_all(name.get().as_bytes());
         }
         rbml_w.end_tag();
     }
@@ -1646,7 +1646,7 @@ fn encode_meta_item(rbml_w: &mut Encoder, mi: &ast::MetaItem) {
       ast::MetaWord(ref name) => {
         rbml_w.start_tag(tag_meta_item_word);
         rbml_w.start_tag(tag_meta_item_name);
-        rbml_w.writer.write(name.get().as_bytes());
+        rbml_w.writer.write_all(name.get().as_bytes());
         rbml_w.end_tag();
         rbml_w.end_tag();
       }
@@ -1655,10 +1655,10 @@ fn encode_meta_item(rbml_w: &mut Encoder, mi: &ast::MetaItem) {
           ast::LitStr(ref value, _) => {
             rbml_w.start_tag(tag_meta_item_name_value);
             rbml_w.start_tag(tag_meta_item_name);
-            rbml_w.writer.write(name.get().as_bytes());
+            rbml_w.writer.write_all(name.get().as_bytes());
             rbml_w.end_tag();
             rbml_w.start_tag(tag_meta_item_value);
-            rbml_w.writer.write(value.get().as_bytes());
+            rbml_w.writer.write_all(value.get().as_bytes());
             rbml_w.end_tag();
             rbml_w.end_tag();
           }
@@ -1668,7 +1668,7 @@ fn encode_meta_item(rbml_w: &mut Encoder, mi: &ast::MetaItem) {
       ast::MetaList(ref name, ref items) => {
         rbml_w.start_tag(tag_meta_item_list);
         rbml_w.start_tag(tag_meta_item_name);
-        rbml_w.writer.write(name.get().as_bytes());
+        rbml_w.writer.write_all(name.get().as_bytes());
         rbml_w.end_tag();
         for inner_item in items.iter() {
             encode_meta_item(rbml_w, &**inner_item);
@@ -1800,7 +1800,7 @@ fn encode_native_libraries(ecx: &EncodeContext, rbml_w: &mut Encoder) {
                 rbml_w.end_tag();
 
                 rbml_w.start_tag(tag_native_libraries_name);
-                rbml_w.writer.write(lib.as_bytes());
+                rbml_w.writer.write_all(lib.as_bytes());
                 rbml_w.end_tag();
 
                 rbml_w.end_tag();
@@ -1975,29 +1975,29 @@ fn encode_crate_dep(rbml_w: &mut Encoder,
                     dep: decoder::CrateDep) {
     rbml_w.start_tag(tag_crate_dep);
     rbml_w.start_tag(tag_crate_dep_crate_name);
-    rbml_w.writer.write(dep.name.as_bytes());
+    rbml_w.writer.write_all(dep.name.as_bytes());
     rbml_w.end_tag();
     rbml_w.start_tag(tag_crate_dep_hash);
-    rbml_w.writer.write(dep.hash.as_str().as_bytes());
+    rbml_w.writer.write_all(dep.hash.as_str().as_bytes());
     rbml_w.end_tag();
     rbml_w.end_tag();
 }
 
 fn encode_hash(rbml_w: &mut Encoder, hash: &Svh) {
     rbml_w.start_tag(tag_crate_hash);
-    rbml_w.writer.write(hash.as_str().as_bytes());
+    rbml_w.writer.write_all(hash.as_str().as_bytes());
     rbml_w.end_tag();
 }
 
 fn encode_crate_name(rbml_w: &mut Encoder, crate_name: &str) {
     rbml_w.start_tag(tag_crate_crate_name);
-    rbml_w.writer.write(crate_name.as_bytes());
+    rbml_w.writer.write_all(crate_name.as_bytes());
     rbml_w.end_tag();
 }
 
 fn encode_crate_triple(rbml_w: &mut Encoder, triple: &str) {
     rbml_w.start_tag(tag_crate_triple);
-    rbml_w.writer.write(triple.as_bytes());
+    rbml_w.writer.write_all(triple.as_bytes());
     rbml_w.end_tag();
 }
 
@@ -2011,7 +2011,7 @@ fn encode_dylib_dependency_formats(rbml_w: &mut Encoder, ecx: &EncodeContext) {
                     cstore::RequireStatic => "s",
                 })).to_string())
             }).collect::<Vec<String>>();
-            rbml_w.writer.write(s.connect(",").as_bytes());
+            rbml_w.writer.write_all(s.connect(",").as_bytes());
         }
         None => {}
     }

src/librustc/metadata/filesearch.rs

@@ -13,8 +13,8 @@
 pub use self::FileMatch::*;
 
 use std::collections::HashSet;
-use std::io::fs::PathExtensions;
+use std::old_io::fs::PathExtensions;
-use std::io::fs;
+use std::old_io::fs;
 use std::os;
 
 use util::fs as myfs;

src/librustc/metadata/loader.rs

@@ -231,8 +231,8 @@ use rustc_back::target::Target;
 use std::ffi::CString;
 use std::cmp;
 use std::collections::HashMap;
-use std::io::fs::PathExtensions;
+use std::old_io::fs::PathExtensions;
-use std::io;
+use std::old_io;
 use std::ptr;
 use std::slice;
 use std::time::Duration;
@@ -796,7 +796,7 @@ pub fn read_meta_section_name(is_osx: bool) -> &'static str {
 
 // A diagnostic function for dumping crate metadata to an output stream
 pub fn list_file_metadata(is_osx: bool, path: &Path,
-                          out: &mut io::Writer) -> io::IoResult<()> {
+                          out: &mut old_io::Writer) -> old_io::IoResult<()> {
     match get_metadata_section(is_osx, path) {
         Ok(bytes) => decoder::list_crate_metadata(bytes.as_slice(), out),
         Err(msg) => {

src/librustc/metadata/tydecode.rs

@@ -377,6 +377,14 @@ fn parse_scope(st: &mut PState) -> region::CodeExtent {
             let node_id = parse_uint(st) as ast::NodeId;
             region::CodeExtent::Misc(node_id)
         }
+        'B' => {
+            let node_id = parse_uint(st) as ast::NodeId;
+            let first_stmt_index = parse_uint(st);
+            let block_remainder = region::BlockRemainder {
+                block: node_id, first_statement_index: first_stmt_index,
+            };
+            region::CodeExtent::Remainder(block_remainder)
+        }
         _ => panic!("parse_scope: bad input")
     }
 }

src/librustc/metadata/tyencode.rs

@@ -51,7 +51,7 @@ pub type abbrev_map<'tcx> = RefCell<FnvHashMap<Ty<'tcx>, ty_abbrev>>;
 
 pub fn enc_ty<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>, t: Ty<'tcx>) {
     match cx.abbrevs.borrow_mut().get(&t) {
-        Some(a) => { w.write(a.s.as_bytes()); return; }
+        Some(a) => { w.write_all(a.s.as_bytes()); return; }
         None => {}
     }
     let pos = w.tell().unwrap();
@@ -276,7 +276,9 @@ pub fn enc_region(w: &mut SeekableMemWriter, cx: &ctxt, r: ty::Region) {
 
 fn enc_scope(w: &mut SeekableMemWriter, _cx: &ctxt, scope: region::CodeExtent) {
     match scope {
-        region::CodeExtent::Misc(node_id) => mywrite!(w, "M{}", node_id)
+        region::CodeExtent::Misc(node_id) => mywrite!(w, "M{}", node_id),
+        region::CodeExtent::Remainder(region::BlockRemainder {
+            block: b, first_statement_index: i }) => mywrite!(w, "B{}{}", b, i),
     }
 }
 

src/librustc/middle/astencode.rs

@@ -37,7 +37,7 @@ use syntax::parse::token;
 use syntax::ptr::P;
 use syntax;
 
-use std::io::Seek;
+use std::old_io::Seek;
 use std::rc::Rc;
 
 use rbml::io::SeekableMemWriter;

src/librustc/middle/dataflow.rs

@@ -19,7 +19,7 @@ pub use self::EntryOrExit::*;
 use middle::cfg;
 use middle::cfg::CFGIndex;
 use middle::ty;
-use std::io;
+use std::old_io;
 use std::uint;
 use std::iter::repeat;
 use syntax::ast;
@@ -105,7 +105,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> {
 impl<'a, 'tcx, O:DataFlowOperator> pprust::PpAnn for DataFlowContext<'a, 'tcx, O> {
     fn pre(&self,
            ps: &mut pprust::State,
-           node: pprust::AnnNode) -> io::IoResult<()> {
+           node: pprust::AnnNode) -> old_io::IoResult<()> {
         let id = match node {
             pprust::NodeIdent(_) | pprust::NodeName(_) => 0,
             pprust::NodeExpr(expr) => expr.id,
@@ -457,13 +457,13 @@ impl<'a, 'tcx, O:DataFlowOperator+Clone+'static> DataFlowContext<'a, 'tcx, O> {
 
         debug!("Dataflow result for {}:", self.analysis_name);
         debug!("{}", {
-            self.pretty_print_to(box io::stderr(), blk).unwrap();
+            self.pretty_print_to(box old_io::stderr(), blk).unwrap();
             ""
         });
     }
 
-    fn pretty_print_to(&self, wr: Box<io::Writer+'static>,
+    fn pretty_print_to(&self, wr: Box<old_io::Writer+'static>,
-                       blk: &ast::Block) -> io::IoResult<()> {
+                       blk: &ast::Block) -> old_io::IoResult<()> {
         let mut ps = pprust::rust_printer_annotated(wr, self);
         try!(ps.cbox(pprust::indent_unit));
         try!(ps.ibox(0u));

src/librustc/middle/infer/error_reporting.rs

@@ -809,6 +809,8 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
         let scope_id = same_regions[0].scope_id;
         let parent = self.tcx.map.get_parent(scope_id);
         let parent_node = self.tcx.map.find(parent);
+        let taken = lifetimes_in_scope(self.tcx, scope_id);
+        let life_giver = LifeGiver::with_taken(&taken[]);
         let node_inner = match parent_node {
             Some(ref node) => match *node {
                 ast_map::NodeItem(ref item) => {
@@ -851,8 +853,6 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
         };
         let (fn_decl, generics, unsafety, ident, expl_self, span)
                                     = node_inner.expect("expect item fn");
-        let taken = lifetimes_in_scope(self.tcx, scope_id);
-        let life_giver = LifeGiver::with_taken(&taken[]);
         let rebuilder = Rebuilder::new(self.tcx, fn_decl, expl_self,
                                        generics, same_regions, &life_giver);
         let (fn_decl, expl_self, generics) = rebuilder.rebuild();

src/librustc/middle/infer/region_inference/graphviz.rs

@@ -26,7 +26,7 @@ use util::nodemap::{FnvHashMap, FnvHashSet};
 use util::ppaux::Repr;
 
 use std::collections::hash_map::Entry::Vacant;
-use std::io::{self, File};
+use std::old_io::{self, File};
 use std::os;
 use std::sync::atomic::{AtomicBool, Ordering, ATOMIC_BOOL_INIT};
 use syntax::ast;
@@ -217,7 +217,7 @@ pub type ConstraintMap<'tcx> = FnvHashMap<Constraint, SubregionOrigin<'tcx>>;
 
 fn dump_region_constraints_to<'a, 'tcx:'a >(tcx: &'a ty::ctxt<'tcx>,
                                             map: &ConstraintMap<'tcx>,
-                                            path: &str) -> io::IoResult<()> {
+                                            path: &str) -> old_io::IoResult<()> {
     debug!("dump_region_constraints map (len: {}) path: {}", map.len(), path);
     let g = ConstraintGraph::new(tcx, format!("region_constraints"), map);
     let mut f = File::create(&Path::new(path));

src/librustc/middle/liveness.rs

@@ -118,7 +118,7 @@ use middle::ty::ClosureTyper;
 use lint;
 use util::nodemap::NodeMap;
 
-use std::{fmt, io, uint};
+use std::{fmt, old_io, uint};
 use std::rc::Rc;
 use std::iter::repeat;
 use syntax::ast::{self, NodeId, Expr};
@@ -693,10 +693,10 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
     }
 
     fn write_vars<F>(&self,
-                     wr: &mut io::Writer,
+                     wr: &mut old_io::Writer,
                      ln: LiveNode,
                      mut test: F)
-                     -> io::IoResult<()> where
+                     -> old_io::IoResult<()> where
         F: FnMut(uint) -> LiveNode,
     {
         let node_base_idx = self.idx(ln, Variable(0));
@@ -740,7 +740,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
     fn ln_str(&self, ln: LiveNode) -> String {
         let mut wr = Vec::new();
         {
-            let wr = &mut wr as &mut io::Writer;
+            let wr = &mut wr as &mut old_io::Writer;
             write!(wr, "[ln({:?}) of kind {:?} reads", ln.get(), self.ir.lnk(ln));
             self.write_vars(wr, ln, |idx| self.users[idx].reader);
             write!(wr, "  writes");

src/librustc/middle/region.rs

@@ -26,6 +26,7 @@ use syntax::codemap::{self, Span};
 use syntax::{ast, visit};
 use syntax::ast::{Block, Item, FnDecl, NodeId, Arm, Pat, Stmt, Expr, Local};
 use syntax::ast_util::{stmt_id};
+use syntax::ast_map;
 use syntax::visit::{Visitor, FnKind};
 
 /// CodeExtent represents a statically-describable extent that can be
@@ -38,7 +39,32 @@ use syntax::visit::{Visitor, FnKind};
 #[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, RustcEncodable,
            RustcDecodable, Show, Copy)]
 pub enum CodeExtent {
-    Misc(ast::NodeId)
+    Misc(ast::NodeId),
+    Remainder(BlockRemainder),
+}
+
+/// Represents a subscope of `block` for a binding that is introduced
+/// by `block.stmts[first_statement_index]`. Such subscopes represent
+/// a suffix of the block. Note that each subscope does not include
+/// the initializer expression, if any, for the statement indexed by
+/// `first_statement_index`.
+///
+/// For example, given `{ let (a, b) = EXPR_1; let c = EXPR_2; ... }`:
+///
+/// * the subscope with `first_statement_index == 0` is scope of both
+///   `a` and `b`; it does not include EXPR_1, but does include
+///   everything after that first `let`. (If you want a scope that
+///   includes EXPR_1 as well, then do not use `CodeExtent::Remainder`,
+///   but instead another `CodeExtent` that encompasses the whole block,
+///   e.g. `CodeExtent::Misc`.
+///
+/// * the subscope with `first_statement_index == 1` is scope of `c`,
+///   and thus does not include EXPR_2, but covers the `...`.
+#[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, RustcEncodable,
+         RustcDecodable, Show, Copy)]
+pub struct BlockRemainder {
+    pub block: ast::NodeId,
+    pub first_statement_index: uint,
 }
 
 impl CodeExtent {
@@ -55,6 +81,7 @@ impl CodeExtent {
     pub fn node_id(&self) -> ast::NodeId {
         match *self {
             CodeExtent::Misc(node_id) => node_id,
+            CodeExtent::Remainder(br) => br.block,
         }
     }
 
@@ -65,8 +92,41 @@ impl CodeExtent {
     {
         match *self {
             CodeExtent::Misc(node_id) => CodeExtent::Misc(f_id(node_id)),
+            CodeExtent::Remainder(br) =>
+                CodeExtent::Remainder(BlockRemainder {
+                    block: f_id(br.block), first_statement_index: br.first_statement_index }),
         }
     }
+
+    /// Returns the span of this CodeExtent.  Note that in general the
+    /// returned span may not correspond to the span of any node id in
+    /// the AST.
+    pub fn span(&self, ast_map: &ast_map::Map) -> Option<Span> {
+        match ast_map.find(self.node_id()) {
+            Some(ast_map::NodeBlock(ref blk)) => {
+                match *self {
+                    CodeExtent::Misc(_) => Some(blk.span),
+
+                    CodeExtent::Remainder(r) => {
+                        assert_eq!(r.block, blk.id);
+                        // Want span for extent starting after the
+                        // indexed statement and ending at end of
+                        // `blk`; reuse span of `blk` and shift `lo`
+                        // forward to end of indexed statement.
+                        //
+                        // (This is the special case aluded to in the
+                        // doc-comment for this method)
+                        let stmt_span = blk.stmts[r.first_statement_index].span;
+                        Some(Span { lo: stmt_span.hi, ..blk.span })
+                    }
+                }
+            }
+            Some(ast_map::NodeExpr(ref expr)) => Some(expr.span),
+            Some(ast_map::NodeStmt(ref stmt)) => Some(stmt.span),
+            Some(ast_map::NodeItem(ref item)) => Some(item.span),
+            Some(_) | None => None,
+         }
+    }
 }
 
 /// The region maps encode information about region relationships.
@@ -74,7 +134,8 @@ impl CodeExtent {
 /// - `scope_map` maps from a scope id to the enclosing scope id; this is
 ///   usually corresponding to the lexical nesting, though in the case of
 ///   closures the parent scope is the innermost conditional expression or repeating
-///   block
+///   block. (Note that the enclosing scope id for the block
+///   associated with a closure is the closure itself.)
 ///
 /// - `var_map` maps from a variable or binding id to the block in which
 ///   that variable is declared.
@@ -115,12 +176,77 @@ pub struct RegionMaps {
     terminating_scopes: RefCell<FnvHashSet<CodeExtent>>,
 }
 
-#[derive(Copy)]
+/// Carries the node id for the innermost block or match expression,
-pub struct Context {
+/// for building up the `var_map` which maps ids to the blocks in
-    var_parent: Option<ast::NodeId>,
+/// which they were declared.
+#[derive(PartialEq, Eq, Show, Copy)]
+enum InnermostDeclaringBlock {
+    None,
+    Block(ast::NodeId),
+    Statement(DeclaringStatementContext),
+    Match(ast::NodeId),
+}
 
-    // Innermost enclosing expression
+impl InnermostDeclaringBlock {
-    parent: Option<ast::NodeId>,
+    fn to_code_extent(&self) -> Option<CodeExtent> {
+        let extent = match *self {
+            InnermostDeclaringBlock::None => {
+                return Option::None;
+            }
+            InnermostDeclaringBlock::Block(id) |
+            InnermostDeclaringBlock::Match(id) => CodeExtent::from_node_id(id),
+            InnermostDeclaringBlock::Statement(s) =>  s.to_code_extent(),
+        };
+        Option::Some(extent)
+    }
+}
+
+/// Contextual information for declarations introduced by a statement
+/// (i.e. `let`). It carries node-id's for statement and enclosing
+/// block both, as well as the statement's index within the block.
+#[derive(PartialEq, Eq, Show, Copy)]
+struct DeclaringStatementContext {
+    stmt_id: ast::NodeId,
+    block_id: ast::NodeId,
+    stmt_index: uint,
+}
+
+impl DeclaringStatementContext {
+    fn to_code_extent(&self) -> CodeExtent {
+        CodeExtent::Remainder(BlockRemainder {
+            block: self.block_id,
+            first_statement_index: self.stmt_index,
+        })
+    }
+}
+
+#[derive(PartialEq, Eq, Show, Copy)]
+enum InnermostEnclosingExpr {
+    None,
+    Some(ast::NodeId),
+    Statement(DeclaringStatementContext),
+}
+
+impl InnermostEnclosingExpr {
+    fn to_code_extent(&self) -> Option<CodeExtent> {
+        let extent = match *self {
+            InnermostEnclosingExpr::None => {
+                return Option::None;
+            }
+            InnermostEnclosingExpr::Statement(s) =>
+                s.to_code_extent(),
+            InnermostEnclosingExpr::Some(parent_id) =>
+                CodeExtent::from_node_id(parent_id),
+        };
+        Some(extent)
+    }
+}
+
+#[derive(Show, Copy)]
+pub struct Context {
+    var_parent: InnermostDeclaringBlock,
+
+    parent: InnermostEnclosingExpr,
 }
 
 struct RegionResolutionVisitor<'a> {
@@ -381,16 +507,13 @@ impl RegionMaps {
     }
 }
 
-/// Records the current parent (if any) as the parent of `child_id`.
+/// Records the current parent (if any) as the parent of `child_scope`.
 fn record_superlifetime(visitor: &mut RegionResolutionVisitor,
-                        child_id: ast::NodeId,
+                        child_scope: CodeExtent,
                         _sp: Span) {
-    match visitor.cx.parent {
+    match visitor.cx.parent.to_code_extent() {
-        Some(parent_id) => {
+        Some(parent_scope) =>
-            let child_scope = CodeExtent::from_node_id(child_id);
+            visitor.region_maps.record_encl_scope(child_scope, parent_scope),
-            let parent_scope = CodeExtent::from_node_id(parent_id);
-            visitor.region_maps.record_encl_scope(child_scope, parent_scope);
-        }
         None => {}
     }
 }
@@ -399,11 +522,9 @@ fn record_superlifetime(visitor: &mut RegionResolutionVisitor,
 fn record_var_lifetime(visitor: &mut RegionResolutionVisitor,
                        var_id: ast::NodeId,
                        _sp: Span) {
-    match visitor.cx.var_parent {
+    match visitor.cx.var_parent.to_code_extent() {
-        Some(parent_id) => {
+        Some(parent_scope) =>
-            let parent_scope = CodeExtent::from_node_id(parent_id);
+            visitor.region_maps.record_var_scope(var_id, parent_scope),
-            visitor.region_maps.record_var_scope(var_id, parent_scope);
-        }
         None => {
             // this can happen in extern fn declarations like
             //
@@ -415,21 +536,72 @@ fn record_var_lifetime(visitor: &mut RegionResolutionVisitor,
 fn resolve_block(visitor: &mut RegionResolutionVisitor, blk: &ast::Block) {
     debug!("resolve_block(blk.id={:?})", blk.id);
 
-    // Record the parent of this block.
+    let prev_cx = visitor.cx;
-    record_superlifetime(visitor, blk.id, blk.span);
+
+    let blk_scope = CodeExtent::Misc(blk.id);
+    record_superlifetime(visitor, blk_scope, blk.span);
 
     // We treat the tail expression in the block (if any) somewhat
     // differently from the statements. The issue has to do with
-    // temporary lifetimes. If the user writes:
+    // temporary lifetimes. Consider the following:
     //
-    //   {
+    //    quux({
-    //     ... (&foo()) ...
+    //        let inner = ... (&bar()) ...;
-    //   }
     //
+    //        (... (&foo()) ...) // (the tail expression)
+    //    }, other_argument());
+    //
+    // Each of the statements within the block is a terminating
+    // scope, and thus a temporary (e.g. the result of calling
+    // `bar()` in the initalizer expression for `let inner = ...;`)
+    // will be cleaned up immediately after its corresponding
+    // statement (i.e. `let inner = ...;`) executes.
+    //
+    // On the other hand, temporaries associated with evaluating the
+    // tail expression for the block are assigned lifetimes so that
+    // they will be cleaned up as part of the terminating scope
+    // *surrounding* the block expression. Here, the terminating
+    // scope for the block expression is the `quux(..)` call; so
+    // those temporaries will only be cleaned up *after* both
+    // `other_argument()` has run and also the call to `quux(..)`
+    // itself has returned.
+
+    visitor.cx = Context {
+        var_parent: InnermostDeclaringBlock::Block(blk.id),
+        parent: InnermostEnclosingExpr::Some(blk.id),
+    };
+
+    {
+        // This block should be kept approximately in sync with
+        // `visit::walk_block`. (We manually walk the block, rather
+        // than call `walk_block`, in order to maintain precise
+        // `InnermostDeclaringBlock` information.)
+
+        for (i, statement) in blk.stmts.iter().enumerate() {
+            if let ast::StmtDecl(_, stmt_id) = statement.node {
+                // Each StmtDecl introduces a subscope for bindings
+                // introduced by the declaration; this subscope covers
+                // a suffix of the block . Each subscope in a block
+                // has the previous subscope in the block as a parent,
+                // except for the first such subscope, which has the
+                // block itself as a parent.
+                let declaring = DeclaringStatementContext {
+                    stmt_id: stmt_id,
+                    block_id: blk.id,
+                    stmt_index: i,
+                };
+                record_superlifetime(
+                    visitor, declaring.to_code_extent(), statement.span);
+                visitor.cx = Context {
+                    var_parent: InnermostDeclaringBlock::Statement(declaring),
+                    parent: InnermostEnclosingExpr::Statement(declaring),
+                };
+            }
+            visitor.visit_stmt(&**statement)
+        }
+        visit::walk_expr_opt(visitor, &blk.expr)
+    }
 
-    let prev_cx = visitor.cx;
-    visitor.cx = Context {var_parent: Some(blk.id), parent: Some(blk.id)};
-    visit::walk_block(visitor, blk);
     visitor.cx = prev_cx;
 }
 
@@ -449,7 +621,7 @@ fn resolve_arm(visitor: &mut RegionResolutionVisitor, arm: &ast::Arm) {
 }
 
 fn resolve_pat(visitor: &mut RegionResolutionVisitor, pat: &ast::Pat) {
-    record_superlifetime(visitor, pat.id, pat.span);
+    record_superlifetime(visitor, CodeExtent::from_node_id(pat.id), pat.span);
 
     // If this is a binding (or maybe a binding, I'm too lazy to check
     // the def map) then record the lifetime of that binding.
@@ -468,11 +640,17 @@ fn resolve_stmt(visitor: &mut RegionResolutionVisitor, stmt: &ast::Stmt) {
     debug!("resolve_stmt(stmt.id={:?})", stmt_id);
 
     let stmt_scope = CodeExtent::from_node_id(stmt_id);
+
+    // Every statement will clean up the temporaries created during
+    // execution of that statement. Therefore each statement has an
+    // associated destruction scope that represents the extent of the
+    // statement plus its destructors, and thus the extent for which
+    // regions referenced by the destructors need to survive.
     visitor.region_maps.mark_as_terminating_scope(stmt_scope);
-    record_superlifetime(visitor, stmt_id, stmt.span);
+    record_superlifetime(visitor, stmt_scope, stmt.span);
 
     let prev_parent = visitor.cx.parent;
-    visitor.cx.parent = Some(stmt_id);
+    visitor.cx.parent = InnermostEnclosingExpr::Some(stmt_id);
     visit::walk_stmt(visitor, stmt);
     visitor.cx.parent = prev_parent;
 }
@@ -480,10 +658,11 @@ fn resolve_stmt(visitor: &mut RegionResolutionVisitor, stmt: &ast::Stmt) {
 fn resolve_expr(visitor: &mut RegionResolutionVisitor, expr: &ast::Expr) {
     debug!("resolve_expr(expr.id={:?})", expr.id);
 
-    record_superlifetime(visitor, expr.id, expr.span);
+    let expr_scope = CodeExtent::Misc(expr.id);
+    record_superlifetime(visitor, expr_scope, expr.span);
 
     let prev_cx = visitor.cx;
-    visitor.cx.parent = Some(expr.id);
+    visitor.cx.parent = InnermostEnclosingExpr::Some(expr.id);
 
     {
         let region_maps = &mut visitor.region_maps;
@@ -527,11 +706,11 @@ fn resolve_expr(visitor: &mut RegionResolutionVisitor, expr: &ast::Expr) {
 
                 // The variable parent of everything inside (most importantly, the
                 // pattern) is the body.
-                visitor.cx.var_parent = Some(body.id);
+                visitor.cx.var_parent = InnermostDeclaringBlock::Block(body.id);
             }
 
             ast::ExprMatch(..) => {
-                visitor.cx.var_parent = Some(expr.id);
+                visitor.cx.var_parent = InnermostDeclaringBlock::Match(expr.id);
             }
 
             ast::ExprAssignOp(..) | ast::ExprIndex(..) |
@@ -568,19 +747,13 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor, local: &ast::Local) {
     debug!("resolve_local(local.id={:?},local.init={:?})",
            local.id,local.init.is_some());
 
-    let blk_id = match visitor.cx.var_parent {
-        Some(id) => id,
-        None => {
-            visitor.sess.span_bug(
-                local.span,
-                "local without enclosing block");
-        }
-    };
-
     // For convenience in trans, associate with the local-id the var
     // scope that will be used for any bindings declared in this
     // pattern.
-    let blk_scope = CodeExtent::from_node_id(blk_id);
+    let blk_scope = visitor.cx.var_parent.to_code_extent()
+        .unwrap_or_else(|| visitor.sess.span_bug(
+            local.span, "local without enclosing block"));
+
     visitor.region_maps.record_var_scope(local.id, blk_scope);
 
     // As an exception to the normal rules governing temporary
@@ -803,7 +976,10 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor, local: &ast::Local) {
 fn resolve_item(visitor: &mut RegionResolutionVisitor, item: &ast::Item) {
     // Items create a new outer block scope as far as we're concerned.
     let prev_cx = visitor.cx;
-    visitor.cx = Context {var_parent: None, parent: None};
+    visitor.cx = Context {
+        var_parent: InnermostDeclaringBlock::None,
+        parent: InnermostEnclosingExpr::None
+    };
     visit::walk_item(visitor, item);
     visitor.cx = prev_cx;
 }
@@ -829,15 +1005,20 @@ fn resolve_fn(visitor: &mut RegionResolutionVisitor,
     let outer_cx = visitor.cx;
 
     // The arguments and `self` are parented to the body of the fn.
-    visitor.cx = Context { parent: Some(body.id),
+    visitor.cx = Context {
-                           var_parent: Some(body.id) };
+        parent: InnermostEnclosingExpr::Some(body.id),
+        var_parent: InnermostDeclaringBlock::Block(body.id)
+    };
     visit::walk_fn_decl(visitor, decl);
 
     // The body of the fn itself is either a root scope (top-level fn)
     // or it continues with the inherited scope (closures).
     match fk {
         visit::FkItemFn(..) | visit::FkMethod(..) => {
-            visitor.cx = Context { parent: None, var_parent: None };
+            visitor.cx = Context {
+                parent: InnermostEnclosingExpr::None,
+                var_parent: InnermostDeclaringBlock::None
+            };
             visitor.visit_block(body);
             visitor.cx = outer_cx;
         }
@@ -898,7 +1079,10 @@ pub fn resolve_crate(sess: &Session, krate: &ast::Crate) -> RegionMaps {
         let mut visitor = RegionResolutionVisitor {
             sess: sess,
             region_maps: &maps,
-            cx: Context { parent: None, var_parent: None }
+            cx: Context {
+                parent: InnermostEnclosingExpr::None,
+                var_parent: InnermostDeclaringBlock::None,
+            }
         };
         visit::walk_crate(&mut visitor, krate);
     }
@@ -911,7 +1095,10 @@ pub fn resolve_inlined_item(sess: &Session,
     let mut visitor = RegionResolutionVisitor {
         sess: sess,
         region_maps: region_maps,
-        cx: Context { parent: None, var_parent: None }
+        cx: Context {
+            parent: InnermostEnclosingExpr::None,
+            var_parent: InnermostDeclaringBlock::None
+        }
     };
     visit::walk_inlined_item(&mut visitor, item);
 }

src/librustc/middle/ty.rs

@@ -3126,7 +3126,6 @@ pub fn type_is_scalar(ty: Ty) -> bool {
       ty_bool | ty_char | ty_int(_) | ty_float(_) | ty_uint(_) |
       ty_infer(IntVar(_)) | ty_infer(FloatVar(_)) |
       ty_bare_fn(..) | ty_ptr(_) => true,
-      ty_tup(ref tys) if tys.is_empty() => true,
       _ => false
     }
 }

src/librustc/util/ppaux.rs

@@ -10,6 +10,7 @@
 
 
 use middle::def;
+use middle::region;
 use middle::subst::{VecPerParamSpace,Subst};
 use middle::subst;
 use middle::ty::{BoundRegion, BrAnon, BrNamed};
@@ -84,37 +85,41 @@ pub fn explain_region_and_span(cx: &ctxt, region: ty::Region)
                             -> (String, Option<Span>) {
     return match region {
       ReScope(scope) => {
-        match cx.map.find(scope.node_id()) {
+        let new_string;
-          Some(ast_map::NodeBlock(ref blk)) => {
+        let on_unknown_scope = |&:| {
-            explain_span(cx, "block", blk.span)
+          (format!("unknown scope: {:?}.  Please report a bug.", scope), None)
-          }
+        };
-          Some(ast_map::NodeExpr(expr)) => {
+        let span = match scope.span(&cx.map) {
-            match expr.node {
+          Some(s) => s,
-              ast::ExprCall(..) => explain_span(cx, "call", expr.span),
+          None => return on_unknown_scope(),
-              ast::ExprMethodCall(..) => {
+        };
-                explain_span(cx, "method call", expr.span)
+        let tag = match cx.map.find(scope.node_id()) {
-              },
+          Some(ast_map::NodeBlock(_)) => "block",
-              ast::ExprMatch(_, _, ast::MatchSource::IfLetDesugar { .. }) =>
+          Some(ast_map::NodeExpr(expr)) => match expr.node {
-                  explain_span(cx, "if let", expr.span),
+              ast::ExprCall(..) => "call",
-              ast::ExprMatch(_, _, ast::MatchSource::WhileLetDesugar) => {
+              ast::ExprMethodCall(..) => "method call",
-                  explain_span(cx, "while let", expr.span)
+              ast::ExprMatch(_, _, ast::MatchSource::IfLetDesugar { .. }) => "if let",
-              },
+              ast::ExprMatch(_, _, ast::MatchSource::WhileLetDesugar) =>  "while let",
-              ast::ExprMatch(..) => explain_span(cx, "match", expr.span),
+              ast::ExprMatch(..) => "match",
-              _ => explain_span(cx, "expression", expr.span)
+              _ => "expression",
-            }
+          },
-          }
+          Some(ast_map::NodeStmt(_)) => "statement",
-          Some(ast_map::NodeStmt(stmt)) => {
+          Some(ast_map::NodeItem(it)) => item_scope_tag(&*it),
-              explain_span(cx, "statement", stmt.span)
-          }
-          Some(ast_map::NodeItem(it)) => {
-              let tag = item_scope_tag(&*it);
-              explain_span(cx, tag, it.span)
-          }
           Some(_) | None => {
             // this really should not happen
-            (format!("unknown scope: {:?}.  Please report a bug.", scope), None)
+            return on_unknown_scope();
           }
-        }
+        };
+        let scope_decorated_tag = match scope {
+            region::CodeExtent::Misc(_) => tag,
+            region::CodeExtent::Remainder(r) => {
+                new_string = format!("block suffix following statement {}",
+                                     r.first_statement_index);
+                new_string.as_slice()
+            }
+        };
+        explain_span(cx, scope_decorated_tag, span)
+
       }
 
       ReFree(ref fr) => {
@@ -867,6 +872,17 @@ impl<'tcx> Repr<'tcx> for ty::FreeRegion {
     }
 }
 
+impl<'tcx> Repr<'tcx> for region::CodeExtent {
+    fn repr(&self, _tcx: &ctxt) -> String {
+        match *self {
+            region::CodeExtent::Misc(node_id) =>
+                format!("Misc({})", node_id),
+            region::CodeExtent::Remainder(rem) =>
+                format!("Remainder({}, {})", rem.block, rem.first_statement_index),
+        }
+    }
+}
+
 impl<'tcx> Repr<'tcx> for ast::DefId {
     fn repr(&self, tcx: &ctxt) -> String {
         // Unfortunately, there seems to be no way to attempt to print

src/librustc_back/archive.rs

@@ -10,10 +10,10 @@
 
 //! A helper class for dealing with static archives
 
-use std::io::fs::PathExtensions;
+use std::old_io::fs::PathExtensions;
-use std::io::process::{Command, ProcessOutput};
+use std::old_io::process::{Command, ProcessOutput};
-use std::io::{fs, TempDir};
+use std::old_io::{fs, TempDir};
-use std::io;
+use std::old_io;
 use std::os;
 use std::str;
 use syntax::diagnostic::Handler as ErrorHandler;
@@ -172,7 +172,7 @@ impl<'a> ArchiveBuilder<'a> {
 
     /// Adds all of the contents of a native library to this archive. This will
     /// search in the relevant locations for a library named `name`.
-    pub fn add_native_library(&mut self, name: &str) -> io::IoResult<()> {
+    pub fn add_native_library(&mut self, name: &str) -> old_io::IoResult<()> {
         let location = find_library(name,
                                     &self.archive.slib_prefix[],
                                     &self.archive.slib_suffix[],
@@ -187,7 +187,7 @@ impl<'a> ArchiveBuilder<'a> {
     /// This ignores adding the bytecode from the rlib, and if LTO is enabled
     /// then the object file also isn't added.
     pub fn add_rlib(&mut self, rlib: &Path, name: &str,
-                    lto: bool) -> io::IoResult<()> {
+                    lto: bool) -> old_io::IoResult<()> {
         // Ignoring obj file starting with the crate name
         // as simple comparison is not enough - there
         // might be also an extra name suffix
@@ -205,7 +205,7 @@ impl<'a> ArchiveBuilder<'a> {
     }
 
     /// Adds an arbitrary file to this archive
-    pub fn add_file(&mut self, file: &Path) -> io::IoResult<()> {
+    pub fn add_file(&mut self, file: &Path) -> old_io::IoResult<()> {
         let filename = Path::new(file.filename().unwrap());
         let new_file = self.work_dir.path().join(&filename);
         try!(fs::copy(file, &new_file));
@@ -274,8 +274,9 @@ impl<'a> ArchiveBuilder<'a> {
         self.archive
     }
 
-    fn add_archive<F>(&mut self, archive: &Path, name: &str, mut skip: F) -> io::IoResult<()> where
+    fn add_archive<F>(&mut self, archive: &Path, name: &str,
-        F: FnMut(&str) -> bool,
+                      mut skip: F) -> old_io::IoResult<()>
+        where F: FnMut(&str) -> bool,
     {
         let loc = TempDir::new("rsar").unwrap();
 

src/librustc_back/fs.rs

@@ -8,13 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::io;
+use std::old_io;
-use std::io::fs;
+use std::old_io::fs;
 use std::os;
 
 /// Returns an absolute path in the filesystem that `path` points to. The
 /// returned path does not contain any symlinks in its hierarchy.
-pub fn realpath(original: &Path) -> io::IoResult<Path> {
+pub fn realpath(original: &Path) -> old_io::IoResult<Path> {
     static MAX_LINKS_FOLLOWED: uint = 256;
     let original = os::make_absolute(original).unwrap();
 
@@ -32,12 +32,12 @@ pub fn realpath(original: &Path) -> io::IoResult<Path> {
 
         loop {
             if followed == MAX_LINKS_FOLLOWED {
-                return Err(io::standard_error(io::InvalidInput))
+                return Err(old_io::standard_error(old_io::InvalidInput))
             }
 
             match fs::lstat(&result) {
                 Err(..) => break,
-                Ok(ref stat) if stat.kind != io::FileType::Symlink => break,
+                Ok(ref stat) if stat.kind != old_io::FileType::Symlink => break,
                 Ok(..) => {
                     followed += 1;
                     let path = try!(fs::readlink(&result));
@@ -53,10 +53,10 @@ pub fn realpath(original: &Path) -> io::IoResult<Path> {
 
 #[cfg(all(not(windows), test))]
 mod test {
-    use std::io;
+    use std::old_io;
-    use std::io::fs::{File, symlink, mkdir, mkdir_recursive};
+    use std::old_io::fs::{File, symlink, mkdir, mkdir_recursive};
     use super::realpath;
-    use std::io::TempDir;
+    use std::old_io::TempDir;
 
     #[test]
     fn realpath_works() {
@@ -68,7 +68,7 @@ mod test {
         let linkdir = tmpdir.join("test3");
 
         File::create(&file).unwrap();
-        mkdir(&dir, io::USER_RWX).unwrap();
+        mkdir(&dir, old_io::USER_RWX).unwrap();
         symlink(&file, &link).unwrap();
         symlink(&dir, &linkdir).unwrap();
 
@@ -91,8 +91,8 @@ mod test {
         let e = d.join("e");
         let f = a.join("f");
 
-        mkdir_recursive(&b, io::USER_RWX).unwrap();
+        mkdir_recursive(&b, old_io::USER_RWX).unwrap();
-        mkdir_recursive(&d, io::USER_RWX).unwrap();
+        mkdir_recursive(&d, old_io::USER_RWX).unwrap();
         File::create(&f).unwrap();
         symlink(&Path::new("../d/e"), &c).unwrap();
         symlink(&Path::new("../f"), &e).unwrap();

src/librustc_back/rpath.rs

@@ -11,7 +11,7 @@
 
 use std::collections::HashSet;
 use std::os;
-use std::io::IoError;
+use std::old_io::IoError;
 use syntax::ast;
 
 pub struct RPathConfig<F, G> where

src/librustc_back/target/apple_ios_base.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::io::{Command, IoError, OtherIoError};
+use std::old_io::{Command, IoError, OtherIoError};
 use target::TargetOptions;
 
 use self::Arch::*;

src/librustc_back/target/i686_apple_darwin.rs

@@ -12,6 +12,7 @@ use target::Target;
 
 pub fn target() -> Target {
     let mut base = super::apple_base::opts();
+    base.cpu = "yonah".to_string();
     base.pre_link_args.push("-m32".to_string());
 
     Target {

src/librustc_back/target/i686_pc_windows_gnu.rs

@@ -12,6 +12,7 @@ use target::Target;
 
 pub fn target() -> Target {
     let mut options = super::windows_base::opts();
+    options.cpu = "pentium4".to_string();
 
     // Mark all dynamic libraries and executables as compatible with the larger 4GiB address
     // space available to x86 Windows binaries on x86_64.

src/librustc_back/target/i686_unknown_dragonfly.rs

@@ -12,6 +12,7 @@ use target::Target;
 
 pub fn target() -> Target {
     let mut base = super::dragonfly_base::opts();
+    base.cpu = "pentium4".to_string();
     base.pre_link_args.push("-m32".to_string());
 
     Target {

src/librustc_back/target/i686_unknown_linux_gnu.rs

@@ -12,6 +12,7 @@ use target::Target;
 
 pub fn target() -> Target {
     let mut base = super::linux_base::opts();
+    base.cpu = "pentium4".to_string();
     base.pre_link_args.push("-m32".to_string());
 
     Target {

src/librustc_back/target/mod.rs

@@ -48,7 +48,7 @@
 use serialize::json::Json;
 use syntax::{diagnostic, abi};
 use std::default::Default;
-use std::io::fs::PathExtensions;
+use std::old_io::fs::PathExtensions;
 
 mod windows_base;
 mod linux_base;
@@ -302,7 +302,7 @@ impl Target {
     /// JSON decoding.
     pub fn search(target: &str) -> Result<Target, String> {
         use std::os;
-        use std::io::File;
+        use std::old_io::File;
         use std::path::Path;
         use serialize::json;
 

src/librustc_back/target/x86_64_apple_darwin.rs

@@ -12,7 +12,7 @@ use target::Target;
 
 pub fn target() -> Target {
     let mut base = super::apple_base::opts();
-    base.cpu = "x86-64".to_string();
+    base.cpu = "core2".to_string();
     base.eliminate_frame_pointer = false;
     base.pre_link_args.push("-m64".to_string());
 

src/librustc_driver/driver.rs

@@ -30,8 +30,8 @@ use rustc_privacy;
 
 use serialize::json;
 
-use std::io;
+use std::old_io;
-use std::io::fs;
+use std::old_io::fs;
 use std::os;
 use syntax::ast;
 use syntax::ast_map;
@@ -100,6 +100,7 @@ pub fn compile_input(sess: Session,
                                                                  &id[]));
 
         let mut forest = ast_map::Forest::new(expanded_crate);
+        let arenas = ty::CtxtArenas::new();
         let ast_map = assign_node_ids_and_map(&sess, &mut forest);
 
         write_out_deps(&sess, input, &outputs, &id[]);
@@ -111,7 +112,6 @@ pub fn compile_input(sess: Session,
                                                                      &ast_map,
                                                                      &id[]));
 
-        let arenas = ty::CtxtArenas::new();
         let analysis = phase_3_run_analysis_passes(sess,
                                                    ast_map,
                                                    &arenas,
@@ -794,14 +794,14 @@ fn write_out_deps(sess: &Session,
         _ => return,
     };
 
-    let result = (|&:| -> io::IoResult<()> {
+    let result = (|&:| -> old_io::IoResult<()> {
         // Build a list of files used to compile the output and
         // write Makefile-compatible dependency rules
         let files: Vec<String> = sess.codemap().files.borrow()
                                    .iter().filter(|fmap| fmap.is_real_file())
                                    .map(|fmap| escape_dep_filename(&fmap.name[]))
                                    .collect();
-        let mut file = try!(io::File::create(&deps_filename));
+        let mut file = try!(old_io::File::create(&deps_filename));
         for path in out_filenames.iter() {
             try!(write!(&mut file as &mut Writer,
                           "{}: {}\n\n", path.display(), files.connect(" ")));

src/librustc_driver/lib.rs

@@ -73,7 +73,7 @@ use rustc::metadata::creader::CrateOrString::Str;
 use rustc::util::common::time;
 
 use std::cmp::Ordering::Equal;
-use std::io;
+use std::old_io;
 use std::iter::repeat;
 use std::os;
 use std::sync::mpsc::channel;
@@ -142,7 +142,7 @@ fn run_compiler(args: &[String]) {
         1u => {
             let ifile = &matches.free[0][];
             if ifile == "-" {
-                let contents = io::stdin().read_to_end().unwrap();
+                let contents = old_io::stdin().read_to_end().unwrap();
                 let src = String::from_utf8(contents).unwrap();
                 (Input::Str(src), None)
             } else {
@@ -196,7 +196,7 @@ fn run_compiler(args: &[String]) {
     if r.contains(&("ls".to_string())) {
         match input {
             Input::File(ref ifile) => {
-                let mut stdout = io::stdout();
+                let mut stdout = old_io::stdout();
                 list_metadata(&sess, &(*ifile), &mut stdout).unwrap();
             }
             Input::Str(_) => {
@@ -599,7 +599,7 @@ fn parse_crate_attrs(sess: &Session, input: &Input) ->
 }
 
 pub fn list_metadata(sess: &Session, path: &Path,
-                     out: &mut io::Writer) -> io::IoResult<()> {
+                     out: &mut old_io::Writer) -> old_io::IoResult<()> {
     metadata::loader::list_file_metadata(sess.target.target.options.is_like_osx, path, out)
 }
 
@@ -612,8 +612,8 @@ pub fn monitor<F:FnOnce()+Send>(f: F) {
     static STACK_SIZE: uint = 8 * 1024 * 1024; // 8MB
 
     let (tx, rx) = channel();
-    let w = io::ChanWriter::new(tx);
+    let w = old_io::ChanWriter::new(tx);
-    let mut r = io::ChanReader::new(rx);
+    let mut r = old_io::ChanReader::new(rx);
 
     let mut cfg = thread::Builder::new().name("rustc".to_string());
 
@@ -623,7 +623,7 @@ pub fn monitor<F:FnOnce()+Send>(f: F) {
         cfg = cfg.stack_size(STACK_SIZE);
     }
 
-    match cfg.scoped(move || { std::io::stdio::set_stderr(box w); f() }).join() {
+    match cfg.scoped(move || { std::old_io::stdio::set_stderr(box w); f() }).join() {
         Ok(()) => { /* fallthrough */ }
         Err(value) => {
             // Thread panicked without emitting a fatal diagnostic
@@ -665,7 +665,7 @@ pub fn monitor<F:FnOnce()+Send>(f: F) {
             // Panic so the process returns a failure code, but don't pollute the
             // output with some unnecessary panic messages, we've already
             // printed everything that we needed to.
-            io::stdio::set_stderr(box io::util::NullWriter);
+            old_io::stdio::set_stderr(box old_io::util::NullWriter);
             panic!();
         }
     }

src/librustc_driver/pretty.rs

@@ -38,7 +38,7 @@ use syntax::ptr::P;
 
 use graphviz as dot;
 
-use std::io::{self, MemReader};
+use std::old_io::{self, MemReader};
 use std::option;
 use std::str::FromStr;
 
@@ -208,7 +208,7 @@ impl<'ast> PrinterSupport<'ast> for IdentifiedAnnotation<'ast> {
 impl<'ast> pprust::PpAnn for IdentifiedAnnotation<'ast> {
     fn pre(&self,
            s: &mut pprust::State,
-           node: pprust::AnnNode) -> io::IoResult<()> {
+           node: pprust::AnnNode) -> old_io::IoResult<()> {
         match node {
             pprust::NodeExpr(_) => s.popen(),
             _ => Ok(())
@@ -216,7 +216,7 @@ impl<'ast> pprust::PpAnn for IdentifiedAnnotation<'ast> {
     }
     fn post(&self,
             s: &mut pprust::State,
-            node: pprust::AnnNode) -> io::IoResult<()> {
+            node: pprust::AnnNode) -> old_io::IoResult<()> {
         match node {
             pprust::NodeIdent(_) | pprust::NodeName(_) => Ok(()),
 
@@ -259,7 +259,7 @@ impl<'ast> PrinterSupport<'ast> for HygieneAnnotation<'ast> {
 impl<'ast> pprust::PpAnn for HygieneAnnotation<'ast> {
     fn post(&self,
             s: &mut pprust::State,
-            node: pprust::AnnNode) -> io::IoResult<()> {
+            node: pprust::AnnNode) -> old_io::IoResult<()> {
         match node {
             pprust::NodeIdent(&ast::Ident { name: ast::Name(nm), ctxt }) => {
                 try!(pp::space(&mut s.s));
@@ -294,7 +294,7 @@ impl<'tcx> PrinterSupport<'tcx> for TypedAnnotation<'tcx> {
 impl<'tcx> pprust::PpAnn for TypedAnnotation<'tcx> {
     fn pre(&self,
            s: &mut pprust::State,
-           node: pprust::AnnNode) -> io::IoResult<()> {
+           node: pprust::AnnNode) -> old_io::IoResult<()> {
         match node {
             pprust::NodeExpr(_) => s.popen(),
             _ => Ok(())
@@ -302,7 +302,7 @@ impl<'tcx> pprust::PpAnn for TypedAnnotation<'tcx> {
     }
     fn post(&self,
             s: &mut pprust::State,
-            node: pprust::AnnNode) -> io::IoResult<()> {
+            node: pprust::AnnNode) -> old_io::IoResult<()> {
         let tcx = &self.analysis.ty_cx;
         match node {
             pprust::NodeExpr(expr) => {
@@ -548,9 +548,9 @@ pub fn pretty_print_input(sess: Session,
     let mut rdr = MemReader::new(src);
 
     let out = match ofile {
-        None => box io::stdout() as Box<Writer+'static>,
+        None => box old_io::stdout() as Box<Writer+'static>,
         Some(p) => {
-            let r = io::File::create(&p);
+            let r = old_io::File::create(&p);
             match r {
                 Ok(w) => box w as Box<Writer+'static>,
                 Err(e) => panic!("print-print failed to open {} due to {}",
@@ -643,11 +643,11 @@ pub fn pretty_print_input(sess: Session,
     }.unwrap()
 }
 
-fn print_flowgraph<W:io::Writer>(variants: Vec<borrowck_dot::Variant>,
+fn print_flowgraph<W:old_io::Writer>(variants: Vec<borrowck_dot::Variant>,
                                  analysis: ty::CrateAnalysis,
                                  code: blocks::Code,
                                  mode: PpFlowGraphMode,
-                                 mut out: W) -> io::IoResult<()> {
+                                 mut out: W) -> old_io::IoResult<()> {
     let ty_cx = &analysis.ty_cx;
     let cfg = match code {
         blocks::BlockCode(block) => cfg::CFG::new(ty_cx, &*block),
@@ -687,11 +687,11 @@ fn print_flowgraph<W:io::Writer>(variants: Vec<borrowck_dot::Variant>,
         }
     }
 
-    fn expand_err_details(r: io::IoResult<()>) -> io::IoResult<()> {
+    fn expand_err_details(r: old_io::IoResult<()>) -> old_io::IoResult<()> {
         r.map_err(|ioerr| {
             let orig_detail = ioerr.detail.clone();
             let m = "graphviz::render failed";
-            io::IoError {
+            old_io::IoError {
                 detail: Some(match orig_detail {
                     None => m.to_string(),
                     Some(d) => format!("{}: {}", m, d)

src/librustc_driver/test.rs

@@ -103,7 +103,7 @@ fn test_env<F>(source_string: &str,
     let codemap =
         CodeMap::new();
     let diagnostic_handler =
-        diagnostic::mk_handler(emitter);
+        diagnostic::mk_handler(true, emitter);
     let span_diagnostic_handler =
         diagnostic::mk_span_handler(diagnostic_handler, codemap);
 
@@ -115,6 +115,7 @@ fn test_env<F>(source_string: &str,
                     .expect("phase 2 aborted");
 
     let mut forest = ast_map::Forest::new(krate);
+    let arenas = ty::CtxtArenas::new();
     let ast_map = driver::assign_node_ids_and_map(&sess, &mut forest);
     let krate = ast_map.krate();
 
@@ -125,7 +126,6 @@ fn test_env<F>(source_string: &str,
     let named_region_map = resolve_lifetime::krate(&sess, krate, &def_map);
     let region_map = region::resolve_crate(&sess, krate);
     let stability_index = stability::Index::build(&sess, krate);
-    let arenas = ty::CtxtArenas::new();
     let tcx = ty::mk_ctxt(sess,
                           &arenas,
                           def_map,

src/librustc_trans/back/link.rs

@@ -27,9 +27,9 @@ use util::common::time;
 use util::ppaux;
 use util::sha2::{Digest, Sha256};
 
-use std::io::fs::PathExtensions;
+use std::old_io::fs::PathExtensions;
-use std::io::{fs, TempDir, Command};
+use std::old_io::{fs, TempDir, Command};
-use std::io;
+use std::old_io;
 use std::mem;
 use std::str;
 use std::string::String;
@@ -425,7 +425,7 @@ pub fn invalid_output_for_target(sess: &Session,
 fn is_writeable(p: &Path) -> bool {
     match p.stat() {
         Err(..) => true,
-        Ok(m) => m.perm & io::USER_WRITE == io::USER_WRITE
+        Ok(m) => m.perm & old_io::USER_WRITE == old_io::USER_WRITE
     }
 }
 
@@ -586,8 +586,7 @@ fn link_rlib<'a>(sess: &'a Session,
             // the same filename for metadata (stomping over one another)
             let tmpdir = TempDir::new("rustc").ok().expect("needs a temp dir");
             let metadata = tmpdir.path().join(METADATA_FILENAME);
-            match fs::File::create(&metadata).write(&trans.metadata
+            match fs::File::create(&metadata).write_all(&trans.metadata[]) {
-                                                    []) {
                 Ok(..) => {}
                 Err(e) => {
                     sess.err(&format!("failed to write {}: {}",
@@ -671,13 +670,13 @@ fn link_rlib<'a>(sess: &'a Session,
 
 fn write_rlib_bytecode_object_v1<T: Writer>(writer: &mut T,
                                             bc_data_deflated: &[u8])
-                                         -> ::std::io::IoResult<()> {
+                                         -> ::std::old_io::IoResult<()> {
     let bc_data_deflated_size: u64 = bc_data_deflated.len() as u64;
 
-    try! { writer.write(RLIB_BYTECODE_OBJECT_MAGIC) };
+    try! { writer.write_all(RLIB_BYTECODE_OBJECT_MAGIC) };
     try! { writer.write_le_u32(1) };
     try! { writer.write_le_u64(bc_data_deflated_size) };
-    try! { writer.write(&bc_data_deflated[]) };
+    try! { writer.write_all(&bc_data_deflated[]) };
 
     let number_of_bytes_written_so_far =
         RLIB_BYTECODE_OBJECT_MAGIC.len() +                // magic id
@@ -1201,7 +1200,7 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session,
                 // Fix up permissions of the copy, as fs::copy() preserves
                 // permissions, but the original file may have been installed
                 // by a package manager and may be read-only.
-                match fs::chmod(&dst, io::USER_READ | io::USER_WRITE) {
+                match fs::chmod(&dst, old_io::USER_READ | old_io::USER_WRITE) {
                     Ok(..) => {}
                     Err(e) => {
                         sess.err(&format!("failed to chmod {} when preparing \

src/librustc_trans/back/write.rs

@@ -23,8 +23,8 @@ use syntax::diagnostic;
 use syntax::diagnostic::{Emitter, Handler, Level, mk_handler};
 
 use std::ffi::{self, CString};
-use std::io::Command;
+use std::old_io::Command;
-use std::io::fs;
+use std::old_io::fs;
 use std::iter::Unfold;
 use std::ptr;
 use std::str;
@@ -728,9 +728,9 @@ pub fn run_passes(sess: &Session,
             println!("{:?}", &cmd);
         }
 
-        cmd.stdin(::std::io::process::Ignored)
+        cmd.stdin(::std::old_io::process::Ignored)
-           .stdout(::std::io::process::InheritFd(1))
+           .stdout(::std::old_io::process::InheritFd(1))
-           .stderr(::std::io::process::InheritFd(2));
+           .stderr(::std::old_io::process::InheritFd(2));
         match cmd.status() {
             Ok(status) => {
                 if !status.success() {

src/librustc_trans/save/mod.rs

@@ -33,7 +33,7 @@ use middle::def;
 use middle::ty::{self, Ty};
 
 use std::cell::Cell;
-use std::io::{self, File, fs};
+use std::old_io::{self, File, fs};
 use std::os;
 
 use syntax::ast_util::{self, PostExpansionMethod};
@@ -1532,7 +1532,7 @@ pub fn process_crate(sess: &Session,
         },
     };
 
-    match fs::mkdir_recursive(&root_path, io::USER_RWX) {
+    match fs::mkdir_recursive(&root_path, old_io::USER_RWX) {
         Err(e) => sess.err(&format!("Could not create directory {}: {}",
                            root_path.display(), e)[]),
         _ => (),

src/librustc_trans/trans/base.rs

@@ -1784,15 +1784,16 @@ pub fn trans_closure<'a, 'b, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
     debug!("trans_closure(..., param_substs={})",
            param_substs.repr(ccx.tcx()));
 
-    let arena = TypedArena::new();
+    let (arena, fcx): (TypedArena<_>, FunctionContext);
-    let fcx = new_fn_ctxt(ccx,
+    arena = TypedArena::new();
-                          llfndecl,
+    fcx = new_fn_ctxt(ccx,
-                          fn_ast_id,
+                      llfndecl,
-                          closure_env.kind != closure::NotClosure,
+                      fn_ast_id,
-                          output_type,
+                      closure_env.kind != closure::NotClosure,
-                          param_substs,
+                      output_type,
-                          Some(body.span),
+                      param_substs,
-                          &arena);
+                      Some(body.span),
+                      &arena);
     let mut bcx = init_function(&fcx, false, output_type);
 
     // cleanup scope for the incoming arguments
@@ -2046,9 +2047,10 @@ fn trans_enum_variant_or_tuple_like_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx
                     ty_to_string(ccx.tcx(), ctor_ty))[])
     };
 
-    let arena = TypedArena::new();
+    let (arena, fcx): (TypedArena<_>, FunctionContext);
-    let fcx = new_fn_ctxt(ccx, llfndecl, ctor_id, false, result_ty,
+    arena = TypedArena::new();
-                          param_substs, None, &arena);
+    fcx = new_fn_ctxt(ccx, llfndecl, ctor_id, false, result_ty,
+                      param_substs, None, &arena);
     let bcx = init_function(&fcx, false, result_ty);
 
     assert!(!fcx.needs_ret_allocas);

src/librustc_trans/trans/callee.rs

@@ -322,16 +322,17 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>(
                               &function_name[]);
 
     //
-    let block_arena = TypedArena::new();
     let empty_substs = Substs::trans_empty();
-    let fcx = new_fn_ctxt(ccx,
+    let (block_arena, fcx): (TypedArena<_>, FunctionContext);
-                          llfn,
+    block_arena = TypedArena::new();
-                          ast::DUMMY_NODE_ID,
+    fcx = new_fn_ctxt(ccx,
-                          false,
+                      llfn,
-                          sig.output,
+                      ast::DUMMY_NODE_ID,
-                          &empty_substs,
+                      false,
-                          None,
+                      sig.output,
-                          &block_arena);
+                      &empty_substs,
+                      None,
+                      &block_arena);
     let mut bcx = init_function(&fcx, false, sig.output);
 
     // the first argument (`self`) will be ptr to the the fn pointer

src/librustc_trans/trans/glue.rs

@@ -540,11 +540,12 @@ fn make_generic_glue<'a, 'tcx, F>(ccx: &CrateContext<'a, 'tcx>,
     let glue_name = format!("glue {} {}", name, ty_to_short_str(ccx.tcx(), t));
     let _s = StatRecorder::new(ccx, glue_name);
 
-    let arena = TypedArena::new();
     let empty_param_substs = Substs::trans_empty();
-    let fcx = new_fn_ctxt(ccx, llfn, ast::DUMMY_NODE_ID, false,
+    let (arena, fcx): (TypedArena<_>, FunctionContext);
-                          ty::FnConverging(ty::mk_nil(ccx.tcx())),
+    arena = TypedArena::new();
-                          &empty_param_substs, None, &arena);
+    fcx = new_fn_ctxt(ccx, llfn, ast::DUMMY_NODE_ID, false,
+                      ty::FnConverging(ty::mk_nil(ccx.tcx())),
+                      &empty_param_substs, None, &arena);
 
     let bcx = init_function(&fcx, false, ty::FnConverging(ty::mk_nil(ccx.tcx())));
 

src/librustc_trans/trans/meth.rs

@@ -601,17 +601,17 @@ pub fn trans_object_shim<'a, 'tcx>(
 
     let sig = ty::erase_late_bound_regions(ccx.tcx(), &fty.sig);
 
-    //
-    let block_arena = TypedArena::new();
     let empty_substs = Substs::trans_empty();
-    let fcx = new_fn_ctxt(ccx,
+    let (block_arena, fcx): (TypedArena<_>, FunctionContext);
-                          llfn,
+    block_arena = TypedArena::new();
-                          ast::DUMMY_NODE_ID,
+    fcx = new_fn_ctxt(ccx,
-                          false,
+                      llfn,
-                          sig.output,
+                      ast::DUMMY_NODE_ID,
-                          &empty_substs,
+                      false,
-                          None,
+                      sig.output,
-                          &block_arena);
+                      &empty_substs,
+                      None,
+                      &block_arena);
     let mut bcx = init_function(&fcx, false, sig.output);
 
     // the first argument (`self`) will be a trait object

src/librustc_typeck/check/method/probe.rs

@@ -1049,8 +1049,8 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
         // if there are any.
         assert_eq!(substs.types.len(subst::FnSpace), 0);
         assert_eq!(substs.regions().len(subst::FnSpace), 0);
-        let mut substs = substs;
         let placeholder;
+        let mut substs = substs;
         if
             !method.generics.types.is_empty_in(subst::FnSpace) ||
             !method.generics.regions.is_empty_in(subst::FnSpace)

src/librustc_typeck/check/mod.rs

@@ -990,86 +990,65 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
     }
 }
 
-fn check_cast(fcx: &FnCtxt,
+fn report_cast_to_unsized_type<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
-              cast_expr: &ast::Expr,
+                                         span: Span,
-              e: &ast::Expr,
+                                         t_span: Span,
-              t: &ast::Ty) {
+                                         e_span: Span,
-    let id = cast_expr.id;
+                                         t_1: Ty<'tcx>,
-    let span = cast_expr.span;
+                                         t_e: Ty<'tcx>,
-
+                                         id: ast::NodeId) {
-    // Find the type of `e`. Supply hints based on the type we are casting to,
+    let tstr = fcx.infcx().ty_to_string(t_1);
-    // if appropriate.
+    fcx.type_error_message(span, |actual| {
-    let t_1 = fcx.to_ty(t);
+        format!("cast to unsized type: `{}` as `{}`", actual, tstr)
-    let t_1 = structurally_resolved_type(fcx, span, t_1);
+    }, t_e, None);
-
+    match t_e.sty {
-    check_expr_with_expectation(fcx, e, ExpectCastableToType(t_1));
+        ty::ty_rptr(_, ty::mt { mutbl: mt, .. }) => {
-
+            let mtstr = match mt {
-    let t_e = fcx.expr_ty(e);
+                ast::MutMutable => "mut ",
-
+                ast::MutImmutable => ""
-    debug!("t_1={}", fcx.infcx().ty_to_string(t_1));
+            };
-    debug!("t_e={}", fcx.infcx().ty_to_string(t_e));
+            if ty::type_is_trait(t_1) {
-
+                span_help!(fcx.tcx().sess, t_span, "did you mean `&{}{}`?", mtstr, tstr);
-    if ty::type_is_error(t_e) {
+            } else {
-        fcx.write_error(id);
+                span_help!(fcx.tcx().sess, span,
-        return
+                           "consider using an implicit coercion to `&{}{}` instead",
-    }
+                           mtstr, tstr);
-
-    if !fcx.type_is_known_to_be_sized(t_1, cast_expr.span) {
-        let tstr = fcx.infcx().ty_to_string(t_1);
-        fcx.type_error_message(span, |actual| {
-            format!("cast to unsized type: `{}` as `{}`", actual, tstr)
-        }, t_e, None);
-        match t_e.sty {
-            ty::ty_rptr(_, ty::mt { mutbl: mt, .. }) => {
-                let mtstr = match mt {
-                    ast::MutMutable => "mut ",
-                    ast::MutImmutable => ""
-                };
-                if ty::type_is_trait(t_1) {
-                    span_help!(fcx.tcx().sess, t.span, "did you mean `&{}{}`?", mtstr, tstr);
-                } else {
-                    span_help!(fcx.tcx().sess, span,
-                               "consider using an implicit coercion to `&{}{}` instead",
-                               mtstr, tstr);
-                }
-            }
-            ty::ty_uniq(..) => {
-                span_help!(fcx.tcx().sess, t.span, "did you mean `Box<{}>`?", tstr);
-            }
-            _ => {
-                span_help!(fcx.tcx().sess, e.span,
-                           "consider using a box or reference as appropriate");
             }
         }
-        fcx.write_error(id);
+        ty::ty_uniq(..) => {
-        return
+            span_help!(fcx.tcx().sess, t_span, "did you mean `Box<{}>`?", tstr);
+        }
+        _ => {
+            span_help!(fcx.tcx().sess, e_span,
+                       "consider using a box or reference as appropriate");
+        }
     }
+    fcx.write_error(id);
+}
 
-    if ty::type_is_trait(t_1) {
-        // This will be looked up later on.
-        vtable::check_object_cast(fcx, cast_expr, e, t_1);
-        fcx.write_ty(id, t_1);
-        return
-    }
 
-    let t_1 = structurally_resolved_type(fcx, span, t_1);
+fn check_cast_inner<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
-    let t_e = structurally_resolved_type(fcx, span, t_e);
+                              span: Span,
-
+                              t_1: Ty<'tcx>,
-    if ty::type_is_nil(t_e) {
+                              t_e: Ty<'tcx>,
+                              e: &ast::Expr) {
+    fn cast_through_integer_err<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
+                                          span: Span,
+                                          t_1: Ty<'tcx>,
+                                          t_e: Ty<'tcx>) {
         fcx.type_error_message(span, |actual| {
-            format!("cast from nil: `{}` as `{}`",
+            format!("illegal cast; cast through an \
-                    actual,
+                    integer first: `{}` as `{}`",
-                    fcx.infcx().ty_to_string(t_1))
-        }, t_e, None);
-    } else if ty::type_is_nil(t_1) {
-        fcx.type_error_message(span, |actual| {
-            format!("cast to nil: `{}` as `{}`",
                     actual,
                     fcx.infcx().ty_to_string(t_1))
         }, t_e, None);
     }
 
     let t_e_is_bare_fn_item = ty::type_is_bare_fn_item(t_e);
+    let t_e_is_scalar = ty::type_is_scalar(t_e);
+    let t_e_is_integral = ty::type_is_integral(t_e);
+    let t_e_is_float = ty::type_is_floating_point(t_e);
+    let t_e_is_c_enum = ty::type_is_c_like_enum(fcx.tcx(), t_e);
 
     let t_1_is_scalar = ty::type_is_scalar(t_1);
     let t_1_is_char = ty::type_is_char(t_1);
@@ -1078,18 +1057,9 @@ fn check_cast(fcx: &FnCtxt,
 
     // casts to scalars other than `char` and `bare fn` are trivial
     let t_1_is_trivial = t_1_is_scalar && !t_1_is_char && !t_1_is_bare_fn;
+
     if t_e_is_bare_fn_item && t_1_is_bare_fn {
         demand::coerce(fcx, e.span, t_1, &*e);
-    } else if ty::type_is_c_like_enum(fcx.tcx(), t_e) && t_1_is_trivial {
-        if t_1_is_float || ty::type_is_unsafe_ptr(t_1) {
-            fcx.type_error_message(span, |actual| {
-                format!("illegal cast; cast through an \
-                         integer first: `{}` as `{}`",
-                        actual,
-                        fcx.infcx().ty_to_string(t_1))
-            }, t_e, None);
-        }
-        // casts from C-like enums are allowed
     } else if t_1_is_char {
         let t_e = fcx.infcx().shallow_resolve(t_e);
         if t_e.sty != ty::ty_uint(ast::TyU8) {
@@ -1101,6 +1071,16 @@ fn check_cast(fcx: &FnCtxt,
     } else if t_1.sty == ty::ty_bool {
         span_err!(fcx.tcx().sess, span, E0054,
             "cannot cast as `bool`, compare with zero instead");
+    } else if t_1_is_float && (t_e_is_scalar || t_e_is_c_enum) && !(
+        t_e_is_integral || t_e_is_float || t_e.sty == ty::ty_bool) {
+        // Casts to float must go through an integer or boolean
+        cast_through_integer_err(fcx, span, t_1, t_e)
+    } else if t_e_is_c_enum && t_1_is_trivial {
+        if ty::type_is_unsafe_ptr(t_1) {
+            // ... and likewise with C enum -> *T
+            cast_through_integer_err(fcx, span, t_1, t_e)
+        }
+        // casts from C-like enums are allowed
     } else if ty::type_is_region_ptr(t_e) && ty::type_is_unsafe_ptr(t_1) {
         fn types_compatible<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, sp: Span,
                                       t1: Ty<'tcx>, t2: Ty<'tcx>) -> bool {
@@ -1142,7 +1122,7 @@ fn check_cast(fcx: &FnCtxt,
                 demand::coerce(fcx, e.span, t_1, &*e);
             }
         }
-    } else if !(ty::type_is_scalar(t_e) && t_1_is_trivial) {
+    } else if !(t_e_is_scalar && t_1_is_trivial) {
         /*
         If more type combinations should be supported than are
         supported here, then file an enhancement issue and
@@ -1153,15 +1133,49 @@ fn check_cast(fcx: &FnCtxt,
                     actual,
                     fcx.infcx().ty_to_string(t_1))
         }, t_e, None);
-    } else if ty::type_is_unsafe_ptr(t_e) && t_1_is_float {
+    }
-        fcx.type_error_message(span, |actual| {
+}
-            format!("cannot cast from pointer to float directly: `{}` as `{}`; cast through an \
+
-                     integer first",
+fn check_cast(fcx: &FnCtxt,
-                    actual,
+              cast_expr: &ast::Expr,
-                    fcx.infcx().ty_to_string(t_1))
+              e: &ast::Expr,
-        }, t_e, None);
+              t: &ast::Ty) {
+    let id = cast_expr.id;
+    let span = cast_expr.span;
+
+    // Find the type of `e`. Supply hints based on the type we are casting to,
+    // if appropriate.
+    let t_1 = fcx.to_ty(t);
+    let t_1 = structurally_resolved_type(fcx, span, t_1);
+
+    check_expr_with_expectation(fcx, e, ExpectCastableToType(t_1));
+
+    let t_e = fcx.expr_ty(e);
+
+    debug!("t_1={}", fcx.infcx().ty_to_string(t_1));
+    debug!("t_e={}", fcx.infcx().ty_to_string(t_e));
+
+    if ty::type_is_error(t_e) {
+        fcx.write_error(id);
+        return
     }
 
+    if !fcx.type_is_known_to_be_sized(t_1, cast_expr.span) {
+        report_cast_to_unsized_type(fcx, span, t.span, e.span, t_1, t_e, id);
+        return
+    }
+
+    if ty::type_is_trait(t_1) {
+        // This will be looked up later on.
+        vtable::check_object_cast(fcx, cast_expr, e, t_1);
+        fcx.write_ty(id, t_1);
+        return
+    }
+
+    let t_1 = structurally_resolved_type(fcx, span, t_1);
+    let t_e = structurally_resolved_type(fcx, span, t_e);
+
+    check_cast_inner(fcx, span, t_1, t_e, e);
     fcx.write_ty(id, t_1);
 }
 
@@ -3087,8 +3101,8 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
         let name = ident.get();
         // only find fits with at least one matching letter
         let mut best_dist = name.len();
-        let mut best = None;
         let fields = ty::lookup_struct_fields(tcx, id);
+        let mut best = None;
         for elem in fields.iter() {
             let n = elem.name.as_str();
             // ignore already set fields

src/librustdoc/core.rs

@@ -126,9 +126,9 @@ pub fn run_core(search_paths: SearchPaths, cfgs: Vec<String>, externs: Externs,
                     .expect("phase_2_configure_and_expand aborted in rustdoc!");
 
     let mut forest = ast_map::Forest::new(krate);
+    let arenas = ty::CtxtArenas::new();
     let ast_map = driver::assign_node_ids_and_map(&sess, &mut forest);
 
-    let arenas = ty::CtxtArenas::new();
     let ty::CrateAnalysis {
         exported_items, public_items, ty_cx, ..
     } = driver::phase_3_run_analysis_passes(sess,

src/librustdoc/externalfiles.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::{io, str};
+use std::{old_io, str};
 
 #[derive(Clone)]
 pub struct ExternalHtml{
@@ -33,8 +33,8 @@ impl ExternalHtml {
     }
 }
 
-pub fn load_string(input: &Path) -> io::IoResult<Option<String>> {
+pub fn load_string(input: &Path) -> old_io::IoResult<Option<String>> {
-    let mut f = try!(io::File::open(input));
+    let mut f = try!(old_io::File::open(input));
     let d = try!(f.read_to_end());
     Ok(str::from_utf8(d.as_slice()).map(|s| s.to_string()).ok())
 }
@@ -45,12 +45,12 @@ macro_rules! load_or_return {
             let input = Path::new($input);
             match ::externalfiles::load_string(&input) {
                 Err(e) => {
-                    let _ = writeln!(&mut io::stderr(),
+                    let _ = writeln!(&mut old_io::stderr(),
                                      "error reading `{}`: {}", input.display(), e);
                     return $cant_read;
                 }
                 Ok(None) => {
-                    let _ = writeln!(&mut io::stderr(),
+                    let _ = writeln!(&mut old_io::stderr(),
                                      "error reading `{}`: not UTF-8", input.display());
                     return $not_utf8;
                 }

src/librustdoc/html/highlight.rs

@@ -15,7 +15,7 @@
 
 use html::escape::Escape;
 
-use std::io;
+use std::old_io;
 use syntax::parse::lexer;
 use syntax::parse::token;
 use syntax::parse;
@@ -46,7 +46,7 @@ pub fn highlight(src: &str, class: Option<&str>, id: Option<&str>) -> String {
 /// source.
 fn doit(sess: &parse::ParseSess, mut lexer: lexer::StringReader,
         class: Option<&str>, id: Option<&str>,
-        out: &mut Writer) -> io::IoResult<()> {
+        out: &mut Writer) -> old_io::IoResult<()> {
     use syntax::parse::lexer::Reader;
 
     try!(write!(out, "<pre "));

src/librustdoc/html/layout.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use std::fmt;
-use std::io;
+use std::old_io;
 
 use externalfiles::ExternalHtml;
 
@@ -31,8 +31,8 @@ pub struct Page<'a> {
 }
 
 pub fn render<T: fmt::Display, S: fmt::Display>(
-    dst: &mut io::Writer, layout: &Layout, page: &Page, sidebar: &S, t: &T)
+    dst: &mut old_io::Writer, layout: &Layout, page: &Page, sidebar: &S, t: &T)
-    -> io::IoResult<()>
+    -> old_io::IoResult<()>
 {
     write!(dst,
 r##"<!DOCTYPE html>
@@ -159,7 +159,7 @@ r##"<!DOCTYPE html>
     )
 }
 
-pub fn redirect(dst: &mut io::Writer, url: &str) -> io::IoResult<()> {
+pub fn redirect(dst: &mut old_io::Writer, url: &str) -> old_io::IoResult<()> {
     // <script> triggers a redirect before refresh, so this is fine.
     write!(dst,
 r##"<!DOCTYPE html>

src/librustdoc/html/render.rs

@@ -39,9 +39,9 @@ use std::cmp::Ordering;
 use std::collections::{HashMap, HashSet};
 use std::default::Default;
 use std::fmt;
-use std::io::fs::PathExtensions;
+use std::old_io::fs::PathExtensions;
-use std::io::{fs, File, BufferedWriter, BufferedReader};
+use std::old_io::{fs, File, BufferedWriter, BufferedReader};
-use std::io;
+use std::old_io;
 use std::iter::repeat;
 use std::str;
 use std::sync::Arc;
@@ -257,7 +257,7 @@ thread_local!(pub static CURRENT_LOCATION_KEY: RefCell<Vec<String>> =
 pub fn run(mut krate: clean::Crate,
            external_html: &ExternalHtml,
            dst: Path,
-           passes: HashSet<String>) -> io::IoResult<()> {
+           passes: HashSet<String>) -> old_io::IoResult<()> {
     let mut cx = Context {
         dst: dst,
         src_root: krate.src.dir_path(),
@@ -391,7 +391,7 @@ pub fn run(mut krate: clean::Crate,
     cx.krate(krate, summary)
 }
 
-fn build_index(krate: &clean::Crate, cache: &mut Cache) -> io::IoResult<String> {
+fn build_index(krate: &clean::Crate, cache: &mut Cache) -> old_io::IoResult<String> {
     // Build the search index from the collected metadata
     let mut nodeid_to_pathid = HashMap::new();
     let mut pathid_to_nodeid = Vec::new();
@@ -485,7 +485,7 @@ fn build_index(krate: &clean::Crate, cache: &mut Cache) -> io::IoResult<String>
 fn write_shared(cx: &Context,
                 krate: &clean::Crate,
                 cache: &Cache,
-                search_index: String) -> io::IoResult<()> {
+                search_index: String) -> old_io::IoResult<()> {
     // Write out the shared files. Note that these are shared among all rustdoc
     // docs placed in the output directory, so this needs to be a synchronized
     // operation with respect to all other rustdocs running around.
@@ -517,7 +517,7 @@ fn write_shared(cx: &Context,
                include_bytes!("static/SourceCodePro-Semibold.woff")));
 
     fn collect(path: &Path, krate: &str,
-               key: &str) -> io::IoResult<Vec<String>> {
+               key: &str) -> old_io::IoResult<Vec<String>> {
         let mut ret = Vec::new();
         if path.exists() {
             for line in BufferedReader::new(File::open(path)).lines() {
@@ -607,7 +607,7 @@ fn write_shared(cx: &Context,
 }
 
 fn render_sources(cx: &mut Context,
-                  krate: clean::Crate) -> io::IoResult<clean::Crate> {
+                  krate: clean::Crate) -> old_io::IoResult<clean::Crate> {
     info!("emitting source files");
     let dst = cx.dst.join("src");
     try!(mkdir(&dst));
@@ -625,15 +625,15 @@ fn render_sources(cx: &mut Context,
 
 /// Writes the entire contents of a string to a destination, not attempting to
 /// catch any errors.
-fn write(dst: Path, contents: &[u8]) -> io::IoResult<()> {
+fn write(dst: Path, contents: &[u8]) -> old_io::IoResult<()> {
-    File::create(&dst).write(contents)
+    File::create(&dst).write_all(contents)
 }
 
 /// Makes a directory on the filesystem, failing the task if an error occurs and
 /// skipping if the directory already exists.
-fn mkdir(path: &Path) -> io::IoResult<()> {
+fn mkdir(path: &Path) -> old_io::IoResult<()> {
     if !path.exists() {
-        fs::mkdir(path, io::USER_RWX)
+        fs::mkdir(path, old_io::USER_RWX)
     } else {
         Ok(())
     }
@@ -736,7 +736,7 @@ impl<'a> DocFolder for SourceCollector<'a> {
 
 impl<'a> SourceCollector<'a> {
     /// Renders the given filename into its corresponding HTML source file.
-    fn emit_source(&mut self, filename: &str) -> io::IoResult<()> {
+    fn emit_source(&mut self, filename: &str) -> old_io::IoResult<()> {
         let p = Path::new(filename);
 
         // If we couldn't open this file, then just returns because it
@@ -1084,7 +1084,7 @@ impl Context {
     /// This currently isn't parallelized, but it'd be pretty easy to add
     /// parallelization to this function.
     fn krate(mut self, mut krate: clean::Crate,
-             stability: stability_summary::ModuleSummary) -> io::IoResult<()> {
+             stability: stability_summary::ModuleSummary) -> old_io::IoResult<()> {
         let mut item = match krate.module.take() {
             Some(i) => i,
             None => return Ok(())
@@ -1134,11 +1134,11 @@ impl Context {
     /// all sub-items which need to be rendered.
     ///
     /// The rendering driver uses this closure to queue up more work.
-    fn item<F>(&mut self, item: clean::Item, mut f: F) -> io::IoResult<()> where
+    fn item<F>(&mut self, item: clean::Item, mut f: F) -> old_io::IoResult<()> where
         F: FnMut(&mut Context, clean::Item),
     {
-        fn render(w: io::File, cx: &Context, it: &clean::Item,
+        fn render(w: old_io::File, cx: &Context, it: &clean::Item,
-                  pushname: bool) -> io::IoResult<()> {
+                  pushname: bool) -> old_io::IoResult<()> {
             info!("Rendering an item to {}", w.path().display());
             // A little unfortunate that this is done like this, but it sure
             // does make formatting *a lot* nicer.

src/librustdoc/lib.rs

@@ -49,8 +49,8 @@ extern crate "serialize" as rustc_serialize; // used by deriving
 
 use std::cell::RefCell;
 use std::collections::HashMap;
-use std::io::File;
+use std::old_io::File;
-use std::io;
+use std::old_io;
 use std::rc::Rc;
 use externalfiles::ExternalHtml;
 use serialize::Decodable;
@@ -487,7 +487,7 @@ fn json_input(input: &str) -> Result<Output, String> {
 /// Outputs the crate/plugin json as a giant json blob at the specified
 /// destination.
 fn json_output(krate: clean::Crate, res: Vec<plugins::PluginJson> ,
-               dst: Path) -> io::IoResult<()> {
+               dst: Path) -> old_io::IoResult<()> {
     // {
     //   "schema": version,
     //   "crate": { parsed crate ... },

src/librustdoc/markdown.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::io;
+use std::old_io;
 
 use core;
 use getopts;
@@ -59,9 +59,9 @@ pub fn render(input: &str, mut output: Path, matches: &getopts::Matches,
     }
     let playground = playground.unwrap_or("".to_string());
 
-    let mut out = match io::File::create(&output) {
+    let mut out = match old_io::File::create(&output) {
         Err(e) => {
-            let _ = writeln!(&mut io::stderr(),
+            let _ = writeln!(&mut old_io::stderr(),
                              "error opening `{}` for writing: {}",
                              output.display(), e);
             return 4;
@@ -71,7 +71,7 @@ pub fn render(input: &str, mut output: Path, matches: &getopts::Matches,
 
     let (metadata, text) = extract_leading_metadata(input_str.as_slice());
     if metadata.len() == 0 {
-        let _ = writeln!(&mut io::stderr(),
+        let _ = writeln!(&mut old_io::stderr(),
                          "invalid markdown file: expecting initial line with `% ...TITLE...`");
         return 5;
     }
@@ -126,7 +126,7 @@ pub fn render(input: &str, mut output: Path, matches: &getopts::Matches,
 
     match err {
         Err(e) => {
-            let _ = writeln!(&mut io::stderr(),
+            let _ = writeln!(&mut old_io::stderr(),
                              "error writing to `{}`: {}",
                              output.display(), e);
             6

src/librustdoc/test.rs

@@ -11,8 +11,8 @@
 use std::cell::RefCell;
 use std::sync::mpsc::channel;
 use std::dynamic_lib::DynamicLibrary;
-use std::io::{Command, TempDir};
+use std::old_io::{Command, TempDir};
-use std::io;
+use std::old_io;
 use std::os;
 use std::str;
 use std::thread::Thread;
@@ -145,20 +145,20 @@ fn runtest(test: &str, cratename: &str, libs: SearchPaths,
     // The basic idea is to not use a default_handler() for rustc, and then also
     // not print things by default to the actual stderr.
     let (tx, rx) = channel();
-    let w1 = io::ChanWriter::new(tx);
+    let w1 = old_io::ChanWriter::new(tx);
     let w2 = w1.clone();
-    let old = io::stdio::set_stderr(box w1);
+    let old = old_io::stdio::set_stderr(box w1);
     Thread::spawn(move |:| {
-        let mut p = io::ChanReader::new(rx);
+        let mut p = old_io::ChanReader::new(rx);
         let mut err = match old {
             Some(old) => {
                 // Chop off the `Send` bound.
                 let old: Box<Writer> = old;
                 old
             }
-            None => box io::stderr() as Box<Writer>,
+            None => box old_io::stderr() as Box<Writer>,
         };
-        io::util::copy(&mut p, &mut err).unwrap();
+        old_io::util::copy(&mut p, &mut err).unwrap();
     });
     let emitter = diagnostic::EmitterWriter::new(box w2, None);
 
@@ -200,7 +200,7 @@ fn runtest(test: &str, cratename: &str, libs: SearchPaths,
 
     match cmd.output() {
         Err(e) => panic!("couldn't run the test: {}{}", e,
-                        if e.kind == io::PermissionDenied {
+                        if e.kind == old_io::PermissionDenied {
                             " - maybe your tempdir is mounted with noexec?"
                         } else { "" }),
         Ok(out) => {

src/libserialize/json.rs

@@ -201,7 +201,7 @@ use self::InternalStackElement::*;
 
 use std;
 use std::collections::{HashMap, BTreeMap};
-use std::{char, f64, fmt, io, num, str};
+use std::{char, f64, fmt, old_io, num, str};
 use std::mem::{swap};
 use std::num::{Float, Int};
 use std::num::FpCategory as Fp;
@@ -260,7 +260,7 @@ pub enum ErrorCode {
 pub enum ParserError {
     /// msg, line, col
     SyntaxError(ErrorCode, uint, uint),
-    IoError(io::IoErrorKind, &'static str),
+    IoError(old_io::IoErrorKind, &'static str),
 }
 
 // Builder and Parser have the same errors.
@@ -331,7 +331,7 @@ impl fmt::Display for ErrorCode {
     }
 }
 
-fn io_error_to_error(io: io::IoError) -> ParserError {
+fn io_error_to_error(io: old_io::IoError) -> ParserError {
     IoError(io.kind, io.desc)
 }
 
@@ -2057,8 +2057,8 @@ impl<T: Iterator<Item=char>> Builder<T> {
     }
 }
 
-/// Decodes a json value from an `&mut io::Reader`
+/// Decodes a json value from an `&mut old_io::Reader`
-pub fn from_reader(rdr: &mut io::Reader) -> Result<Json, BuilderError> {
+pub fn from_reader(rdr: &mut old_io::Reader) -> Result<Json, BuilderError> {
     let contents = match rdr.read_to_end() {
         Ok(c)  => c,
         Err(e) => return Err(io_error_to_error(e))
@@ -2618,7 +2618,7 @@ mod tests {
     use super::JsonEvent::*;
     use super::{Json, from_str, DecodeResult, DecoderError, JsonEvent, Parser,
                 StackElement, Stack, Decoder, Encoder, EncoderError};
-    use std::{i64, u64, f32, f64, io};
+    use std::{i64, u64, f32, f64, old_io};
     use std::collections::BTreeMap;
     use std::num::Float;
     use std::string;
@@ -3456,7 +3456,7 @@ mod tests {
     #[test]
     fn test_encode_hashmap_with_numeric_key() {
         use std::str::from_utf8;
-        use std::io::Writer;
+        use std::old_io::Writer;
         use std::collections::HashMap;
         let mut hm: HashMap<uint, bool> = HashMap::new();
         hm.insert(1, true);
@@ -3472,7 +3472,7 @@ mod tests {
     #[test]
     fn test_prettyencode_hashmap_with_numeric_key() {
         use std::str::from_utf8;
-        use std::io::Writer;
+        use std::old_io::Writer;
         use std::collections::HashMap;
         let mut hm: HashMap<uint, bool> = HashMap::new();
         hm.insert(1, true);
@@ -3929,7 +3929,7 @@ mod tests {
     #[test]
     fn test_encode_hashmap_with_arbitrary_key() {
         use std::str::from_utf8;
-        use std::io::Writer;
+        use std::old_io::Writer;
         use std::collections::HashMap;
         use std::fmt;
         #[derive(PartialEq, Eq, Hash, RustcEncodable)]

src/libstd/failure.rs

@@ -14,12 +14,12 @@ use prelude::v1::*;
 
 use any::Any;
 use cell::RefCell;
-use io::IoResult;
+use old_io::IoResult;
 use rt::{backtrace, unwind};
 use rt::util::{Stderr, Stdio};
 use thread::Thread;
 
-// Defined in this module instead of io::stdio so that the unwinding
+// Defined in this module instead of old_io::stdio so that the unwinding
 thread_local! {
     pub static LOCAL_STDERR: RefCell<Option<Box<Writer + Send>>> = {
         RefCell::new(None)
@@ -27,7 +27,7 @@ thread_local! {
 }
 
 impl Writer for Stdio {
-    fn write(&mut self, bytes: &[u8]) -> IoResult<()> {
+    fn write_all(&mut self, bytes: &[u8]) -> IoResult<()> {
         let _ = self.write_bytes(bytes);
         Ok(())
     }

src/libstd/fmt.rs

@@ -238,7 +238,7 @@
 //!
 //! ```ignore
 //! format!      // described above
-//! write!       // first argument is a &mut io::Writer, the destination
+//! write!       // first argument is a &mut old_io::Writer, the destination
 //! writeln!     // same as write but appends a newline
 //! print!       // the format string is printed to the standard output
 //! println!     // same as print but appends a newline
@@ -255,10 +255,8 @@
 //!
 //! ```rust
 //! # #![allow(unused_must_use)]
-//! use std::io;
-//!
 //! let mut w = Vec::new();
-//! write!(&mut w as &mut io::Writer, "Hello {}!", "world");
+//! write!(&mut w, "Hello {}!", "world");
 //! ```
 //!
 //! #### `print!`
@@ -282,15 +280,15 @@
 //!
 //! ```
 //! use std::fmt;
-//! use std::io;
+//! use std::old_io;
 //!
 //! fmt::format(format_args!("this returns {}", "String"));
 //!
-//! let some_writer: &mut io::Writer = &mut io::stdout();
+//! let mut some_writer = old_io::stdout();
-//! write!(some_writer, "{}", format_args!("print with a {}", "macro"));
+//! write!(&mut some_writer, "{}", format_args!("print with a {}", "macro"));
 //!
 //! fn my_fmt_fn(args: fmt::Arguments) {
-//!     write!(&mut io::stdout(), "{}", args);
+//!     write!(&mut old_io::stdout(), "{}", args);
 //! }
 //! my_fmt_fn(format_args!("or a {} too", "function"));
 //! ```

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).
@@ -247,7 +248,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;
@@ -292,7 +293,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/macros.rs

@@ -81,14 +81,14 @@ macro_rules! format {
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
 macro_rules! print {
-    ($($arg:tt)*) => ($crate::io::stdio::print_args(format_args!($($arg)*)))
+    ($($arg:tt)*) => ($crate::old_io::stdio::print_args(format_args!($($arg)*)))
 }
 
 /// Macro for printing to a task's stdout handle.
 ///
-/// Each task can override its stdout handle via `std::io::stdio::set_stdout`.
+/// Each task can override its stdout handle via `std::old_io::stdio::set_stdout`.
 /// The syntax of this macro is the same as that used for `format!`. For more
-/// information, see `std::fmt` and `std::io::stdio`.
+/// information, see `std::fmt` and `std::old_io::stdio`.
 ///
 /// # Example
 ///
@@ -99,7 +99,7 @@ macro_rules! print {
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
 macro_rules! println {
-    ($($arg:tt)*) => ($crate::io::stdio::println_args(format_args!($($arg)*)))
+    ($($arg:tt)*) => ($crate::old_io::stdio::println_args(format_args!($($arg)*)))
 }
 
 /// Helper macro for unwrapping `Result` values while returning early with an

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);
@@ -184,7 +184,7 @@ impl<W: Writer> BufferedWriter<W> {
 
     fn flush_buf(&mut self) -> IoResult<()> {
         if self.pos != 0 {
-            let ret = self.inner.as_mut().unwrap().write(&self.buf[..self.pos]);
+            let ret = self.inner.as_mut().unwrap().write_all(&self.buf[..self.pos]);
             self.pos = 0;
             ret
         } else {
@@ -213,13 +213,13 @@ impl<W: Writer> BufferedWriter<W> {
 }
 
 impl<W: Writer> Writer for BufferedWriter<W> {
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> {
+    fn write_all(&mut self, buf: &[u8]) -> IoResult<()> {
         if self.pos + buf.len() > self.buf.len() {
             try!(self.flush_buf());
         }
 
         if buf.len() > self.buf.len() {
-            self.inner.as_mut().unwrap().write(buf)
+            self.inner.as_mut().unwrap().write_all(buf)
         } else {
             let dst = &mut self.buf[self.pos..];
             slice::bytes::copy_memory(dst, buf);
@@ -281,15 +281,15 @@ impl<W: Writer> LineBufferedWriter<W> {
 }
 
 impl<W: Writer> Writer for LineBufferedWriter<W> {
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> {
+    fn write_all(&mut self, buf: &[u8]) -> IoResult<()> {
         match buf.iter().rposition(|&b| b == b'\n') {
             Some(i) => {
-                try!(self.inner.write(&buf[..i + 1]));
+                try!(self.inner.write_all(&buf[..i + 1]));
                 try!(self.inner.flush());
-                try!(self.inner.write(&buf[i + 1..]));
+                try!(self.inner.write_all(&buf[i + 1..]));
                 Ok(())
             }
-            None => self.inner.write(buf),
+            None => self.inner.write_all(buf),
         }
     }
 
@@ -324,12 +324,12 @@ 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);
 ///
-/// stream.write("hello, world".as_bytes());
+/// stream.write_all("hello, world".as_bytes());
 /// stream.flush();
 ///
 /// let mut buf = [0; 100];
@@ -412,8 +412,8 @@ impl<S: Stream> Reader for BufferedStream<S> {
 }
 
 impl<S: Stream> Writer for BufferedStream<S> {
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> {
+    fn write_all(&mut self, buf: &[u8]) -> IoResult<()> {
-        self.inner.inner.get_mut().write(buf)
+        self.inner.inner.get_mut().write_all(buf)
     }
     fn flush(&mut self) -> IoResult<()> {
         self.inner.inner.get_mut().flush()
@@ -423,7 +423,7 @@ impl<S: Stream> Writer for BufferedStream<S> {
 #[cfg(test)]
 mod test {
     extern crate test;
-    use io;
+    use old_io;
     use prelude::v1::*;
     use super::*;
     use super::super::{IoResult, EndOfFile};
@@ -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_all(&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))
             }
@@ -503,34 +503,34 @@ mod test {
         let inner = Vec::new();
         let mut writer = BufferedWriter::with_capacity(2, inner);
 
-        writer.write(&[0, 1]).unwrap();
+        writer.write_all(&[0, 1]).unwrap();
         let b: &[_] = &[];
         assert_eq!(&writer.get_ref()[], b);
 
-        writer.write(&[2]).unwrap();
+        writer.write_all(&[2]).unwrap();
         let b: &[_] = &[0, 1];
         assert_eq!(&writer.get_ref()[], b);
 
-        writer.write(&[3]).unwrap();
+        writer.write_all(&[3]).unwrap();
         assert_eq!(&writer.get_ref()[], b);
 
         writer.flush().unwrap();
         let a: &[_] = &[0, 1, 2, 3];
         assert_eq!(a, &writer.get_ref()[]);
 
-        writer.write(&[4]).unwrap();
+        writer.write_all(&[4]).unwrap();
-        writer.write(&[5]).unwrap();
+        writer.write_all(&[5]).unwrap();
         assert_eq!(a, &writer.get_ref()[]);
 
-        writer.write(&[6]).unwrap();
+        writer.write_all(&[6]).unwrap();
         let a: &[_] = &[0, 1, 2, 3, 4, 5];
         assert_eq!(a, &writer.get_ref()[]);
 
-        writer.write(&[7, 8]).unwrap();
+        writer.write_all(&[7, 8]).unwrap();
         let a: &[_] = &[0, 1, 2, 3, 4, 5, 6];
         assert_eq!(a, &writer.get_ref()[]);
 
-        writer.write(&[9, 10, 11]).unwrap();
+        writer.write_all(&[9, 10, 11]).unwrap();
         let a: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
         assert_eq!(a, &writer.get_ref()[]);
 
@@ -541,7 +541,7 @@ mod test {
     #[test]
     fn test_buffered_writer_inner_flushes() {
         let mut w = BufferedWriter::with_capacity(3, Vec::new());
-        w.write(&[0, 1]).unwrap();
+        w.write_all(&[0, 1]).unwrap();
         let a: &[_] = &[];
         assert_eq!(a, &w.get_ref()[]);
         let w = w.into_inner();
@@ -555,20 +555,20 @@ 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_all(&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))
             }
         }
 
         let mut stream = BufferedStream::new(S);
         let mut buf = [];
         assert!(stream.read(&mut buf).is_err());
-        stream.write(&buf).unwrap();
+        stream.write_all(&buf).unwrap();
         stream.flush().unwrap();
     }
 
@@ -586,21 +586,21 @@ mod test {
     #[test]
     fn test_line_buffer() {
         let mut writer = LineBufferedWriter::new(Vec::new());
-        writer.write(&[0]).unwrap();
+        writer.write_all(&[0]).unwrap();
         let b: &[_] = &[];
         assert_eq!(&writer.get_ref()[], b);
-        writer.write(&[1]).unwrap();
+        writer.write_all(&[1]).unwrap();
         assert_eq!(&writer.get_ref()[], b);
         writer.flush().unwrap();
         let b: &[_] = &[0, 1];
         assert_eq!(&writer.get_ref()[], b);
-        writer.write(&[0, b'\n', 1, b'\n', 2]).unwrap();
+        writer.write_all(&[0, b'\n', 1, b'\n', 2]).unwrap();
         let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n'];
         assert_eq!(&writer.get_ref()[], b);
         writer.flush().unwrap();
         let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n', 2];
         assert_eq!(&writer.get_ref()[], b);
-        writer.write(&[3, b'\n']).unwrap();
+        writer.write_all(&[3, b'\n']).unwrap();
         let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n', 2, 3, b'\n'];
         assert_eq!(&writer.get_ref()[], b);
     }
@@ -663,8 +663,8 @@ mod test {
         struct FailFlushWriter;
 
         impl Writer for FailFlushWriter {
-            fn write(&mut self, _buf: &[u8]) -> IoResult<()> { Ok(()) }
+            fn write_all(&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);
@@ -142,10 +142,10 @@ impl Clone for ChanWriter {
 }
 
 impl Writer for ChanWriter {
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> {
+    fn write_all(&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
             }
@@ -160,7 +160,7 @@ mod test {
 
     use sync::mpsc::channel;
     use super::*;
-    use io;
+    use old_io;
     use thread::Thread;
 
     #[test]
@@ -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))
         }
     }
@@ -178,15 +178,15 @@ pub fn u64_from_be_bytes(data: &[u8], start: uint, size: uint) -> u64 {
 #[cfg(test)]
 mod test {
     use prelude::v1::*;
-    use io;
+    use old_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)
@@ -407,13 +407,13 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
 ///
 /// ```rust
 /// # #![allow(unused_must_use)]
-/// use std::io;
+/// use std::old_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))
@@ -469,11 +469,11 @@ pub fn readlink(path: &Path) -> IoResult<Path> {
 ///
 /// ```rust
 /// # #![allow(unused_must_use)]
-/// use std::io;
+/// use std::old_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;
+/// use std::old_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)
                 }
             },
@@ -719,7 +719,7 @@ impl Reader for File {
 }
 
 impl Writer for File {
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> {
+    fn write_all(&mut self, buf: &[u8]) -> IoResult<()> {
         self.fd.write(buf)
             .update_err("couldn't write to file",
                         |e| format!("{}; path={}", e, self.path.display()))
@@ -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 old_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
         })
@@ -43,7 +43,7 @@ fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64>
 
 impl Writer for Vec<u8> {
     #[inline]
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> {
+    fn write_all(&mut self, buf: &[u8]) -> IoResult<()> {
         self.push_all(buf);
         Ok(())
     }
@@ -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]);
@@ -101,7 +101,7 @@ impl MemWriter {
 
 impl Writer for MemWriter {
     #[inline]
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> {
+    fn write_all(&mut self, buf: &[u8]) -> IoResult<()> {
         self.buf.push_all(buf);
         Ok(())
     }
@@ -113,7 +113,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));
 ///
@@ -157,7 +157,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);
         {
@@ -191,7 +191,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))
         }
     }
 
@@ -202,7 +202,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());
         {
@@ -221,7 +221,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)
         }
@@ -243,7 +243,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];
 /// {
@@ -271,12 +271,12 @@ impl<'a> BufWriter<'a> {
 
 impl<'a> Writer for BufWriter<'a> {
     #[inline]
-    fn write(&mut self, src: &[u8]) -> IoResult<()> {
+    fn write_all(&mut self, src: &[u8]) -> IoResult<()> {
         let dst = &mut self.buf[self.pos..];
         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();
@@ -292,7 +292,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)))
         }
     }
 }
@@ -315,7 +315,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);
@@ -347,7 +347,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);
         {
@@ -381,7 +381,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))
         }
     }
 
@@ -392,10 +392,10 @@ 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;
+    use old_io;
     use iter::repeat;
     use self::test_crate::Bencher;
     use super::*;
@@ -434,8 +434,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);
@@ -478,7 +478,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");
+//!     file.write_all(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,14 +103,14 @@
 //!
 //!     ```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
 //!     # // just stop it running (#11576)
 //!     # if false {
 //!     let mut socket = TcpStream::connect("127.0.0.1:8080").unwrap();
-//!     socket.write(b"GET / HTTP/1.0\n\n");
+//!     socket.write_all(b"GET / HTTP/1.0\n\n");
 //!     let response = socket.read_to_end();
 //!     # }
 //!     ```
@@ -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");
@@ -156,7 +174,7 @@
 //!   to be 'unwrapped' before use.
 //!
 //! These features combine in the API to allow for expressions like
-//! `File::create(&Path::new("diary.txt")).write(b"Met a girl.\n")`
+//! `File::create(&Path::new("diary.txt")).write_all(b"Met a girl.\n")`
 //! without having to worry about whether "diary.txt" exists or whether
 //! the write succeeds. As written, if either `new` or `write_line`
 //! encounters an error then the result of the entire expression will
@@ -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") {
+//! match File::create(&Path::new("diary.txt")).write_all(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) {}
 ///
@@ -979,7 +997,12 @@ pub trait Writer {
     /// `Err`. Note that it is considered an error if the entire buffer could
     /// not be written, and if an error is returned then it is unknown how much
     /// data (if any) was actually written.
-    fn write(&mut self, buf: &[u8]) -> IoResult<()>;
+    fn write_all(&mut self, buf: &[u8]) -> IoResult<()>;
+
+    /// Deprecated, this method was renamed to `write_all`
+    #[unstable(feature = "io")]
+    #[deprecated(since = "1.0.0", reason = "renamed to `write_all`")]
+    fn write(&mut self, buf: &[u8]) -> IoResult<()> { self.write_all(buf) }
 
     /// Flush this output stream, ensuring that all intermediately buffered
     /// contents reach their destination.
@@ -1008,7 +1031,7 @@ pub trait Writer {
 
         impl<'a, T: ?Sized + Writer> fmt::Writer for Adaptor<'a, T> {
             fn write_str(&mut self, s: &str) -> fmt::Result {
-                match self.inner.write(s.as_bytes()) {
+                match self.inner.write_all(s.as_bytes()) {
                     Ok(()) => Ok(()),
                     Err(e) => {
                         self.error = Err(e);
@@ -1034,7 +1057,7 @@ pub trait Writer {
     /// converted byte-array instead.
     #[inline]
     fn write_str(&mut self, s: &str) -> IoResult<()> {
-        self.write(s.as_bytes())
+        self.write_all(s.as_bytes())
     }
 
     /// Writes a string into this sink, and then writes a literal newline (`\n`)
@@ -1046,7 +1069,7 @@ pub trait Writer {
     /// that the `write` method is used specifically instead.
     #[inline]
     fn write_line(&mut self, s: &str) -> IoResult<()> {
-        self.write_str(s).and_then(|()| self.write(&[b'\n']))
+        self.write_str(s).and_then(|()| self.write_all(&[b'\n']))
     }
 
     /// Write a single char, encoded as UTF-8.
@@ -1054,7 +1077,7 @@ pub trait Writer {
     fn write_char(&mut self, c: char) -> IoResult<()> {
         let mut buf = [0u8; 4];
         let n = c.encode_utf8(buf.as_mut_slice()).unwrap_or(0);
-        self.write(&buf[..n])
+        self.write_all(&buf[..n])
     }
 
     /// Write the result of passing n through `int::to_str_bytes`.
@@ -1072,61 +1095,61 @@ pub trait Writer {
     /// Write a little-endian uint (number of bytes depends on system).
     #[inline]
     fn write_le_uint(&mut self, n: uint) -> IoResult<()> {
-        extensions::u64_to_le_bytes(n as u64, uint::BYTES, |v| self.write(v))
+        extensions::u64_to_le_bytes(n as u64, uint::BYTES, |v| self.write_all(v))
     }
 
     /// Write a little-endian int (number of bytes depends on system).
     #[inline]
     fn write_le_int(&mut self, n: int) -> IoResult<()> {
-        extensions::u64_to_le_bytes(n as u64, int::BYTES, |v| self.write(v))
+        extensions::u64_to_le_bytes(n as u64, int::BYTES, |v| self.write_all(v))
     }
 
     /// Write a big-endian uint (number of bytes depends on system).
     #[inline]
     fn write_be_uint(&mut self, n: uint) -> IoResult<()> {
-        extensions::u64_to_be_bytes(n as u64, uint::BYTES, |v| self.write(v))
+        extensions::u64_to_be_bytes(n as u64, uint::BYTES, |v| self.write_all(v))
     }
 
     /// Write a big-endian int (number of bytes depends on system).
     #[inline]
     fn write_be_int(&mut self, n: int) -> IoResult<()> {
-        extensions::u64_to_be_bytes(n as u64, int::BYTES, |v| self.write(v))
+        extensions::u64_to_be_bytes(n as u64, int::BYTES, |v| self.write_all(v))
     }
 
     /// Write a big-endian u64 (8 bytes).
     #[inline]
     fn write_be_u64(&mut self, n: u64) -> IoResult<()> {
-        extensions::u64_to_be_bytes(n, 8u, |v| self.write(v))
+        extensions::u64_to_be_bytes(n, 8u, |v| self.write_all(v))
     }
 
     /// Write a big-endian u32 (4 bytes).
     #[inline]
     fn write_be_u32(&mut self, n: u32) -> IoResult<()> {
-        extensions::u64_to_be_bytes(n as u64, 4u, |v| self.write(v))
+        extensions::u64_to_be_bytes(n as u64, 4u, |v| self.write_all(v))
     }
 
     /// Write a big-endian u16 (2 bytes).
     #[inline]
     fn write_be_u16(&mut self, n: u16) -> IoResult<()> {
-        extensions::u64_to_be_bytes(n as u64, 2u, |v| self.write(v))
+        extensions::u64_to_be_bytes(n as u64, 2u, |v| self.write_all(v))
     }
 
     /// Write a big-endian i64 (8 bytes).
     #[inline]
     fn write_be_i64(&mut self, n: i64) -> IoResult<()> {
-        extensions::u64_to_be_bytes(n as u64, 8u, |v| self.write(v))
+        extensions::u64_to_be_bytes(n as u64, 8u, |v| self.write_all(v))
     }
 
     /// Write a big-endian i32 (4 bytes).
     #[inline]
     fn write_be_i32(&mut self, n: i32) -> IoResult<()> {
-        extensions::u64_to_be_bytes(n as u64, 4u, |v| self.write(v))
+        extensions::u64_to_be_bytes(n as u64, 4u, |v| self.write_all(v))
     }
 
     /// Write a big-endian i16 (2 bytes).
     #[inline]
     fn write_be_i16(&mut self, n: i16) -> IoResult<()> {
-        extensions::u64_to_be_bytes(n as u64, 2u, |v| self.write(v))
+        extensions::u64_to_be_bytes(n as u64, 2u, |v| self.write_all(v))
     }
 
     /// Write a big-endian IEEE754 double-precision floating-point (8 bytes).
@@ -1148,37 +1171,37 @@ pub trait Writer {
     /// Write a little-endian u64 (8 bytes).
     #[inline]
     fn write_le_u64(&mut self, n: u64) -> IoResult<()> {
-        extensions::u64_to_le_bytes(n, 8u, |v| self.write(v))
+        extensions::u64_to_le_bytes(n, 8u, |v| self.write_all(v))
     }
 
     /// Write a little-endian u32 (4 bytes).
     #[inline]
     fn write_le_u32(&mut self, n: u32) -> IoResult<()> {
-        extensions::u64_to_le_bytes(n as u64, 4u, |v| self.write(v))
+        extensions::u64_to_le_bytes(n as u64, 4u, |v| self.write_all(v))
     }
 
     /// Write a little-endian u16 (2 bytes).
     #[inline]
     fn write_le_u16(&mut self, n: u16) -> IoResult<()> {
-        extensions::u64_to_le_bytes(n as u64, 2u, |v| self.write(v))
+        extensions::u64_to_le_bytes(n as u64, 2u, |v| self.write_all(v))
     }
 
     /// Write a little-endian i64 (8 bytes).
     #[inline]
     fn write_le_i64(&mut self, n: i64) -> IoResult<()> {
-        extensions::u64_to_le_bytes(n as u64, 8u, |v| self.write(v))
+        extensions::u64_to_le_bytes(n as u64, 8u, |v| self.write_all(v))
     }
 
     /// Write a little-endian i32 (4 bytes).
     #[inline]
     fn write_le_i32(&mut self, n: i32) -> IoResult<()> {
-        extensions::u64_to_le_bytes(n as u64, 4u, |v| self.write(v))
+        extensions::u64_to_le_bytes(n as u64, 4u, |v| self.write_all(v))
     }
 
     /// Write a little-endian i16 (2 bytes).
     #[inline]
     fn write_le_i16(&mut self, n: i16) -> IoResult<()> {
-        extensions::u64_to_le_bytes(n as u64, 2u, |v| self.write(v))
+        extensions::u64_to_le_bytes(n as u64, 2u, |v| self.write_all(v))
     }
 
     /// Write a little-endian IEEE754 double-precision floating-point
@@ -1202,13 +1225,13 @@ pub trait Writer {
     /// Write a u8 (1 byte).
     #[inline]
     fn write_u8(&mut self, n: u8) -> IoResult<()> {
-        self.write(&[n])
+        self.write_all(&[n])
     }
 
     /// Write an i8 (1 byte).
     #[inline]
     fn write_i8(&mut self, n: i8) -> IoResult<()> {
-        self.write(&[n as u8])
+        self.write_all(&[n as u8])
     }
 }
 
@@ -1230,8 +1253,8 @@ impl<T: Writer> ByRefWriter for T {
 
 impl<'a> Writer for Box<Writer+'a> {
     #[inline]
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> {
+    fn write_all(&mut self, buf: &[u8]) -> IoResult<()> {
-        (&mut **self).write(buf)
+        (&mut **self).write_all(buf)
     }
 
     #[inline]
@@ -1242,7 +1265,7 @@ impl<'a> Writer for Box<Writer+'a> {
 
 impl<'a> Writer for &'a mut (Writer+'a) {
     #[inline]
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> { (**self).write(buf) }
+    fn write_all(&mut self, buf: &[u8]) -> IoResult<()> { (**self).write_all(buf) }
 
     #[inline]
     fn flush(&mut self) -> IoResult<()> { (**self).flush() }
@@ -1254,8 +1277,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) {}
 ///
@@ -1277,7 +1300,7 @@ pub struct RefWriter<'a, W:'a> {
 
 impl<'a, W: Writer> Writer for RefWriter<'a, W> {
     #[inline]
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> { self.inner.write(buf) }
+    fn write_all(&mut self, buf: &[u8]) -> IoResult<()> { self.inner.write_all(buf) }
 
     #[inline]
     fn flush(&mut self) -> IoResult<()> { self.inner.flush() }
@@ -1379,7 +1402,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 +1624,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);
@@ -1690,7 +1713,7 @@ pub enum FileType {
 ///
 /// ```no_run
 ///
-/// 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);
@@ -146,7 +146,7 @@ impl Reader for UnixStream {
 }
 
 impl Writer for UnixStream {
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> {
+    fn write_all(&mut self, buf: &[u8]) -> IoResult<()> {
         self.inner.write(buf)
     }
 }
@@ -173,8 +173,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);
@@ -275,11 +275,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");
@@ -134,8 +134,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;
     ///
@@ -262,7 +262,7 @@ impl Reader for TcpStream {
 }
 
 impl Writer for TcpStream {
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> {
+    fn write_all(&mut self, buf: &[u8]) -> IoResult<()> {
         self.inner.write(buf)
     }
 }
@@ -280,8 +280,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();
@@ -376,8 +376,8 @@ impl TcpAcceptor {
     /// # Example
     ///
     /// ```no_run
-    /// 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();
     ///
@@ -420,7 +420,7 @@ impl TcpAcceptor {
     /// # Example
     ///
     /// ```
-    /// 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();
@@ -488,13 +488,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) {
@@ -183,9 +183,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);
@@ -105,7 +105,7 @@ impl Reader for PipeStream {
 }
 
 impl Writer for PipeStream {
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> {
+    fn write_all(&mut self, buf: &[u8]) -> IoResult<()> {
         self.inner.write(buf)
     }
 }
@@ -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

@@ -20,9 +20,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;
@@ -57,7 +57,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,
@@ -158,7 +158,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,
@@ -358,7 +358,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,
@@ -379,7 +379,7 @@ impl Command {
     /// # Example
     ///
     /// ```
-    /// use std::io::Command;
+    /// use std::old_io::Command;
     ///
     /// let status = match Command::new("ls").status() {
     ///     Ok(status) => status,
@@ -582,7 +582,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,
             })
@@ -652,8 +652,8 @@ impl Process {
     /// # Example
     ///
     /// ```no_run
-    /// 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());
@@ -697,7 +697,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) => {
@@ -751,12 +751,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};
@@ -1078,13 +1078,13 @@ mod tests {
     #[test]
     fn test_override_env() {
         use os;
-        let mut new_env = vec![("RUN_TEST_NEW_ENV", "123")];
 
         // In some build environments (such as chrooted Nix builds), `env` can
         // only be found in the explicitly-provided PATH env variable, not in
         // default places such as /bin or /usr/bin. So we need to pass through
         // PATH to our sub-process.
         let path_val: String;
+        let mut new_env = vec![("RUN_TEST_NEW_ENV", "123")];
         match os::getenv("PATH") {
             None => {}
             Some(val) => {

src/libstd/old_io/result.rs

@@ -19,9 +19,9 @@ use result::Result::{Ok, Err};
 use super::{Reader, Writer, Listener, Acceptor, Seek, SeekStyle, IoResult};
 
 impl<W: Writer> Writer for IoResult<W> {
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> {
+    fn write_all(&mut self, buf: &[u8]) -> IoResult<()> {
         match *self {
-            Ok(ref mut writer) => writer.write(buf),
+            Ok(ref mut writer) => writer.write_all(buf),
             Err(ref e) => Err((*e).clone())
         }
     }
@@ -80,34 +80,34 @@ impl<T, A: Acceptor<T>> Acceptor<T> for IoResult<A> {
 mod test {
     use prelude::v1::*;
     use super::super::mem::*;
-    use io;
+    use old_io;
 
     #[test]
     fn test_option_writer() {
-        let mut writer: io::IoResult<Vec<u8>> = Ok(Vec::new());
+        let mut writer: old_io::IoResult<Vec<u8>> = Ok(Vec::new());
-        writer.write(&[0, 1, 2]).unwrap();
+        writer.write_all(&[0, 1, 2]).unwrap();
         writer.flush().unwrap();
         assert_eq!(writer.unwrap(), vec!(0, 1, 2));
     }
 
     #[test]
     fn test_option_writer_error() {
-        let mut writer: io::IoResult<Vec<u8>> =
+        let mut writer: old_io::IoResult<Vec<u8>> =
-            Err(io::standard_error(io::EndOfFile));
+            Err(old_io::standard_error(old_io::EndOfFile));
 
-        match writer.write(&[0, 0, 0]) {
+        match writer.write_all(&[0, 0, 0]) {
             Ok(..) => panic!(),
-            Err(e) => assert_eq!(e.kind, io::EndOfFile),
+            Err(e) => assert_eq!(e.kind, old_io::EndOfFile),
         }
         match writer.flush() {
             Ok(..) => panic!(),
-            Err(e) => assert_eq!(e.kind, io::EndOfFile),
+            Err(e) => assert_eq!(e.kind, old_io::EndOfFile),
         }
     }
 
     #[test]
     fn test_option_reader() {
-        let mut reader: io::IoResult<MemReader> =
+        let mut reader: old_io::IoResult<MemReader> =
             Ok(MemReader::new(vec!(0, 1, 2, 3)));
         let mut buf = [0, 0];
         reader.read(&mut buf).unwrap();
@@ -117,13 +117,13 @@ mod test {
 
     #[test]
     fn test_option_reader_error() {
-        let mut reader: io::IoResult<MemReader> =
+        let mut reader: old_io::IoResult<MemReader> =
-            Err(io::standard_error(io::EndOfFile));
+            Err(old_io::standard_error(old_io::EndOfFile));
         let mut buf = [];
 
         match reader.read(&mut buf) {
             Ok(..) => panic!(),
-            Err(e) => assert_eq!(e.kind, io::EndOfFile),
+            Err(e) => assert_eq!(e.kind, old_io::EndOfFile),
         }
     }
 }

src/libstd/old_io/stdio.rs

@@ -19,10 +19,10 @@
 //!
 //! ```rust
 //! # #![allow(unused_must_use)]
-//! use std::io;
+//! use std::old_io;
 //!
-//! let mut out = io::stdout();
+//! let mut out = old_io::stdout();
-//! out.write(b"Hello, world!");
+//! out.write_all(b"Hello, world!");
 //! ```
 
 use self::StdSource::*;
@@ -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;
@@ -141,9 +141,9 @@ impl StdinReader {
     /// # Examples
     ///
     /// ```rust
-    /// use std::io;
+    /// use std::old_io;
     ///
-    /// for line in io::stdin().lock().lines() {
+    /// for line in old_io::stdin().lock().lines() {
     ///     println!("{}", line.unwrap());
     /// }
     /// ```
@@ -370,14 +370,14 @@ pub fn flush() {
 /// Prints a string to the stdout of the current process. No newline is emitted
 /// after the string is printed.
 pub fn print(s: &str) {
-    with_task_stdout(|io| io.write(s.as_bytes()))
+    with_task_stdout(|io| io.write_all(s.as_bytes()))
 }
 
 /// Prints a string to the stdout of the current process. A literal
 /// `\n` character is printed to the console after the string.
 pub fn println(s: &str) {
     with_task_stdout(|io| {
-        io.write(s.as_bytes()).and_then(|()| io.write(&[b'\n']))
+        io.write_all(s.as_bytes()).and_then(|()| io.write_all(&[b'\n']))
     })
 }
 
@@ -498,7 +498,7 @@ impl StdWriter {
 }
 
 impl Writer for StdWriter {
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> {
+    fn write_all(&mut self, buf: &[u8]) -> IoResult<()> {
         // As with stdin on windows, stdout often can't handle writes of large
         // sizes. For an example, see #14940. For this reason, chunk the output
         // buffer on windows, but on unix we can just write the whole buffer all
@@ -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_all(&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,15 +143,15 @@ 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_all(&mut self, buf: &[u8]) -> old_io::IoResult<()> {
         for writer in self.writers.iter_mut() {
-            try!(writer.write(buf));
+            try!(writer.write_all(buf));
         }
         Ok(())
     }
 
     #[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,23 +221,23 @@ 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)
+            self.writer.write_all(&mut buf[..len]).map(|()| len)
         })
     }
 }
 
 /// 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]));
+        try!(w.write_all(&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,8 +275,8 @@ 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 old_io;
     use super::*;
 
     #[test]
@@ -321,7 +321,7 @@ mod test {
     fn test_null_writer() {
         let mut s = NullWriter;
         let buf = vec![0, 0, 0];
-        s.write(buf.as_slice()).unwrap();
+        s.write_all(buf.as_slice()).unwrap();
         s.flush().unwrap();
     }
 
@@ -347,12 +347,12 @@ mod test {
 
         struct TestWriter;
         impl Writer for TestWriter {
-            fn write(&mut self, _buf: &[u8]) -> io::IoResult<()> {
+            fn write_all(&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(())
             }
@@ -360,7 +360,7 @@ mod test {
 
         let mut multi = MultiWriter::new(vec!(box TestWriter as Box<Writer>,
                                               box TestWriter as Box<Writer>));
-        multi.write(&[1, 2, 3]).unwrap();
+        multi.write_all(&[1, 2, 3]).unwrap();
         assert_eq!(2, unsafe { writes });
         assert_eq!(0, unsafe { flushes });
         multi.flush().unwrap();
@@ -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]

src/libstd/os.rs

@@ -10,17 +10,19 @@
 
 //! Higher-level interfaces to libc::* functions and operating system services.
 //!
-//! In general these take and return rust types, use rust idioms (enums, closures, vectors) rather
+//! In general these take and return rust types, use rust idioms (enums,
-//! than C idioms, and do more extensive safety checks.
+//! closures, vectors) rather than C idioms, and do more extensive safety
+//! checks.
 //!
-//! This module is not meant to only contain 1:1 mappings to libc entries; any os-interface code
+//! This module is not meant to only contain 1:1 mappings to libc entries; any
-//! that is reasonably useful and broadly applicable can go here. Including utility routines that
+//! os-interface code that is reasonably useful and broadly applicable can go
-//! merely build on other os code.
+//! here. Including utility routines that merely build on other os code.
 //!
-//! We assume the general case is that users do not care, and do not want to be made to care, which
+//! We assume the general case is that users do not care, and do not want to be
-//! operating system they are on. While they may want to special case various special cases -- and
+//! made to care, which operating system they are on. While they may want to
-//! so we will not _hide_ the facts of which OS the user is on -- they should be given the
+//! special case various special cases -- and so we will not _hide_ the facts of
-//! opportunity to write OS-ignorant code by default.
+//! which OS the user is on -- they should be given the opportunity to write
+//! OS-ignorant code by default.
 
 #![unstable(feature = "os")]
 
@@ -35,7 +37,7 @@ use self::MapError::*;
 use clone::Clone;
 use error::{FromError, Error};
 use fmt;
-use io::{IoResult, IoError};
+use old_io::{IoResult, IoError};
 use iter::{Iterator, IteratorExt};
 use marker::{Copy, Send};
 use libc::{c_void, c_int, c_char};
@@ -374,7 +376,7 @@ pub struct Pipe {
 /// This function is also unsafe as there is no destructor associated with the
 /// `Pipe` structure will return. If it is not arranged for the returned file
 /// descriptors to be closed, the file descriptors will leak. For safe handling
-/// of this scenario, use `std::io::PipeStream` instead.
+/// of this scenario, use `std::old_io::PipeStream` instead.
 pub unsafe fn pipe() -> IoResult<Pipe> {
     let (reader, writer) = try!(sys::os::pipe());
     Ok(Pipe {
@@ -1635,10 +1637,10 @@ mod tests {
     fn memory_map_file() {
         use libc;
         use os::*;
-        use io::fs::{File, unlink};
+        use old_io::fs::{File, unlink};
-        use io::SeekStyle::SeekSet;
+        use old_io::SeekStyle::SeekSet;
-        use io::FileMode::Open;
+        use old_io::FileMode::Open;
-        use io::FileAccess::ReadWrite;
+        use old_io::FileAccess::ReadWrite;
 
         #[cfg(not(windows))]
         fn get_fd(file: &File) -> libc::c_int {

src/libstd/path/mod.rs

@@ -49,7 +49,7 @@
 //! ## Example
 //!
 //! ```rust
-//! use std::io::fs::PathExtensions;
+//! use std::old_io::fs::PathExtensions;
 //!
 //! let mut path = Path::new("/tmp/path");
 //! println!("path: {}", path.display());

src/libstd/path/posix.rs

@@ -14,7 +14,7 @@ use clone::Clone;
 use cmp::{Ordering, Eq, Ord, PartialEq, PartialOrd};
 use fmt;
 use hash;
-use io::Writer;
+use old_io::Writer;
 use iter::{AdditiveIterator, Extend};
 use iter::{Iterator, IteratorExt, Map};
 use marker::Sized;

src/libstd/path/windows.rs

@@ -20,7 +20,7 @@ use clone::Clone;
 use cmp::{Ordering, Eq, Ord, PartialEq, PartialOrd};
 use fmt;
 use hash;
-use io::Writer;
+use old_io::Writer;
 use iter::{AdditiveIterator, Extend};
 use iter::{Iterator, IteratorExt, Map, repeat};
 use mem;

src/libstd/prelude/v1.rs

@@ -62,6 +62,6 @@
 // NB: remove when path reform lands
 #[doc(no_inline)] pub use path::{Path, GenericPath};
 // NB: remove when I/O reform lands
-#[doc(no_inline)] pub use io::{Buffer, Writer, Reader, Seek, BufferPrelude};
+#[doc(no_inline)] pub use old_io::{Buffer, Writer, Reader, Seek, BufferPrelude};
 // NB: remove when range syntax lands
 #[doc(no_inline)] pub use iter::range;

src/libstd/rand/mod.rs

@@ -223,7 +223,7 @@
 
 use cell::RefCell;
 use clone::Clone;
-use io::IoResult;
+use old_io::IoResult;
 use iter::{Iterator, IteratorExt};
 use mem;
 use rc::Rc;

src/libstd/rand/os.rs

@@ -19,7 +19,7 @@ mod imp {
 
     use self::OsRngInner::*;
 
-    use io::{IoResult, File};
+    use old_io::{IoResult, File};
     use path::Path;
     use rand::Rng;
     use rand::reader::ReaderRng;
@@ -187,7 +187,7 @@ mod imp {
 mod imp {
     extern crate libc;
 
-    use io::{IoResult};
+    use old_io::{IoResult};
     use marker::Sync;
     use mem;
     use os;
@@ -259,7 +259,7 @@ mod imp {
 mod imp {
     extern crate libc;
 
-    use io::{IoResult, IoError};
+    use old_io::{IoResult, IoError};
     use mem;
     use ops::Drop;
     use os;

src/libstd/rand/reader.rs

@@ -10,7 +10,7 @@
 
 //! A wrapper around any Reader to treat it as an RNG.
 
-use io::Reader;
+use old_io::Reader;
 use rand::Rng;
 use result::Result::{Ok, Err};
 use slice::SliceExt;
@@ -26,7 +26,7 @@ use slice::SliceExt;
 ///
 /// ```rust
 /// use std::rand::{reader, Rng};
-/// use std::io::MemReader;
+/// use std::old_io::MemReader;
 ///
 /// let mut rng = reader::ReaderRng::new(MemReader::new(vec!(1,2,3,4,5,6,7,8)));
 /// println!("{:x}", rng.gen::<uint>());
@@ -77,7 +77,7 @@ mod test {
     use prelude::v1::*;
 
     use super::ReaderRng;
-    use io::MemReader;
+    use old_io::MemReader;
     use num::Int;
     use rand::Rng;
 

src/libstd/sync/mpsc/mod.rs

@@ -120,7 +120,7 @@
 //!
 //! ```no_run
 //! use std::sync::mpsc::channel;
-//! use std::io::timer::Timer;
+//! use std::old_io::timer::Timer;
 //! use std::time::Duration;
 //!
 //! let (tx, rx) = channel::<int>();
@@ -144,7 +144,7 @@
 //!
 //! ```no_run
 //! use std::sync::mpsc::channel;
-//! use std::io::timer::Timer;
+//! use std::old_io::timer::Timer;
 //! use std::time::Duration;
 //!
 //! let (tx, rx) = channel::<int>();

src/libstd/sys/common/backtrace.rs

@@ -10,7 +10,7 @@
 
 use prelude::v1::*;
 
-use io::IoResult;
+use old_io::IoResult;
 
 #[cfg(target_pointer_width = "64")]
 pub const HEX_WIDTH: uint = 18;

src/libstd/sys/common/mod.rs

@@ -11,7 +11,7 @@
 #![allow(missing_docs)]
 #![allow(dead_code)]
 
-use io::{self, IoError, IoResult};
+use old_io::{self, IoError, IoResult};
 use prelude::v1::*;
 use sys::{last_error, retry};
 use ffi::CString;
@@ -35,7 +35,7 @@ pub mod wtf8;
 
 pub fn eof() -> IoError {
     IoError {
-        kind: io::EndOfFile,
+        kind: old_io::EndOfFile,
         desc: "end of file",
         detail: None,
     }
@@ -43,7 +43,7 @@ pub fn eof() -> IoError {
 
 pub fn timeout(desc: &'static str) -> IoError {
     IoError {
-        kind: io::TimedOut,
+        kind: old_io::TimedOut,
         desc: desc,
         detail: None,
     }
@@ -51,7 +51,7 @@ pub fn timeout(desc: &'static str) -> IoError {
 
 pub fn short_write(n: uint, desc: &'static str) -> IoError {
     IoError {
-        kind: if n == 0 { io::TimedOut } else { io::ShortWrite(n) },
+        kind: if n == 0 { old_io::TimedOut } else { old_io::ShortWrite(n) },
         desc: desc,
         detail: None,
     }
@@ -59,7 +59,7 @@ pub fn short_write(n: uint, desc: &'static str) -> IoError {
 
 pub fn unimpl() -> IoError {
     IoError {
-        kind: io::IoUnavailable,
+        kind: old_io::IoUnavailable,
         desc: "operations not yet supported",
         detail: None,
     }

src/libstd/sys/common/net.rs

@@ -14,9 +14,9 @@ use self::InAddr::*;
 
 use ffi::CString;
 use ffi;
-use io::net::addrinfo;
+use old_io::net::addrinfo;
-use io::net::ip::{SocketAddr, IpAddr, Ipv4Addr, Ipv6Addr};
+use old_io::net::ip::{SocketAddr, IpAddr, Ipv4Addr, Ipv6Addr};
-use io::{IoResult, IoError};
+use old_io::{IoResult, IoError};
 use libc::{self, c_char, c_int};
 use mem;
 use num::Int;
@@ -28,7 +28,7 @@ use sys::{self, retry, c, sock_t, last_error, last_net_error, last_gai_error, cl
 use sync::{Arc, Mutex, MutexGuard};
 use sys_common::{self, keep_going, short_write, timeout};
 use cmp;
-use io;
+use old_io;
 
 // FIXME: move uses of Arc and deadline tracking to std::io
 
@@ -208,7 +208,7 @@ pub fn sockaddr_to_addr(storage: &libc::sockaddr_storage,
         }
         _ => {
             Err(IoError {
-                kind: io::InvalidInput,
+                kind: old_io::InvalidInput,
                 desc: "invalid argument",
                 detail: None,
             })
@@ -458,7 +458,7 @@ pub fn write<T, L, W>(fd: sock_t,
             // As with read(), first wait for the socket to be ready for
             // the I/O operation.
             match await(&[fd], deadline, Writable) {
-                Err(ref e) if e.kind == io::EndOfFile && written > 0 => {
+                Err(ref e) if e.kind == old_io::EndOfFile && written > 0 => {
                     assert!(deadline.is_some());
                     return Err(short_write(written, "short write"))
                 }

src/libstd/sys/unix/backtrace.rs

@@ -86,7 +86,7 @@
 use prelude::v1::*;
 
 use ffi;
-use io::IoResult;
+use old_io::IoResult;
 use libc;
 use mem;
 use str;
@@ -136,7 +136,7 @@ pub fn write(w: &mut Writer) -> IoResult<()> {
 #[inline(never)] // if we know this is a function call, we can skip it when
                  // tracing
 pub fn write(w: &mut Writer) -> IoResult<()> {
-    use io::IoError;
+    use old_io::IoError;
 
     struct Context<'a> {
         idx: int,
@@ -375,7 +375,7 @@ fn output(w: &mut Writer, idx: int, addr: *mut libc::c_void,
         Some(string) => try!(demangle(w, string)),
         None => try!(write!(w, "<unknown>")),
     }
-    w.write(&['\n' as u8])
+    w.write_all(&['\n' as u8])
 }
 
 /// Unwind library interface used for backtraces

src/libstd/sys/unix/ext.rs

@@ -18,7 +18,7 @@
 //! ```rust,ignore
 //! #![feature(globs)]
 //!
-//! use std::io::fs::File;
+//! use std::old_io::fs::File;
 //! use std::os::unix::prelude::*;
 //!
 //! fn main() {
@@ -37,7 +37,7 @@ use sys_common::{AsInner, IntoInner, FromInner};
 use ffi::{OsStr, OsString};
 use libc;
 
-use io;
+use old_io;
 
 /// Raw file descriptors.
 pub type Fd = libc::c_int;
@@ -48,55 +48,55 @@ pub trait AsRawFd {
     fn as_raw_fd(&self) -> Fd;
 }
 
-impl AsRawFd for io::fs::File {
+impl AsRawFd for old_io::fs::File {
     fn as_raw_fd(&self) -> Fd {
         self.as_inner().fd()
     }
 }
 
-impl AsRawFd for io::pipe::PipeStream {
+impl AsRawFd for old_io::pipe::PipeStream {
     fn as_raw_fd(&self) -> Fd {
         self.as_inner().fd()
     }
 }
 
-impl AsRawFd for io::net::pipe::UnixStream {
+impl AsRawFd for old_io::net::pipe::UnixStream {
     fn as_raw_fd(&self) -> Fd {
         self.as_inner().fd()
     }
 }
 
-impl AsRawFd for io::net::pipe::UnixListener {
+impl AsRawFd for old_io::net::pipe::UnixListener {
     fn as_raw_fd(&self) -> Fd {
         self.as_inner().fd()
     }
 }
 
-impl AsRawFd for io::net::pipe::UnixAcceptor {
+impl AsRawFd for old_io::net::pipe::UnixAcceptor {
     fn as_raw_fd(&self) -> Fd {
         self.as_inner().fd()
     }
 }
 
-impl AsRawFd for io::net::tcp::TcpStream {
+impl AsRawFd for old_io::net::tcp::TcpStream {
     fn as_raw_fd(&self) -> Fd {
         self.as_inner().fd()
     }
 }
 
-impl AsRawFd for io::net::tcp::TcpListener {
+impl AsRawFd for old_io::net::tcp::TcpListener {
     fn as_raw_fd(&self) -> Fd {
         self.as_inner().fd()
     }
 }
 
-impl AsRawFd for io::net::tcp::TcpAcceptor {
+impl AsRawFd for old_io::net::tcp::TcpAcceptor {
     fn as_raw_fd(&self) -> Fd {
         self.as_inner().fd()
     }
 }
 
-impl AsRawFd for io::net::udp::UdpSocket {
+impl AsRawFd for old_io::net::udp::UdpSocket {
     fn as_raw_fd(&self) -> Fd {
         self.as_inner().fd()
     }