Auto merge of #21919 - alexcrichton:rollup, r=alexcrichton

33 files changed, 5165 insertions, 40 deletions

diff --git a/src/libstd/env.rs b/src/libstd/env.rs
index 5070f8c547a..559a68542ef 100644
--- a/src/libstd/env.rs
+++ b/src/libstd/env.rs
@@ -57,7 +57,7 @@ pub fn current_dir() -> IoResult<Path> {
 ///
 /// ```rust
 /// use std::env;
-/// use std::path::Path;
+/// use std::old_path::Path;
 ///
 /// let root = Path::new("/");
 /// assert!(env::set_current_dir(&root).is_ok());
diff --git a/src/libstd/ffi/mod.rs b/src/libstd/ffi/mod.rs
index 76f925a23f1..07a4f17796c 100644
--- a/src/libstd/ffi/mod.rs
+++ b/src/libstd/ffi/mod.rs
@@ -24,6 +24,7 @@ pub use self::os_str::OsStr;
 mod c_str;
 mod os_str;
 
+// FIXME (#21670): these should be defined in the os_str module
 /// Freely convertible to an `&OsStr` slice.
 pub trait AsOsStr {
     /// Convert to an `&OsStr` slice.
diff --git a/src/libstd/ffi/os_str.rs b/src/libstd/ffi/os_str.rs
index b8d770e6ad6..4d7292b6eb4 100644
--- a/src/libstd/ffi/os_str.rs
+++ b/src/libstd/ffi/os_str.rs
@@ -41,7 +41,7 @@ use string::{String, CowString};
 use ops;
 use cmp;
 use hash::{Hash, Hasher, Writer};
-use path::{Path, GenericPath};
+use old_path::{Path, GenericPath};
 
 use sys::os_str::{Buf, Slice};
 use sys_common::{AsInner, IntoInner, FromInner};
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
new file mode 100644
index 00000000000..2fd6631ecc4
--- /dev/null
+++ b/src/libstd/io/buffered.rs
@@ -0,0 +1,676 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+//
+// ignore-lexer-test FIXME #15883
+
+//! Buffering wrappers for I/O traits
+
+use prelude::v1::*;
+use io::prelude::*;
+
+use cmp;
+use error::Error as StdError;
+use error::FromError;
+use fmt;
+use io::{self, Cursor, DEFAULT_BUF_SIZE, Error, ErrorKind};
+use ptr;
+
+/// Wraps a `Read` and buffers input from it
+///
+/// It can be excessively inefficient to work directly with a `Read` instance.
+/// For example, every call to `read` on `TcpStream` results in a system call.
+/// A `BufReader` performs large, infrequent reads on the underlying `Read`
+/// and maintains an in-memory buffer of the results.
+pub struct BufReader<R> {
+    inner: R,
+    buf: Cursor<Vec<u8>>,
+}
+
+impl<R: Read> BufReader<R> {
+    /// Creates a new `BufReader` with a default buffer capacity
+    pub fn new(inner: R) -> BufReader<R> {
+        BufReader::with_capacity(DEFAULT_BUF_SIZE, inner)
+    }
+
+    /// Creates a new `BufReader` with the specified buffer capacity
+    pub fn with_capacity(cap: usize, inner: R) -> BufReader<R> {
+        BufReader {
+            inner: inner,
+            buf: Cursor::new(Vec::with_capacity(cap)),
+        }
+    }
+
+    /// Gets a reference to the underlying reader.
+    pub fn get_ref<'a>(&self) -> &R { &self.inner }
+
+    /// Gets a mutable reference to the underlying reader.
+    ///
+    /// # Warning
+    ///
+    /// It is inadvisable to directly read from the underlying reader.
+    pub fn get_mut(&mut self) -> &mut R { &mut self.inner }
+
+    /// Unwraps this `BufReader`, returning the underlying reader.
+    ///
+    /// Note that any leftover data in the internal buffer is lost.
+    pub fn into_inner(self) -> R { self.inner }
+}
+
+impl<R: Read> Read for BufReader<R> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        // If we don't have any buffered data and we're doing a massive read
+        // (larger than our internal buffer), bypass our internal buffer
+        // entirely.
+        if self.buf.get_ref().len() == self.buf.position() as usize &&
+            buf.len() >= self.buf.get_ref().capacity() {
+            return self.inner.read(buf);
+        }
+        try!(self.fill_buf());
+        self.buf.read(buf)
+    }
+}
+
+impl<R: Read> BufRead for BufReader<R> {
+    fn fill_buf(&mut self) -> io::Result<&[u8]> {
+        // If we've reached the end of our internal buffer then we need to fetch
+        // some more data from the underlying reader.
+        if self.buf.position() as usize == self.buf.get_ref().len() {
+            self.buf.set_position(0);
+            let v = self.buf.get_mut();
+            v.truncate(0);
+            let inner = &mut self.inner;
+            try!(super::with_end_to_cap(v, |b| inner.read(b)));
+        }
+        self.buf.fill_buf()
+    }
+
+    fn consume(&mut self, amt: uint) {
+        self.buf.consume(amt)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<R> fmt::Debug for BufReader<R> where R: fmt::Debug {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "BufReader {{ reader: {:?}, buffer: {}/{} }}",
+               self.inner, self.buf.position(), self.buf.get_ref().len())
+    }
+}
+
+/// Wraps a Writer and buffers output to it
+///
+/// It can be excessively inefficient to work directly with a `Write`. For
+/// example, every call to `write` on `TcpStream` results in a system call. A
+/// `BufWriter` keeps an in memory buffer of data and writes it to the
+/// underlying `Write` in large, infrequent batches.
+///
+/// This writer will be flushed when it is dropped.
+pub struct BufWriter<W> {
+    inner: Option<W>,
+    buf: Vec<u8>,
+}
+
+/// An error returned by `into_inner` which indicates whether a flush error
+/// happened or not.
+#[derive(Debug)]
+pub struct IntoInnerError<W>(W, Error);
+
+impl<W: Write> BufWriter<W> {
+    /// Creates a new `BufWriter` with a default buffer capacity
+    pub fn new(inner: W) -> BufWriter<W> {
+        BufWriter::with_capacity(DEFAULT_BUF_SIZE, inner)
+    }
+
+    /// Creates a new `BufWriter` with the specified buffer capacity
+    pub fn with_capacity(cap: usize, inner: W) -> BufWriter<W> {
+        BufWriter {
+            inner: Some(inner),
+            buf: Vec::with_capacity(cap),
+        }
+    }
+
+    fn flush_buf(&mut self) -> io::Result<()> {
+        let mut written = 0;
+        let len = self.buf.len();
+        let mut ret = Ok(());
+        while written < len {
+            match self.inner.as_mut().unwrap().write(&self.buf[written..]) {
+                Ok(0) => {
+                    ret = Err(Error::new(ErrorKind::WriteZero,
+                                         "failed to flush", None));
+                    break;
+                }
+                Ok(n) => written += n,
+                Err(e) => { ret = Err(e); break }
+
+            }
+        }
+        if written > 0 {
+            // NB: would be better expressed as .remove(0..n) if it existed
+            unsafe {
+                ptr::copy_memory(self.buf.as_mut_ptr(),
+                                 self.buf.as_ptr().offset(written as isize),
+                                 len - written);
+            }
+        }
+        self.buf.truncate(len - written);
+        ret
+    }
+
+    /// Gets a reference to the underlying writer.
+    pub fn get_ref(&self) -> &W { self.inner.as_ref().unwrap() }
+
+    /// Gets a mutable reference to the underlying write.
+    ///
+    /// # Warning
+    ///
+    /// It is inadvisable to directly read from the underlying writer.
+    pub fn get_mut(&mut self) -> &mut W { self.inner.as_mut().unwrap() }
+
+    /// Unwraps this `BufWriter`, returning the underlying writer.
+    ///
+    /// The buffer is flushed before returning the writer.
+    pub fn into_inner(mut self) -> Result<W, IntoInnerError<BufWriter<W>>> {
+        match self.flush_buf() {
+            Err(e) => Err(IntoInnerError(self, e)),
+            Ok(()) => Ok(self.inner.take().unwrap())
+        }
+    }
+}
+
+impl<W: Write> Write for BufWriter<W> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        if self.buf.len() + buf.len() > self.buf.capacity() {
+            try!(self.flush_buf());
+        }
+        if buf.len() >= self.buf.capacity() {
+            self.inner.as_mut().unwrap().write(buf)
+        } else {
+            let amt = cmp::min(buf.len(), self.buf.capacity());
+            Write::write(&mut self.buf, &buf[..amt])
+        }
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        self.flush_buf().and_then(|()| self.get_mut().flush())
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<W> fmt::Debug for BufWriter<W> where W: fmt::Debug {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "BufWriter {{ writer: {:?}, buffer: {}/{} }}",
+               self.inner.as_ref().unwrap(), self.buf.len(), self.buf.capacity())
+    }
+}
+
+#[unsafe_destructor]
+impl<W: Write> Drop for BufWriter<W> {
+    fn drop(&mut self) {
+        if self.inner.is_some() {
+            // dtors should not panic, so we ignore a failed flush
+            let _r = self.flush_buf();
+        }
+    }
+}
+
+impl<W> IntoInnerError<W> {
+    /// Returns the error which caused the call to `into_inner` to fail.
+    ///
+    /// This error was returned when attempting to flush the internal buffer.
+    pub fn error(&self) -> &Error { &self.1 }
+
+    /// Returns the underlying `BufWriter` instance which generated the error.
+    ///
+    /// The returned object can be used to retry a flush or re-inspect the
+    /// buffer.
+    pub fn into_inner(self) -> W { self.0 }
+}
+
+impl<W> FromError<IntoInnerError<W>> for Error {
+    fn from_error(iie: IntoInnerError<W>) -> Error { iie.1 }
+}
+
+impl<W> StdError for IntoInnerError<W> {
+    fn description(&self) -> &str { self.error().description() }
+}
+
+impl<W> fmt::Display for IntoInnerError<W> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.error().fmt(f)
+    }
+}
+
+/// Wraps a Writer and buffers output to it, flushing whenever a newline
+/// (`0x0a`, `'\n'`) is detected.
+///
+/// This writer will be flushed when it is dropped.
+pub struct LineWriter<W> {
+    inner: BufWriter<W>,
+}
+
+impl<W: Write> LineWriter<W> {
+    /// Creates a new `LineWriter`
+    pub fn new(inner: W) -> LineWriter<W> {
+        // Lines typically aren't that long, don't use a giant buffer
+        LineWriter { inner: BufWriter::with_capacity(1024, inner) }
+    }
+
+    /// Gets a reference to the underlying writer.
+    ///
+    /// This type does not expose the ability to get a mutable reference to the
+    /// underlying reader because that could possibly corrupt the buffer.
+    pub fn get_ref<'a>(&'a self) -> &'a W { self.inner.get_ref() }
+
+    /// Unwraps this `LineWriter`, returning the underlying writer.
+    ///
+    /// The internal buffer is flushed before returning the writer.
+    pub fn into_inner(self) -> Result<W, IntoInnerError<LineWriter<W>>> {
+        self.inner.into_inner().map_err(|IntoInnerError(buf, e)| {
+            IntoInnerError(LineWriter { inner: buf }, e)
+        })
+    }
+}
+
+impl<W: Write> Write for LineWriter<W> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        match buf.rposition_elem(&b'\n') {
+            Some(i) => {
+                let n = try!(self.inner.write(&buf[..i + 1]));
+                if n != i + 1 { return Ok(n) }
+                try!(self.inner.flush());
+                self.inner.write(&buf[i + 1..]).map(|i| n + i)
+            }
+            None => self.inner.write(buf),
+        }
+    }
+
+    fn flush(&mut self) -> io::Result<()> { self.inner.flush() }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<W> fmt::Debug for LineWriter<W> where W: fmt::Debug {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "LineWriter {{ writer: {:?}, buffer: {}/{} }}",
+               self.inner.inner, self.inner.buf.len(),
+               self.inner.buf.capacity())
+    }
+}
+
+struct InternalBufWriter<W>(BufWriter<W>);
+
+impl<W> InternalBufWriter<W> {
+    fn get_mut(&mut self) -> &mut BufWriter<W> {
+        let InternalBufWriter(ref mut w) = *self;
+        return w;
+    }
+}
+
+impl<W: Read> Read for InternalBufWriter<W> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        self.get_mut().inner.as_mut().unwrap().read(buf)
+    }
+}
+
+/// Wraps a Stream and buffers input and output to and from it.
+///
+/// It can be excessively inefficient to work directly with a `Stream`. For
+/// example, every call to `read` or `write` on `TcpStream` results in a system
+/// call. A `BufStream` keeps in memory buffers of data, making large,
+/// infrequent calls to `read` and `write` on the underlying `Stream`.
+///
+/// The output half will be flushed when this stream is dropped.
+pub struct BufStream<S> {
+    inner: BufReader<InternalBufWriter<S>>
+}
+
+impl<S: Read + Write> BufStream<S> {
+    /// Creates a new buffered stream with explicitly listed capacities for the
+    /// reader/writer buffer.
+    pub fn with_capacities(reader_cap: usize, writer_cap: usize, inner: S)
+                           -> BufStream<S> {
+        let writer = BufWriter::with_capacity(writer_cap, inner);
+        let internal_writer = InternalBufWriter(writer);
+        let reader = BufReader::with_capacity(reader_cap, internal_writer);
+        BufStream { inner: reader }
+    }
+
+    /// Creates a new buffered stream with the default reader/writer buffer
+    /// capacities.
+    pub fn new(inner: S) -> BufStream<S> {
+        BufStream::with_capacities(DEFAULT_BUF_SIZE, DEFAULT_BUF_SIZE, inner)
+    }
+
+    /// Gets a reference to the underlying stream.
+    pub fn get_ref(&self) -> &S {
+        let InternalBufWriter(ref w) = self.inner.inner;
+        w.get_ref()
+    }
+
+    /// Gets a mutable reference to the underlying stream.
+    ///
+    /// # Warning
+    ///
+    /// It is inadvisable to read directly from or write directly to the
+    /// underlying stream.
+    pub fn get_mut(&mut self) -> &mut S {
+        let InternalBufWriter(ref mut w) = self.inner.inner;
+        w.get_mut()
+    }
+
+    /// Unwraps this `BufStream`, returning the underlying stream.
+    ///
+    /// The internal buffer is flushed before returning the stream. Any leftover
+    /// data in the read buffer is lost.
+    pub fn into_inner(self) -> Result<S, IntoInnerError<BufStream<S>>> {
+        let BufReader { inner: InternalBufWriter(w), buf } = self.inner;
+        w.into_inner().map_err(|IntoInnerError(w, e)| {
+            IntoInnerError(BufStream {
+                inner: BufReader { inner: InternalBufWriter(w), buf: buf },
+            }, e)
+        })
+    }
+}
+
+impl<S: Read + Write> BufRead for BufStream<S> {
+    fn fill_buf(&mut self) -> io::Result<&[u8]> { self.inner.fill_buf() }
+    fn consume(&mut self, amt: uint) { self.inner.consume(amt) }
+}
+
+impl<S: Read + Write> Read for BufStream<S> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        self.inner.read(buf)
+    }
+}
+
+impl<S: Read + Write> Write for BufStream<S> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.inner.inner.get_mut().write(buf)
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        self.inner.inner.get_mut().flush()
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<S> fmt::Debug for BufStream<S> where S: fmt::Debug {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        let reader = &self.inner;
+        let writer = &self.inner.inner.0;
+        write!(fmt, "BufStream {{ stream: {:?}, write_buffer: {}/{}, read_buffer: {}/{} }}",
+               writer.inner,
+               writer.buf.len(), writer.buf.capacity(),
+               reader.buf.position(), reader.buf.get_ref().len())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use prelude::v1::*;
+    use io::prelude::*;
+    use io::{self, BufReader, BufWriter, BufStream, Cursor, LineWriter};
+    use test;
+
+    /// A dummy reader intended at testing short-reads propagation.
+    pub struct ShortReader {
+        lengths: Vec<usize>,
+    }
+
+    impl Read for ShortReader {
+        fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
+            if self.lengths.is_empty() {
+                Ok(0)
+            } else {
+                Ok(self.lengths.remove(0))
+            }
+        }
+    }
+
+    #[test]
+    fn test_buffered_reader() {
+        let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
+        let mut reader = BufReader::with_capacity(2, inner);
+
+        let mut buf = [0, 0, 0];
+        let nread = reader.read(&mut buf);
+        assert_eq!(Ok(3), nread);
+        let b: &[_] = &[5, 6, 7];
+        assert_eq!(buf, b);
+
+        let mut buf = [0, 0];
+        let nread = reader.read(&mut buf);
+        assert_eq!(Ok(2), nread);
+        let b: &[_] = &[0, 1];
+        assert_eq!(buf, b);
+
+        let mut buf = [0];
+        let nread = reader.read(&mut buf);
+        assert_eq!(Ok(1), nread);
+        let b: &[_] = &[2];
+        assert_eq!(buf, b);
+
+        let mut buf = [0, 0, 0];
+        let nread = reader.read(&mut buf);
+        assert_eq!(Ok(1), nread);
+        let b: &[_] = &[3, 0, 0];
+        assert_eq!(buf, b);
+
+        let nread = reader.read(&mut buf);
+        assert_eq!(Ok(1), nread);
+        let b: &[_] = &[4, 0, 0];
+        assert_eq!(buf, b);
+
+        assert_eq!(reader.read(&mut buf), Ok(0));
+    }
+
+    #[test]
+    fn test_buffered_writer() {
+        let inner = Vec::new();
+        let mut writer = BufWriter::with_capacity(2, inner);
+
+        writer.write(&[0, 1]).unwrap();
+        assert_eq!(*writer.get_ref(), [0, 1]);
+
+        writer.write(&[2]).unwrap();
+        assert_eq!(*writer.get_ref(), [0, 1]);
+
+        writer.write(&[3]).unwrap();
+        assert_eq!(*writer.get_ref(), [0, 1]);
+
+        writer.flush().unwrap();
+        assert_eq!(*writer.get_ref(), [0, 1, 2, 3]);
+
+        writer.write(&[4]).unwrap();
+        writer.write(&[5]).unwrap();
+        assert_eq!(*writer.get_ref(), [0, 1, 2, 3]);
+
+        writer.write(&[6]).unwrap();
+        assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5]);
+
+        writer.write(&[7, 8]).unwrap();
+        assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8]);
+
+        writer.write(&[9, 10, 11]).unwrap();
+        let a: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+        assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
+
+        writer.flush().unwrap();
+        assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
+    }
+
+    #[test]
+    fn test_buffered_writer_inner_flushes() {
+        let mut w = BufWriter::with_capacity(3, Vec::new());
+        w.write(&[0, 1]).unwrap();
+        assert_eq!(*w.get_ref(), []);
+        let w = w.into_inner().unwrap();
+        assert_eq!(w, [0, 1]);
+    }
+
+    // This is just here to make sure that we don't infinite loop in the
+    // newtype struct autoderef weirdness
+    #[test]
+    fn test_buffered_stream() {
+        struct S;
+
+        impl Write for S {
+            fn write(&mut self, b: &[u8]) -> io::Result<usize> { Ok(b.len()) }
+            fn flush(&mut self) -> io::Result<()> { Ok(()) }
+        }
+
+        impl Read for S {
+            fn read(&mut self, _: &mut [u8]) -> io::Result<usize> { Ok(0) }
+        }
+
+        let mut stream = BufStream::new(S);
+        assert_eq!(stream.read(&mut [0; 10]), Ok(0));
+        stream.write(&[0; 10]).unwrap();
+        stream.flush().unwrap();
+    }
+
+    #[test]
+    fn test_read_until() {
+        let inner: &[u8] = &[0, 1, 2, 1, 0];
+        let mut reader = BufReader::with_capacity(2, inner);
+        let mut v = Vec::new();
+        reader.read_until(0, &mut v).unwrap();
+        assert_eq!(v, [0]);
+        v.truncate(0);
+        reader.read_until(2, &mut v).unwrap();
+        assert_eq!(v, [1, 2]);
+        v.truncate(0);
+        reader.read_until(1, &mut v).unwrap();
+        assert_eq!(v, [1]);
+        v.truncate(0);
+        reader.read_until(8, &mut v).unwrap();
+        assert_eq!(v, [0]);
+        v.truncate(0);
+        reader.read_until(9, &mut v).unwrap();
+        assert_eq!(v, []);
+    }
+
+    #[test]
+    fn test_line_buffer() {
+        let mut writer = LineWriter::new(Vec::new());
+        writer.write(&[0]).unwrap();
+        assert_eq!(*writer.get_ref(), []);
+        writer.write(&[1]).unwrap();
+        assert_eq!(*writer.get_ref(), []);
+        writer.flush().unwrap();
+        assert_eq!(*writer.get_ref(), [0, 1]);
+        writer.write(&[0, b'\n', 1, b'\n', 2]).unwrap();
+        assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n']);
+        writer.flush().unwrap();
+        assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n', 2]);
+        writer.write(&[3, b'\n']).unwrap();
+        assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n', 2, 3, b'\n']);
+    }
+
+    #[test]
+    fn test_read_line() {
+        let in_buf = b"a\nb\nc";
+        let mut reader = BufReader::with_capacity(2, in_buf);
+        let mut s = String::new();
+        reader.read_line(&mut s).unwrap();
+        assert_eq!(s, "a\n");
+        s.truncate(0);
+        reader.read_line(&mut s).unwrap();
+        assert_eq!(s, "b\n");
+        s.truncate(0);
+        reader.read_line(&mut s).unwrap();
+        assert_eq!(s, "c");
+        s.truncate(0);
+        reader.read_line(&mut s).unwrap();
+        assert_eq!(s, "");
+    }
+
+    #[test]
+    fn test_lines() {
+        let in_buf = b"a\nb\nc";
+        let mut reader = BufReader::with_capacity(2, in_buf);
+        let mut it = reader.lines();
+        assert_eq!(it.next(), Some(Ok("a".to_string())));
+        assert_eq!(it.next(), Some(Ok("b".to_string())));
+        assert_eq!(it.next(), Some(Ok("c".to_string())));
+        assert_eq!(it.next(), None);
+    }
+
+    #[test]
+    fn test_short_reads() {
+        let inner = ShortReader{lengths: vec![0, 1, 2, 0, 1, 0]};
+        let mut reader = BufReader::new(inner);
+        let mut buf = [0, 0];
+        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert_eq!(reader.read(&mut buf), Ok(1));
+        assert_eq!(reader.read(&mut buf), Ok(2));
+        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert_eq!(reader.read(&mut buf), Ok(1));
+        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert_eq!(reader.read(&mut buf), Ok(0));
+    }
+
+    #[test]
+    fn read_char_buffered() {
+        let buf = [195u8, 159u8];
+        let mut reader = BufReader::with_capacity(1, &buf[]);
+        assert_eq!(reader.chars().next(), Some(Ok('ß')));
+    }
+
+    #[test]
+    fn test_chars() {
+        let buf = [195u8, 159u8, b'a'];
+        let mut reader = BufReader::with_capacity(1, &buf[]);
+        let mut it = reader.chars();
+        assert_eq!(it.next(), Some(Ok('ß')));
+        assert_eq!(it.next(), Some(Ok('a')));
+        assert_eq!(it.next(), None);
+    }
+
+    #[test]
+    #[should_fail]
+    fn dont_panic_in_drop_on_panicked_flush() {
+        struct FailFlushWriter;
+
+        impl Write for FailFlushWriter {
+            fn write(&mut self, buf: &[u8]) -> io::Result<usize> { Ok(buf.len()) }
+            fn flush(&mut self) -> io::Result<()> {
+                Err(io::Error::last_os_error())
+            }
+        }
+
+        let writer = FailFlushWriter;
+        let _writer = BufWriter::new(writer);
+
+        // If writer panics *again* due to the flush error then the process will
+        // abort.
+        panic!();
+    }
+
+    #[bench]
+    fn bench_buffered_reader(b: &mut test::Bencher) {
+        b.iter(|| {
+            BufReader::new(io::empty())
+        });
+    }
+
+    #[bench]
+    fn bench_buffered_writer(b: &mut test::Bencher) {
+        b.iter(|| {
+            BufWriter::new(io::sink())
+        });
+    }
+
+    #[bench]
+    fn bench_buffered_stream(b: &mut test::Bencher) {
+        let mut buf = Cursor::new(Vec::new());
+        b.iter(|| {
+            BufStream::new(&mut buf);
+        });
+    }
+}
diff --git a/src/libstd/io/cursor.rs b/src/libstd/io/cursor.rs
new file mode 100644
index 00000000000..9f3655de20f
--- /dev/null
+++ b/src/libstd/io/cursor.rs
@@ -0,0 +1,408 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(missing_copy_implementations)]
+
+use prelude::v1::*;
+use io::prelude::*;
+
+use cmp;
+use io::{self, SeekFrom, Error, ErrorKind};
+use iter::repeat;
+use num::Int;
+use slice;
+
+/// A `Cursor` is a type which wraps another I/O object to provide a `Seek`
+/// implementation.
+///
+/// Cursors are currently typically used with memory buffer objects in order to
+/// allow `Seek` plus `Read` and `Write` implementations. For example, common
+/// cursor types include:
+///
+/// * `Cursor<Vec<u8>>`
+/// * `Cursor<&[u8]>`
+///
+/// Implementations of the I/O traits for `Cursor<T>` are not currently generic
+/// over `T` itself. Instead, specific implementations are provided for various
+/// in-memory buffer types like `Vec<u8>` and `&[u8]`.
+pub struct Cursor<T> {
+    inner: T,
+    pos: u64,
+}
+
+impl<T> Cursor<T> {
+    /// Create a new cursor wrapping the provided underlying I/O object.
+    pub fn new(inner: T) -> Cursor<T> {
+        Cursor { pos: 0, inner: inner }
+    }
+
+    /// Consume this cursor, returning the underlying value.
+    pub fn into_inner(self) -> T { self.inner }
+
+    /// Get a reference to the underlying value in this cursor.
+    pub fn get_ref(&self) -> &T { &self.inner }
+
+    /// Get a mutable reference to the underlying value in this cursor.
+    ///
+    /// Care should be taken to avoid modifying the internal I/O state of the
+    /// underlying value as it may corrupt this cursor's position.
+    pub fn get_mut(&mut self) -> &mut T { &mut self.inner }
+
+    /// Returns the current value of this cursor
+    pub fn position(&self) -> u64 { self.pos }
+
+    /// Sets the value of this cursor
+    pub fn set_position(&mut self, pos: u64) { self.pos = pos; }
+}
+
+macro_rules! seek {
+    () => {
+        fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
+            let pos = match style {
+                SeekFrom::Start(n) => { self.pos = n; return Ok(n) }
+                SeekFrom::End(n) => self.inner.len() as i64 + n,
+                SeekFrom::Current(n) => self.pos as i64 + n,
+            };
+
+            if pos < 0 {
+                Err(Error::new(ErrorKind::InvalidInput,
+                               "invalid seek to a negative position",
+                               None))
+            } else {
+                self.pos = pos as u64;
+                Ok(self.pos)
+            }
+        }
+    }
+}
+
+impl<'a> io::Seek for Cursor<&'a [u8]> { seek!(); }
+impl<'a> io::Seek for Cursor<&'a mut [u8]> { seek!(); }
+impl io::Seek for Cursor<Vec<u8>> { seek!(); }
+
+macro_rules! read {
+    () => {
+        fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+            let n = try!(Read::read(&mut try!(self.fill_buf()), buf));
+            self.pos += n as u64;
+            Ok(n)
+        }
+    }
+}
+
+impl<'a> Read for Cursor<&'a [u8]> { read!(); }
+impl<'a> Read for Cursor<&'a mut [u8]> { read!(); }
+impl Read for Cursor<Vec<u8>> { read!(); }
+
+macro_rules! buffer {
+    () => {
+        fn fill_buf(&mut self) -> io::Result<&[u8]> {
+            let amt = cmp::min(self.pos, self.inner.len() as u64);
+            Ok(&self.inner[(amt as usize)..])
+        }
+        fn consume(&mut self, amt: usize) { self.pos += amt as u64; }
+    }
+}
+
+impl<'a> BufRead for Cursor<&'a [u8]> { buffer!(); }
+impl<'a> BufRead for Cursor<&'a mut [u8]> { buffer!(); }
+impl<'a> BufRead for Cursor<Vec<u8>> { buffer!(); }
+
+impl<'a> Write for Cursor<&'a mut [u8]> {
+    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
+        let pos = cmp::min(self.pos, self.inner.len() as u64);
+        let amt = try!((&mut self.inner[(pos as usize)..]).write(data));
+        self.pos += amt as u64;
+        Ok(amt)
+    }
+    fn flush(&mut self) -> io::Result<()> { Ok(()) }
+}
+
+impl Write for Cursor<Vec<u8>> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        // Make sure the internal buffer is as least as big as where we
+        // currently are
+        let pos = self.position();
+        let amt = pos.saturating_sub(self.inner.len() as u64);
+        self.inner.extend(repeat(0).take(amt as usize));
+
+        // Figure out what bytes will be used to overwrite what's currently
+        // there (left), and what will be appended on the end (right)
+        let space = self.inner.len() - pos as usize;
+        let (left, right) = buf.split_at(cmp::min(space, buf.len()));
+        slice::bytes::copy_memory(&mut self.inner[(pos as usize)..], left);
+        self.inner.push_all(right);
+
+        // Bump us forward
+        self.set_position(pos + buf.len() as u64);
+        Ok(buf.len())
+    }
+    fn flush(&mut self) -> io::Result<()> { Ok(()) }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use core::prelude::*;
+
+    use io::prelude::*;
+    use io::{Cursor, SeekFrom};
+    use vec::Vec;
+
+    #[test]
+    fn test_vec_writer() {
+        let mut writer = Vec::new();
+        assert_eq!(writer.write(&[0]), Ok(1));
+        assert_eq!(writer.write(&[1, 2, 3]), Ok(3));
+        assert_eq!(writer.write(&[4, 5, 6, 7]), Ok(4));
+        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
+        assert_eq!(writer, b);
+    }
+
+    #[test]
+    fn test_mem_writer() {
+        let mut writer = Cursor::new(Vec::new());
+        assert_eq!(writer.write(&[0]), Ok(1));
+        assert_eq!(writer.write(&[1, 2, 3]), Ok(3));
+        assert_eq!(writer.write(&[4, 5, 6, 7]), Ok(4));
+        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
+        assert_eq!(&writer.get_ref()[], b);
+    }
+
+    #[test]
+    fn test_buf_writer() {
+        let mut buf = [0 as u8; 9];
+        {
+            let mut writer = Cursor::new(&mut buf[]);
+            assert_eq!(writer.position(), 0);
+            assert_eq!(writer.write(&[0]), Ok(1));
+            assert_eq!(writer.position(), 1);
+            assert_eq!(writer.write(&[1, 2, 3]), Ok(3));
+            assert_eq!(writer.write(&[4, 5, 6, 7]), Ok(4));
+            assert_eq!(writer.position(), 8);
+            assert_eq!(writer.write(&[]), Ok(0));
+            assert_eq!(writer.position(), 8);
+
+            assert_eq!(writer.write(&[8, 9]), Ok(1));
+            assert_eq!(writer.write(&[10]), Ok(0));
+        }
+        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
+        assert_eq!(buf, b);
+    }
+
+    #[test]
+    fn test_buf_writer_seek() {
+        let mut buf = [0 as u8; 8];
+        {
+            let mut writer = Cursor::new(&mut buf[]);
+            assert_eq!(writer.position(), 0);
+            assert_eq!(writer.write(&[1]), Ok(1));
+            assert_eq!(writer.position(), 1);
+
+            assert_eq!(writer.seek(SeekFrom::Start(2)), Ok(2));
+            assert_eq!(writer.position(), 2);
+            assert_eq!(writer.write(&[2]), Ok(1));
+            assert_eq!(writer.position(), 3);
+
+            assert_eq!(writer.seek(SeekFrom::Current(-2)), Ok(1));
+            assert_eq!(writer.position(), 1);
+            assert_eq!(writer.write(&[3]), Ok(1));
+            assert_eq!(writer.position(), 2);
+
+            assert_eq!(writer.seek(SeekFrom::End(-1)), Ok(7));
+            assert_eq!(writer.position(), 7);
+            assert_eq!(writer.write(&[4]), Ok(1));
+            assert_eq!(writer.position(), 8);
+
+        }
+        let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
+        assert_eq!(buf, b);
+    }
+
+    #[test]
+    fn test_buf_writer_error() {
+        let mut buf = [0 as u8; 2];
+        let mut writer = Cursor::new(&mut buf[]);
+        assert_eq!(writer.write(&[0]), Ok(1));
+        assert_eq!(writer.write(&[0, 0]), Ok(1));
+        assert_eq!(writer.write(&[0, 0]), Ok(0));
+    }
+
+    #[test]
+    fn test_mem_reader() {
+        let mut reader = Cursor::new(vec!(0u8, 1, 2, 3, 4, 5, 6, 7));
+        let mut buf = [];
+        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert_eq!(reader.position(), 0);
+        let mut buf = [0];
+        assert_eq!(reader.read(&mut buf), Ok(1));
+        assert_eq!(reader.position(), 1);
+        let b: &[_] = &[0];
+        assert_eq!(buf, b);
+        let mut buf = [0; 4];
+        assert_eq!(reader.read(&mut buf), Ok(4));
+        assert_eq!(reader.position(), 5);
+        let b: &[_] = &[1, 2, 3, 4];
+        assert_eq!(buf, b);
+        assert_eq!(reader.read(&mut buf), Ok(3));
+        let b: &[_] = &[5, 6, 7];
+        assert_eq!(&buf[..3], b);
+        assert_eq!(reader.read(&mut buf), Ok(0));
+    }
+
+    #[test]
+    fn read_to_end() {
+        let mut reader = Cursor::new(vec!(0u8, 1, 2, 3, 4, 5, 6, 7));
+        let mut v = Vec::new();
+        reader.read_to_end(&mut v).ok().unwrap();
+        assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
+    }
+
+    #[test]
+    fn test_slice_reader() {
+        let in_buf = vec![0u8, 1, 2, 3, 4, 5, 6, 7];
+        let mut reader = &mut in_buf.as_slice();
+        let mut buf = [];
+        assert_eq!(reader.read(&mut buf), Ok(0));
+        let mut buf = [0];
+        assert_eq!(reader.read(&mut buf), Ok(1));
+        assert_eq!(reader.len(), 7);
+        let b: &[_] = &[0];
+        assert_eq!(buf.as_slice(), b);
+        let mut buf = [0; 4];
+        assert_eq!(reader.read(&mut buf), Ok(4));
+        assert_eq!(reader.len(), 3);
+        let b: &[_] = &[1, 2, 3, 4];
+        assert_eq!(buf.as_slice(), b);
+        assert_eq!(reader.read(&mut buf), Ok(3));
+        let b: &[_] = &[5, 6, 7];
+        assert_eq!(&buf[..3], b);
+        assert_eq!(reader.read(&mut buf), Ok(0));
+    }
+
+    #[test]
+    fn test_buf_reader() {
+        let in_buf = vec![0u8, 1, 2, 3, 4, 5, 6, 7];
+        let mut reader = Cursor::new(in_buf.as_slice());
+        let mut buf = [];
+        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert_eq!(reader.position(), 0);
+        let mut buf = [0];
+        assert_eq!(reader.read(&mut buf), Ok(1));
+        assert_eq!(reader.position(), 1);
+        let b: &[_] = &[0];
+        assert_eq!(buf, b);
+        let mut buf = [0; 4];
+        assert_eq!(reader.read(&mut buf), Ok(4));
+        assert_eq!(reader.position(), 5);
+        let b: &[_] = &[1, 2, 3, 4];
+        assert_eq!(buf, b);
+        assert_eq!(reader.read(&mut buf), Ok(3));
+        let b: &[_] = &[5, 6, 7];
+        assert_eq!(&buf[..3], b);
+        assert_eq!(reader.read(&mut buf), Ok(0));
+    }
+
+    #[test]
+    fn test_read_char() {
+        let b = b"Vi\xE1\xBB\x87t";
+        let mut c = Cursor::new(b).chars();
+        assert_eq!(c.next(), Some(Ok('V')));
+        assert_eq!(c.next(), Some(Ok('i')));
+        assert_eq!(c.next(), Some(Ok('ệ')));
+        assert_eq!(c.next(), Some(Ok('t')));
+        assert_eq!(c.next(), None);
+    }
+
+    #[test]
+    fn test_read_bad_char() {
+        let b = b"\x80";
+        let mut c = Cursor::new(b).chars();
+        assert!(c.next().unwrap().is_err());
+    }
+
+    #[test]
+    fn seek_past_end() {
+        let buf = [0xff];
+        let mut r = Cursor::new(&buf[]);
+        assert_eq!(r.seek(SeekFrom::Start(10)), Ok(10));
+        assert_eq!(r.read(&mut [0]), Ok(0));
+
+        let mut r = Cursor::new(vec!(10u8));
+        assert_eq!(r.seek(SeekFrom::Start(10)), Ok(10));
+        assert_eq!(r.read(&mut [0]), Ok(0));
+
+        let mut buf = [0];
+        let mut r = Cursor::new(&mut buf[]);
+        assert_eq!(r.seek(SeekFrom::Start(10)), Ok(10));
+        assert_eq!(r.write(&[3]), Ok(0));
+    }
+
+    #[test]
+    fn seek_before_0() {
+        let buf = [0xff_u8];
+        let mut r = Cursor::new(&buf[]);
+        assert!(r.seek(SeekFrom::End(-2)).is_err());
+
+        let mut r = Cursor::new(vec!(10u8));
+        assert!(r.seek(SeekFrom::End(-2)).is_err());
+
+        let mut buf = [0];
+        let mut r = Cursor::new(&mut buf[]);
+        assert!(r.seek(SeekFrom::End(-2)).is_err());
+    }
+
+    #[test]
+    fn test_seekable_mem_writer() {
+        let mut writer = Cursor::new(Vec::<u8>::new());
+        assert_eq!(writer.position(), 0);
+        assert_eq!(writer.write(&[0]), Ok(1));
+        assert_eq!(writer.position(), 1);
+        assert_eq!(writer.write(&[1, 2, 3]), Ok(3));
+        assert_eq!(writer.write(&[4, 5, 6, 7]), Ok(4));
+        assert_eq!(writer.position(), 8);
+        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
+        assert_eq!(&writer.get_ref()[], b);
+
+        assert_eq!(writer.seek(SeekFrom::Start(0)), Ok(0));
+        assert_eq!(writer.position(), 0);
+        assert_eq!(writer.write(&[3, 4]), Ok(2));
+        let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
+        assert_eq!(&writer.get_ref()[], b);
+
+        assert_eq!(writer.seek(SeekFrom::Current(1)), Ok(3));
+        assert_eq!(writer.write(&[0, 1]), Ok(2));
+        let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
+        assert_eq!(&writer.get_ref()[], b);
+
+        assert_eq!(writer.seek(SeekFrom::End(-1)), Ok(7));
+        assert_eq!(writer.write(&[1, 2]), Ok(2));
+        let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
+        assert_eq!(&writer.get_ref()[], b);
+
+        assert_eq!(writer.seek(SeekFrom::End(1)), Ok(10));
+        assert_eq!(writer.write(&[1]), Ok(1));
+        let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
+        assert_eq!(&writer.get_ref()[], b);
+    }
+
+    #[test]
+    fn vec_seek_past_end() {
+        let mut r = Cursor::new(Vec::new());
+        assert_eq!(r.seek(SeekFrom::Start(10)), Ok(10));
+        assert_eq!(r.write(&[3]), Ok(1));
+    }
+
+    #[test]
+    fn vec_seek_before_0() {
+        let mut r = Cursor::new(Vec::new());
+        assert!(r.seek(SeekFrom::End(-2)).is_err());
+    }
+}
diff --git a/src/libstd/io/error.rs b/src/libstd/io/error.rs
new file mode 100644
index 00000000000..9f3cd8c8b15
--- /dev/null
+++ b/src/libstd/io/error.rs
@@ -0,0 +1,183 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use boxed::Box;
+use clone::Clone;
+use error::Error as StdError;
+use fmt;
+use option::Option::{self, Some, None};
+use result;
+use string::String;
+use sys;
+
+/// A type for results generated by I/O related functions where the `Err` type
+/// is hard-wired to `io::Error`.
+///
+/// This typedef is generally used to avoid writing out `io::Error` directly and
+/// is otherwise a direct mapping to `std::result::Result`.
+pub type Result<T> = result::Result<T, Error>;
+
+/// The error type for I/O operations of the `Read`, `Write`, `Seek`, and
+/// associated traits.
+///
+/// Errors mostly originate from the underlying OS, but custom instances of
+/// `Error` can be created with crafted error messages and a particular value of
+/// `ErrorKind`.
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct Error {
+    repr: Repr,
+}
+
+#[derive(PartialEq, Eq, Clone, Debug)]
+enum Repr {
+    Os(i32),
+    Custom(Box<Custom>),
+}
+
+#[derive(PartialEq, Eq, Clone, Debug)]
+struct Custom {
+    kind: ErrorKind,
+    desc: &'static str,
+    detail: Option<String>
+}
+
+/// A list specifying general categories of I/O error.
+#[derive(Copy, PartialEq, Eq, Clone, Debug)]
+pub enum ErrorKind {
+    /// The file was not found.
+    FileNotFound,
+    /// The file permissions disallowed access to this file.
+    PermissionDenied,
+    /// The connection was refused by the remote server.
+    ConnectionRefused,
+    /// The connection was reset by the remote server.
+    ConnectionReset,
+    /// The connection was aborted (terminated) by the remote server.
+    ConnectionAborted,
+    /// The network operation failed because it was not connected yet.
+    NotConnected,
+    /// The operation failed because a pipe was closed.
+    BrokenPipe,
+    /// A file already existed with that name.
+    PathAlreadyExists,
+    /// No file exists at that location.
+    PathDoesntExist,
+    /// The path did not specify the type of file that this operation required.
+    /// For example, attempting to copy a directory with the `fs::copy()`
+    /// operation will fail with this error.
+    MismatchedFileTypeForOperation,
+    /// The operation temporarily failed (for example, because a signal was
+    /// received), and retrying may succeed.
+    ResourceUnavailable,
+    /// A parameter was incorrect in a way that caused an I/O error not part of
+    /// this list.
+    InvalidInput,
+    /// The I/O operation's timeout expired, causing it to be canceled.
+    TimedOut,
+    /// An error returned when an operation could not be completed because a
+    /// call to `write` returned `Ok(0)`.
+    ///
+    /// This typically means that an operation could only succeed if it wrote a
+    /// particular number of bytes but only a smaller number of bytes could be
+    /// written.
+    WriteZero,
+    /// This operation was interrupted
+    Interrupted,
+    /// Any I/O error not part of this list.
+    Other,
+}
+
+impl Error {
+    /// Creates a new custom error from a specified kind/description/detail.
+    pub fn new(kind: ErrorKind,
+               description: &'static str,
+               detail: Option<String>) -> Error {
+        Error {
+            repr: Repr::Custom(Box::new(Custom {
+                kind: kind,
+                desc: description,
+                detail: detail,
+            }))
+        }
+    }
+
+    /// Returns an error representing the last OS error which occurred.
+    ///
+    /// This function reads the value of `errno` for the target platform (e.g.
+    /// `GetLastError` on Windows) and will return a corresponding instance of
+    /// `Error` for the error code.
+    pub fn last_os_error() -> Error {
+        Error::from_os_error(sys::os::errno() as i32)
+    }
+
+    /// Creates a new instance of an `Error` from a particular OS error code.
+    pub fn from_os_error(code: i32) -> Error {
+        Error { repr: Repr::Os(code) }
+    }
+
+    /// Return the corresponding `ErrorKind` for this error.
+    pub fn kind(&self) -> ErrorKind {
+        match self.repr {
+            Repr::Os(code) => sys::decode_error_kind(code),
+            Repr::Custom(ref c) => c.kind,
+        }
+    }
+
+    /// Returns a short description for this error message
+    pub fn description(&self) -> &str {
+        match self.repr {
+            Repr::Os(..) => "os error",
+            Repr::Custom(ref c) => c.desc,
+        }
+    }
+
+    /// Returns a detailed error message for this error (if one is available)
+    pub fn detail(&self) -> Option<String> {
+        match self.repr {
+            Repr::Os(code) => Some(sys::os::error_string(code)),
+            Repr::Custom(ref s) => s.detail.clone(),
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match self.repr {
+            Repr::Os(code) => {
+                let detail = sys::os::error_string(code);
+                write!(fmt, "{} (os error {})", detail, code)
+            }
+            Repr::Custom(ref c) => {
+                match **c {
+                    Custom {
+                        kind: ErrorKind::Other,
+                        desc: "unknown error",
+                        detail: Some(ref detail)
+                    } => {
+                        write!(fmt, "{}", detail)
+                    }
+                    Custom { detail: None, desc, .. } =>
+                        write!(fmt, "{}", desc),
+                    Custom { detail: Some(ref detail), desc, .. } =>
+                        write!(fmt, "{} ({})", desc, detail)
+                }
+            }
+        }
+    }
+}
+
+impl StdError for Error {
+    fn description(&self) -> &str {
+        match self.repr {
+            Repr::Os(..) => "os error",
+            Repr::Custom(ref c) => c.desc,
+        }
+    }
+}
diff --git a/src/libstd/io/impls.rs b/src/libstd/io/impls.rs
new file mode 100644
index 00000000000..7f3ce7924c1
--- /dev/null
+++ b/src/libstd/io/impls.rs
@@ -0,0 +1,88 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use core::prelude::*;
+
+use boxed::Box;
+use cmp;
+use io::{self, SeekFrom, Read, Write, Seek, BufRead};
+use mem;
+use slice;
+use vec::Vec;
+
+// =============================================================================
+// Forwarding implementations
+
+impl<'a, R: Read + ?Sized> Read for &'a mut R {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { (**self).read(buf) }
+}
+impl<'a, W: Write + ?Sized> Write for &'a mut W {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> { (**self).write(buf) }
+    fn flush(&mut self) -> io::Result<()> { (**self).flush() }
+}
+impl<'a, S: Seek + ?Sized> Seek for &'a mut S {
+    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { (**self).seek(pos) }
+}
+impl<'a, B: BufRead + ?Sized> BufRead for &'a mut B {
+    fn fill_buf(&mut self) -> io::Result<&[u8]> { (**self).fill_buf() }
+    fn consume(&mut self, amt: usize) { (**self).consume(amt) }
+}
+
+impl<R: Read + ?Sized> Read for Box<R> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { (**self).read(buf) }
+}
+impl<W: Write + ?Sized> Write for Box<W> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> { (**self).write(buf) }
+    fn flush(&mut self) -> io::Result<()> { (**self).flush() }
+}
+impl<S: Seek + ?Sized> Seek for Box<S> {
+    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { (**self).seek(pos) }
+}
+impl<B: BufRead + ?Sized> BufRead for Box<B> {
+    fn fill_buf(&mut self) -> io::Result<&[u8]> { (**self).fill_buf() }
+    fn consume(&mut self, amt: usize) { (**self).consume(amt) }
+}
+
+// =============================================================================
+// In-memory buffer implementations
+
+impl<'a> Read for &'a [u8] {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let amt = cmp::min(buf.len(), self.len());
+        let (a, b) = self.split_at(amt);
+        slice::bytes::copy_memory(buf, a);
+        *self = b;
+        Ok(amt)
+    }
+}
+
+impl<'a> BufRead for &'a [u8] {
+    fn fill_buf(&mut self) -> io::Result<&[u8]> { Ok(*self) }
+    fn consume(&mut self, amt: usize) { *self = &self[amt..]; }
+}
+
+impl<'a> Write for &'a mut [u8] {
+    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
+        let amt = cmp::min(data.len(), self.len());
+        let (a, b) = mem::replace(self, &mut []).split_at_mut(amt);
+        slice::bytes::copy_memory(a, &data[..amt]);
+        *self = b;
+        Ok(amt)
+    }
+    fn flush(&mut self) -> io::Result<()> { Ok(()) }
+}
+
+impl Write for Vec<u8> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.push_all(buf);
+        Ok(buf.len())
+    }
+    fn flush(&mut self) -> io::Result<()> { Ok(()) }
+}
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
new file mode 100644
index 00000000000..0832206a48b
--- /dev/null
+++ b/src/libstd/io/mod.rs
@@ -0,0 +1,948 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Traits, helpers, and type definitions for core I/O functionality.
+//!
+//! > **NOTE**: This module is very much a work in progress and is under active
+//! > development. At this time it is still recommended to use the `old_io`
+//! > module while the details of this module shake out.
+
+#![unstable(feature = "io",
+            reason = "this new I/O module is still under active deveopment and \
+                      APIs are subject to tweaks fairly regularly")]
+
+use cmp;
+use unicode::str as core_str;
+use error::Error as StdError;
+use fmt;
+use iter::Iterator;
+use marker::Sized;
+use mem;
+use ops::{Drop, FnOnce};
+use option::Option::{self, Some, None};
+use ptr::PtrExt;
+use result::Result::{Ok, Err};
+use result;
+use slice::{self, SliceExt};
+use string::String;
+use str::{self, StrExt};
+use vec::Vec;
+
+pub use self::buffered::{BufReader, BufWriter, BufStream, LineWriter};
+pub use self::buffered::IntoInnerError;
+pub use self::cursor::Cursor;
+pub use self::error::{Result, Error, ErrorKind};
+pub use self::util::{copy, sink, Sink, empty, Empty, repeat, Repeat};
+
+pub mod prelude;
+mod buffered;
+mod cursor;
+mod error;
+mod impls;
+mod util;
+
+const DEFAULT_BUF_SIZE: usize = 64 * 1024;
+
+// Acquires a slice of the vector `v` from its length to its capacity
+// (uninitialized data), reads into it, and then updates the length.
+//
+// This function is leveraged to efficiently read some bytes into a destination
+// vector without extra copying and taking advantage of the space that's already
+// in `v`.
+//
+// The buffer we're passing down, however, is pointing at uninitialized data
+// (the end of a `Vec`), and many operations will be *much* faster if we don't
+// have to zero it out. In order to prevent LLVM from generating an `undef`
+// value when reads happen from this uninitialized memory, we force LLVM to
+// think it's initialized by sending it through a black box. This should prevent
+// actual undefined behavior after optimizations.
+fn with_end_to_cap<F>(v: &mut Vec<u8>, f: F) -> Result<usize>
+    where F: FnOnce(&mut [u8]) -> Result<usize>
+{
+    unsafe {
+        let n = try!(f({
+            let base = v.as_mut_ptr().offset(v.len() as isize);
+            black_box(slice::from_raw_mut_buf(mem::copy_lifetime(v, &base),
+                                              v.capacity() - v.len()))
+        }));
+
+        // If the closure (typically a `read` implementation) reported that it
+        // read a larger number of bytes than the vector actually has, we need
+        // to be sure to clamp the vector to at most its capacity.
+        let new_len = cmp::min(v.capacity(), v.len() + n);
+        v.set_len(new_len);
+        return Ok(n);
+    }
+
+    // Semi-hack used to prevent LLVM from retaining any assumptions about
+    // `dummy` over this function call
+    unsafe fn black_box<T>(mut dummy: T) -> T {
+        asm!("" :: "r"(&mut dummy) : "memory");
+        dummy
+    }
+}
+
+// A few methods below (read_to_string, read_line) will append data into a
+// `String` buffer, but we need to be pretty careful when doing this. The
+// implementation will just call `.as_mut_vec()` and then delegate to a
+// byte-oriented reading method, but we must ensure that when returning we never
+// leave `buf` in a state such that it contains invalid UTF-8 in its bounds.
+//
+// To this end, we use an RAII guard (to protect against panics) which updates
+// the length of the string when it is dropped. This guard initially truncates
+// the string to the prior length and only afer we've validated that the
+// new contents are valid UTF-8 do we allow it to set a longer length.
+//
+// The unsafety in this function is twofold:
+//
+// 1. We're looking at the raw bytes of `buf`, so we take on the burden of UTF-8
+//    checks.
+// 2. We're passing a raw buffer to the function `f`, and it is expected that
+//    the function only *appends* bytes to the buffer. We'll get undefined
+//    behavior if existing bytes are overwritten to have non-UTF-8 data.
+fn append_to_string<F>(buf: &mut String, f: F) -> Result<()>
+    where F: FnOnce(&mut Vec<u8>) -> Result<()>
+{
+    struct Guard<'a> { s: &'a mut Vec<u8>, len: usize }
+    #[unsafe_destructor]
+    impl<'a> Drop for Guard<'a> {
+        fn drop(&mut self) {
+            unsafe { self.s.set_len(self.len); }
+        }
+    }
+
+    unsafe {
+        let mut g = Guard { len: buf.len(), s: buf.as_mut_vec() };
+        let ret = f(g.s);
+        if str::from_utf8(&g.s[g.len..]).is_err() {
+            ret.and_then(|()| {
+                Err(Error::new(ErrorKind::InvalidInput,
+                               "stream did not contain valid UTF-8", None))
+            })
+        } else {
+            g.len = g.s.len();
+            ret
+        }
+    }
+}
+
+fn read_to_end<R: Read + ?Sized>(r: &mut R, buf: &mut Vec<u8>) -> Result<()> {
+    loop {
+        if buf.capacity() == buf.len() {
+            buf.reserve(DEFAULT_BUF_SIZE);
+        }
+        match with_end_to_cap(buf, |b| r.read(b)) {
+            Ok(0) => return Ok(()),
+            Ok(_) => {}
+            Err(ref e) if e.kind() == ErrorKind::Interrupted => {}
+            Err(e) => return Err(e),
+        }
+    }
+}
+
+/// A trait for objects which are byte-oriented sources.
+///
+/// Readers are defined by one method, `read`. Each call to `read` will attempt
+/// to pull bytes from this source into a provided buffer.
+///
+/// Readers are intended to be composable with one another. Many objects
+/// throughout the I/O and related libraries take and provide types which
+/// implement the `Read` trait.
+pub trait Read {
+    /// Pull some bytes from this source into the specified buffer, returning
+    /// how many bytes were read.
+    ///
+    /// This function does not provide any guarantees about whether it blocks
+    /// waiting for data, but if an object needs to block for a read but cannot
+    /// it will typically signal this via an `Err` return value.
+    ///
+    /// If the return value of this method is `Ok(n)`, then it must be
+    /// guaranteed that `0 <= n <= buf.len()`. A nonzero `n` value indicates
+    /// that the buffer `buf` has ben filled in with `n` bytes of data from this
+    /// source. If `n` is `0`, then it can indicate one of two scenarios:
+    ///
+    /// 1. This reader has reached its "end of file" and will likely no longer
+    ///    be able to produce bytes. Note that this does not mean that the
+    ///    reader will *always* no longer be able to produce bytes.
+    /// 2. The buffer specified was 0 bytes in length.
+    ///
+    /// No guarantees are provided about the contents of `buf` when this
+    /// function is called, implementations cannot rely on any property of the
+    /// contents of `buf` being true. It is recommended that implementations
+    /// only write data to `buf` instead of reading its contents.
+    ///
+    /// # Errors
+    ///
+    /// If this function encounters any form of I/O or other error, an error
+    /// variant will be returned. If an error is returned then it must be
+    /// guaranteed that no bytes were read.
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
+
+    /// Read all bytes until EOF in this source, placing them into `buf`.
+    ///
+    /// All bytes read from this source will be appended to the specified buffer
+    /// `buf`. This function will return a call to `read` either:
+    ///
+    /// 1. Returns `Ok(0)`.
+    /// 2. Returns an error which is not of the kind `ErrorKind::Interrupted`.
+    ///
+    /// Until one of these conditions is met the function will continuously
+    /// invoke `read` to append more data to `buf`.
+    ///
+    /// # Errors
+    ///
+    /// If this function encounters an error of the kind
+    /// `ErrorKind::Interrupted` then the error is ignored and the operation
+    /// will continue.
+    ///
+    /// If any other read error is encountered then this function immediately
+    /// returns. Any bytes which have already been read will be appended to
+    /// `buf`.
+    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<()> {
+        read_to_end(self, buf)
+    }
+
+    /// Read all bytes until EOF in this source, placing them into `buf`.
+    ///
+    /// # Errors
+    ///
+    /// If the data in this stream is *not* valid UTF-8 then an error is
+    /// returned and `buf` is unchanged.
+    ///
+    /// See `read_to_end` for other error semantics.
+    fn read_to_string(&mut self, buf: &mut String) -> Result<()> {
+        // Note that we do *not* call `.read_to_end()` here. We are passing
+        // `&mut Vec<u8>` (the raw contents of `buf`) into the `read_to_end`
+        // method to fill it up. An arbitrary implementation could overwrite the
+        // entire contents of the vector, not just append to it (which is what
+        // we are expecting).
+        //
+        // To prevent extraneously checking the UTF-8-ness of the entire buffer
+        // we pass it to our hardcoded `read_to_end` implementation which we
+        // know is guaranteed to only read data into the end of the buffer.
+        append_to_string(buf, |b| read_to_end(self, b))
+    }
+}
+
+/// Extension methods for all instances of `Read`, typically imported through
+/// `std::io::prelude::*`.
+pub trait ReadExt: Read + Sized {
+    /// Create a "by reference" adaptor for this instance of `Read`.
+    ///
+    /// The returned adaptor also implements `Read` and will simply borrow this
+    /// current reader.
+    fn by_ref(&mut self) -> &mut Self { self }
+
+    /// Transform this `Read` instance to an `Iterator` over its bytes.
+    ///
+    /// The returned type implements `Iterator` where the `Item` is `Result<u8,
+    /// R::Err>`.  The yielded item is `Ok` if a byte was successfully read and
+    /// `Err` otherwise for I/O errors. EOF is mapped to returning `None` from
+    /// this iterator.
+    fn bytes(self) -> Bytes<Self> {
+        Bytes { inner: self }
+    }
+
+    /// Transform this `Read` instance to an `Iterator` over `char`s.
+    ///
+    /// This adaptor will attempt to interpret this reader as an UTF-8 encoded
+    /// sequence of characters. The returned iterator will return `None` once
+    /// EOF is reached for this reader. Otherwise each element yielded will be a
+    /// `Result<char, E>` where `E` may contain information about what I/O error
+    /// occurred or where decoding failed.
+    ///
+    /// Currently this adaptor will discard intermediate data read, and should
+    /// be avoided if this is not desired.
+    fn chars(self) -> Chars<Self> {
+        Chars { inner: self }
+    }
+
+    /// Create an adaptor which will chain this stream with another.
+    ///
+    /// The returned `Read` instance will first read all bytes from this object
+    /// until EOF is encountered. Afterwards the output is equivalent to the
+    /// output of `next`.
+    fn chain<R: Read>(self, next: R) -> Chain<Self, R> {
+        Chain { first: self, second: next, done_first: false }
+    }
+
+    /// Create an adaptor which will read at most `limit` bytes from it.
+    ///
+    /// This function returns a new instance of `Read` which will read at most
+    /// `limit` bytes, after which it will always return EOF (`Ok(0)`). Any
+    /// read errors will not count towards the number of bytes read and future
+    /// calls to `read` may succeed.
+    fn take(self, limit: u64) -> Take<Self> {
+        Take { inner: self, limit: limit }
+    }
+
+    /// Creates a reader adaptor which will write all read data into the given
+    /// output stream.
+    ///
+    /// Whenever the returned `Read` instance is read it will write the read
+    /// data to `out`. The current semantics of this implementation imply that
+    /// a `write` error will not report how much data was initially read.
+    fn tee<W: Write>(self, out: W) -> Tee<Self, W> {
+        Tee { reader: self, writer: out }
+    }
+}
+
+impl<T: Read> ReadExt for T {}
+
+/// A trait for objects which are byte-oriented sinks.
+///
+/// The `write` method will attempt to write some data into the object,
+/// returning how many bytes were successfully written.
+///
+/// The `flush` method is useful for adaptors and explicit buffers themselves
+/// for ensuring that all buffered data has been pushed out to the "true sink".
+///
+/// Writers are intended to be composable with one another. Many objects
+/// throughout the I/O and related libraries take and provide types which
+/// implement the `Write` trait.
+pub trait Write {
+    /// Write a buffer into this object, returning how many bytes were written.
+    ///
+    /// This function will attempt to write the entire contents of `buf`, but
+    /// the entire write may not succeed, or the write may also generate an
+    /// error. A call to `write` represents *at most one* attempt to write to
+    /// any wrapped object.
+    ///
+    /// Calls to `write` are not guaranteed to block waiting for data to be
+    /// written, and a write which would otherwise block can indicated through
+    /// an `Err` variant.
+    ///
+    /// If the return value is `Ok(n)` then it must be guaranteed that
+    /// `0 <= n <= buf.len()`. A return value of `0` typically means that the
+    /// underlying object is no longer able to accept bytes and will likely not
+    /// be able to in the future as well, or that the buffer provided is empty.
+    ///
+    /// # Errors
+    ///
+    /// Each call to `write` may generate an I/O error indicating that the
+    /// operation could not be completed. If an error is returned then no bytes
+    /// in the buffer were written to this writer.
+    ///
+    /// It is **not** considered an error if the entire buffer could not be
+    /// written to this writer.
+    fn write(&mut self, buf: &[u8]) -> Result<usize>;
+
+    /// Flush this output stream, ensuring that all intermediately buffered
+    /// contents reach their destination.
+    ///
+    /// # Errors
+    ///
+    /// It is considered an error if not all bytes could be written due to
+    /// I/O errors or EOF being reached.
+    fn flush(&mut self) -> Result<()>;
+
+    /// Attempts to write an entire buffer into this write.
+    ///
+    /// This method will continuously call `write` while there is more data to
+    /// write. This method will not return until the entire buffer has been
+    /// successfully written or an error occurs. The first error generated from
+    /// this method will be returned.
+    ///
+    /// # Errors
+    ///
+    /// This function will return the first error that `write` returns.
+    fn write_all(&mut self, mut buf: &[u8]) -> Result<()> {
+        while buf.len() > 0 {
+            match self.write(buf) {
+                Ok(0) => return Err(Error::new(ErrorKind::WriteZero,
+                                               "failed to write whole buffer",
+                                               None)),
+                Ok(n) => buf = &buf[n..],
+                Err(ref e) if e.kind() == ErrorKind::Interrupted => {}
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(())
+    }
+
+    /// Writes a formatted string into this writer, returning any error
+    /// encountered.
+    ///
+    /// This method is primarily used to interface with the `format_args!`
+    /// macro, but it is rare that this should explicitly be called. The
+    /// `write!` macro should be favored to invoke this method instead.
+    ///
+    /// This function internally uses the `write_all` method on this trait and
+    /// hence will continuously write data so long as no errors are received.
+    /// This also means that partial writes are not indicated in this signature.
+    ///
+    /// # Errors
+    ///
+    /// This function will return any I/O error reported while formatting.
+    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()> {
+        // Create a shim which translates a Writer to a fmt::Writer and saves
+        // off I/O errors. instead of discarding them
+        struct Adaptor<'a, T: ?Sized + 'a> {
+            inner: &'a mut T,
+            error: Result<()>,
+        }
+
+        impl<'a, T: Write + ?Sized> fmt::Writer for Adaptor<'a, T> {
+            fn write_str(&mut self, s: &str) -> fmt::Result {
+                match self.inner.write_all(s.as_bytes()) {
+                    Ok(()) => Ok(()),
+                    Err(e) => {
+                        self.error = Err(e);
+                        Err(fmt::Error)
+                    }
+                }
+            }
+        }
+
+        let mut output = Adaptor { inner: self, error: Ok(()) };
+        match fmt::write(&mut output, fmt) {
+            Ok(()) => Ok(()),
+            Err(..) => output.error
+        }
+    }
+}
+
+/// Extension methods for all instances of `Write`, typically imported through
+/// `std::io::prelude::*`.
+pub trait WriteExt: Write + Sized {
+    /// Create a "by reference" adaptor for this instance of `Write`.
+    ///
+    /// The returned adaptor also implements `Write` and will simply borrow this
+    /// current writer.
+    fn by_ref(&mut self) -> &mut Self { self }
+
+    /// Creates a new writer which will write all data to both this writer and
+    /// another writer.
+    ///
+    /// All data written to the returned writer will both be written to `self`
+    /// as well as `other`. Note that the error semantics of the current
+    /// implementation do not precisely track where errors happen. For example
+    /// an error on the second call to `write` will not report that the first
+    /// call to `write` succeeded.
+    fn broadcast<W: Write>(self, other: W) -> Broadcast<Self, W> {
+        Broadcast { first: self, second: other }
+    }
+}
+
+impl<T: Write> WriteExt for T {}
+
+/// An object implementing `Seek` internally has some form of cursor which can
+/// be moved within a stream of bytes.
+///
+/// The stream typically has a fixed size, allowing seeking relative to either
+/// end or the current offset.
+pub trait Seek {
+    /// Seek to an offset, in bytes, in a stream
+    ///
+    /// A seek beyond the end of a stream is allowed, but seeking before offset
+    /// 0 is an error.
+    ///
+    /// Seeking past the end of the stream does not modify the underlying
+    /// stream, but the next write may cause the previous data to be filled in
+    /// with a bit pattern.
+    ///
+    /// This method returns the new position within the stream if the seek
+    /// operation completed successfully.
+    ///
+    /// # Errors
+    ///
+    /// Seeking to a negative offset is considered an error
+    fn seek(&mut self, pos: SeekFrom) -> Result<u64>;
+}
+
+/// Enumeration of possible methods to seek within an I/O object.
+#[derive(Copy, PartialEq, Eq, Clone, Debug)]
+pub enum SeekFrom {
+    /// Set the offset to the provided number of bytes.
+    Start(u64),
+
+    /// Set the offset to the size of this object plus the specified number of
+    /// bytes.
+    ///
+    /// It is possible to seek beyond the end of an object, but is an error to
+    /// seek before byte 0.
+    End(i64),
+
+    /// Set the offset to the current position plus the specified number of
+    /// bytes.
+    ///
+    /// It is possible to seek beyond the end of an object, but is an error to
+    /// seek before byte 0.
+    Current(i64),
+}
+
+fn read_until<R: BufRead + ?Sized>(r: &mut R, delim: u8, buf: &mut Vec<u8>)
+                                   -> Result<()> {
+    loop {
+        let (done, used) = {
+            let available = match r.fill_buf() {
+                Ok(n) => n,
+                Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
+                Err(e) => return Err(e)
+            };
+            match available.position_elem(&delim) {
+                Some(i) => {
+                    buf.push_all(&available[..i + 1]);
+                    (true, i + 1)
+                }
+                None => {
+                    buf.push_all(available);
+                    (false, available.len())
+                }
+            }
+        };
+        r.consume(used);
+        if done || used == 0 {
+            return Ok(());
+        }
+    }
+}
+
+/// A Buffer is a type of reader which has some form of internal buffering to
+/// allow certain kinds of reading operations to be more optimized than others.
+///
+/// This type extends the `Read` trait with a few methods that are not
+/// possible to reasonably implement with purely a read interface.
+pub trait BufRead: Read {
+    /// Fills the internal buffer of this object, returning the buffer contents.
+    ///
+    /// None of the contents will be "read" in the sense that later calling
+    /// `read` may return the same contents.
+    ///
+    /// The `consume` function must be called with the number of bytes that are
+    /// consumed from this buffer returned to ensure that the bytes are never
+    /// returned twice.
+    ///
+    /// An empty buffer returned indicates that the stream has reached EOF.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an I/O error if the underlying reader was
+    /// read, but returned an error.
+    fn fill_buf(&mut self) -> Result<&[u8]>;
+
+    /// Tells this buffer that `amt` bytes have been consumed from the buffer,
+    /// so they should no longer be returned in calls to `read`.
+    fn consume(&mut self, amt: usize);
+
+    /// Read all bytes until the delimiter `byte` is reached.
+    ///
+    /// This function will continue to read (and buffer) bytes from the
+    /// underlying stream until the delimiter or EOF is found. Once found, all
+    /// bytes up to, and including, the delimiter (if found) will be appended to
+    /// `buf`.
+    ///
+    /// If this buffered reader is currently at EOF, then this function will not
+    /// place any more bytes into `buf` and will return `Ok(())`.
+    ///
+    /// # Errors
+    ///
+    /// This function will ignore all instances of `ErrorKind::Interrupted` and
+    /// will otherwise return any errors returned by `fill_buf`.
+    ///
+    /// If an I/O error is encountered then all bytes read so far will be
+    /// present in `buf` and its length will have been adjusted appropriately.
+    fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<()> {
+        read_until(self, byte, buf)
+    }
+
+    /// Read all bytes until a newline byte (the 0xA byte) is reached.
+    ///
+    /// This function will continue to read (and buffer) bytes from the
+    /// underlying stream until the newline delimiter (the 0xA byte) or EOF is
+    /// found. Once found, all bytes up to, and including, the delimiter (if
+    /// found) will be appended to `buf`.
+    ///
+    /// If this reader is currently at EOF then this function will not modify
+    /// `buf` and will return `Ok(())`.
+    ///
+    /// # Errors
+    ///
+    /// This function has the same error semantics as `read_until` and will also
+    /// return an error if the read bytes are not valid UTF-8. If an I/O error
+    /// is encountered then `buf` may contain some bytes already read in the
+    /// event that all data read so far was valid UTF-8.
+    fn read_line(&mut self, buf: &mut String) -> Result<()> {
+        // Note that we are not calling the `.read_until` method here, but
+        // rather our hardcoded implementation. For more details as to why, see
+        // the comments in `read_to_end`.
+        append_to_string(buf, |b| read_until(self, b'\n', b))
+    }
+}
+
+/// Extension methods for all instances of `BufRead`, typically imported through
+/// `std::io::prelude::*`.
+pub trait BufReadExt: BufRead + Sized {
+    /// Returns an iterator over the contents of this reader split on the byte
+    /// `byte`.
+    ///
+    /// The iterator returned from this function will return instances of
+    /// `io::Result<Vec<u8>>`. Each vector returned will *not* have the
+    /// delimiter byte at the end.
+    ///
+    /// This function will yield errors whenever `read_until` would have also
+    /// yielded an error.
+    fn split(self, byte: u8) -> Split<Self> {
+        Split { buf: self, delim: byte }
+    }
+
+    /// Returns an iterator over the lines of this reader.
+    ///
+    /// The iterator returned from this function will yield instances of
+    /// `io::Result<String>`. Each string returned will *not* have a newline
+    /// byte (the 0xA byte) at the end.
+    ///
+    /// This function will yield errors whenever `read_string` would have also
+    /// yielded an error.
+    fn lines(self) -> Lines<Self> {
+        Lines { buf: self }
+    }
+}
+
+impl<T: BufRead> BufReadExt for T {}
+
+/// A `Write` adaptor which will write data to multiple locations.
+///
+/// For more information, see `WriteExt::broadcast`.
+pub struct Broadcast<T, U> {
+    first: T,
+    second: U,
+}
+
+impl<T: Write, U: Write> Write for Broadcast<T, U> {
+    fn write(&mut self, data: &[u8]) -> Result<usize> {
+        let n = try!(self.first.write(data));
+        // FIXME: what if the write fails? (we wrote something)
+        try!(self.second.write_all(&data[..n]));
+        Ok(n)
+    }
+
+    fn flush(&mut self) -> Result<()> {
+        self.first.flush().and(self.second.flush())
+    }
+}
+
+/// Adaptor to chain together two instances of `Read`.
+///
+/// For more information, see `ReadExt::chain`.
+pub struct Chain<T, U> {
+    first: T,
+    second: U,
+    done_first: bool,
+}
+
+impl<T: Read, U: Read> Read for Chain<T, U> {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+        if !self.done_first {
+            match try!(self.first.read(buf)) {
+                0 => { self.done_first = true; }
+                n => return Ok(n),
+            }
+        }
+        self.second.read(buf)
+    }
+}
+
+/// Reader adaptor which limits the bytes read from an underlying reader.
+///
+/// For more information, see `ReadExt::take`.
+pub struct Take<T> {
+    inner: T,
+    limit: u64,
+}
+
+impl<T> Take<T> {
+    /// Returns the number of bytes that can be read before this instance will
+    /// return EOF.
+    ///
+    /// # Note
+    ///
+    /// This instance may reach EOF after reading fewer bytes than indiccated by
+    /// this method if the underlying `Read` instance reaches EOF.
+    pub fn limit(&self) -> u64 { self.limit }
+}
+
+impl<T: Read> Read for Take<T> {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+        let max = cmp::min(buf.len() as u64, self.limit) as usize;
+        let n = try!(self.inner.read(&mut buf[..max]));
+        self.limit -= n as u64;
+        Ok(n)
+    }
+}
+
+/// An adaptor which will emit all read data to a specified writer as well.
+///
+/// For more information see `ReadExt::tee`
+pub struct Tee<R, W> {
+    reader: R,
+    writer: W,
+}
+
+impl<R: Read, W: Write> Read for Tee<R, W> {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+        let n = try!(self.reader.read(buf));
+        // FIXME: what if the write fails? (we read something)
+        try!(self.writer.write_all(&buf[..n]));
+        Ok(n)
+    }
+}
+
+/// A bridge from implementations of `Read` to an `Iterator` of `u8`.
+///
+/// See `ReadExt::bytes` for more information.
+pub struct Bytes<R> {
+    inner: R,
+}
+
+impl<R: Read> Iterator for Bytes<R> {
+    type Item = Result<u8>;
+
+    fn next(&mut self) -> Option<Result<u8>> {
+        let mut buf = [0];
+        match self.inner.read(&mut buf) {
+            Ok(0) => None,
+            Ok(..) => Some(Ok(buf[0])),
+            Err(e) => Some(Err(e)),
+        }
+    }
+}
+
+/// A bridge from implementations of `Read` to an `Iterator` of `char`.
+///
+/// See `ReadExt::chars` for more information.
+pub struct Chars<R> {
+    inner: R,
+}
+
+/// An enumeration of possible errors that can be generated from the `Chars`
+/// adapter.
+#[derive(PartialEq, Clone, Debug)]
+pub enum CharsError {
+    /// Variant representing that the underlying stream was read successfully
+    /// but it did not contain valid utf8 data.
+    NotUtf8,
+
+    /// Variant representing that an I/O error occurred.
+    Other(Error),
+}
+
+impl<R: Read> Iterator for Chars<R> {
+    type Item = result::Result<char, CharsError>;
+
+    fn next(&mut self) -> Option<result::Result<char, CharsError>> {
+        let mut buf = [0];
+        let first_byte = match self.inner.read(&mut buf) {
+            Ok(0) => return None,
+            Ok(..) => buf[0],
+            Err(e) => return Some(Err(CharsError::Other(e))),
+        };
+        let width = core_str::utf8_char_width(first_byte);
+        if width == 1 { return Some(Ok(first_byte as char)) }
+        if width == 0 { return Some(Err(CharsError::NotUtf8)) }
+        let mut buf = [first_byte, 0, 0, 0];
+        {
+            let mut start = 1;
+            while start < width {
+                match self.inner.read(&mut buf[start..width]) {
+                    Ok(0) => return Some(Err(CharsError::NotUtf8)),
+                    Ok(n) => start += n,
+                    Err(e) => return Some(Err(CharsError::Other(e))),
+                }
+            }
+        }
+        Some(match str::from_utf8(&buf[..width]).ok() {
+            Some(s) => Ok(s.char_at(0)),
+            None => Err(CharsError::NotUtf8),
+        })
+    }
+}
+
+impl StdError for CharsError {
+    fn description(&self) -> &str {
+        match *self {
+            CharsError::NotUtf8 => "invalid utf8 encoding",
+            CharsError::Other(ref e) => e.description(),
+        }
+    }
+    fn cause(&self) -> Option<&StdError> {
+        match *self {
+            CharsError::NotUtf8 => None,
+            CharsError::Other(ref e) => e.cause(),
+        }
+    }
+}
+
+impl fmt::Display for CharsError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            CharsError::NotUtf8 => {
+                "byte stream did not contain valid utf8".fmt(f)
+            }
+            CharsError::Other(ref e) => e.fmt(f),
+        }
+    }
+}
+
+/// An iterator over the contents of an instance of `BufRead` split on a
+/// particular byte.
+///
+/// See `BufReadExt::split` for more information.
+pub struct Split<B> {
+    buf: B,
+    delim: u8,
+}
+
+impl<B: BufRead> Iterator for Split<B> {
+    type Item = Result<Vec<u8>>;
+
+    fn next(&mut self) -> Option<Result<Vec<u8>>> {
+        let mut buf = Vec::new();
+        match self.buf.read_until(self.delim, &mut buf) {
+            Ok(()) if buf.len() == 0 => None,
+            Ok(()) => {
+                if buf[buf.len() - 1] == self.delim {
+                    buf.pop();
+                }
+                Some(Ok(buf))
+            }
+            Err(e) => Some(Err(e))
+        }
+    }
+}
+
+/// An iterator over the lines of an instance of `BufRead` split on a newline
+/// byte.
+///
+/// See `BufReadExt::lines` for more information.
+pub struct Lines<B> {
+    buf: B,
+}
+
+impl<B: BufRead> Iterator for Lines<B> {
+    type Item = Result<String>;
+
+    fn next(&mut self) -> Option<Result<String>> {
+        let mut buf = String::new();
+        match self.buf.read_line(&mut buf) {
+            Ok(()) if buf.len() == 0 => None,
+            Ok(()) => {
+                if buf.ends_with("\n") {
+                    buf.pop();
+                }
+                Some(Ok(buf))
+            }
+            Err(e) => Some(Err(e))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use prelude::v1::*;
+    use io::prelude::*;
+    use super::Cursor;
+
+    #[test]
+    fn read_until() {
+        let mut buf = Cursor::new(b"12");
+        let mut v = Vec::new();
+        assert_eq!(buf.read_until(b'3', &mut v), Ok(()));
+        assert_eq!(v, b"12");
+
+        let mut buf = Cursor::new(b"1233");
+        let mut v = Vec::new();
+        assert_eq!(buf.read_until(b'3', &mut v), Ok(()));
+        assert_eq!(v, b"123");
+        v.truncate(0);
+        assert_eq!(buf.read_until(b'3', &mut v), Ok(()));
+        assert_eq!(v, b"3");
+        v.truncate(0);
+        assert_eq!(buf.read_until(b'3', &mut v), Ok(()));
+        assert_eq!(v, []);
+    }
+
+    #[test]
+    fn split() {
+        let mut buf = Cursor::new(b"12");
+        let mut s = buf.split(b'3');
+        assert_eq!(s.next(), Some(Ok(vec![b'1', b'2'])));
+        assert_eq!(s.next(), None);
+
+        let mut buf = Cursor::new(b"1233");
+        let mut s = buf.split(b'3');
+        assert_eq!(s.next(), Some(Ok(vec![b'1', b'2'])));
+        assert_eq!(s.next(), Some(Ok(vec![])));
+        assert_eq!(s.next(), None);
+    }
+
+    #[test]
+    fn read_line() {
+        let mut buf = Cursor::new(b"12");
+        let mut v = String::new();
+        assert_eq!(buf.read_line(&mut v), Ok(()));
+        assert_eq!(v, "12");
+
+        let mut buf = Cursor::new(b"12\n\n");
+        let mut v = String::new();
+        assert_eq!(buf.read_line(&mut v), Ok(()));
+        assert_eq!(v, "12\n");
+        v.truncate(0);
+        assert_eq!(buf.read_line(&mut v), Ok(()));
+        assert_eq!(v, "\n");
+        v.truncate(0);
+        assert_eq!(buf.read_line(&mut v), Ok(()));
+        assert_eq!(v, "");
+    }
+
+    #[test]
+    fn lines() {
+        let mut buf = Cursor::new(b"12");
+        let mut s = buf.lines();
+        assert_eq!(s.next(), Some(Ok("12".to_string())));
+        assert_eq!(s.next(), None);
+
+        let mut buf = Cursor::new(b"12\n\n");
+        let mut s = buf.lines();
+        assert_eq!(s.next(), Some(Ok("12".to_string())));
+        assert_eq!(s.next(), Some(Ok(String::new())));
+        assert_eq!(s.next(), None);
+    }
+
+    #[test]
+    fn read_to_end() {
+        let mut c = Cursor::new(b"");
+        let mut v = Vec::new();
+        assert_eq!(c.read_to_end(&mut v), Ok(()));
+        assert_eq!(v, []);
+
+        let mut c = Cursor::new(b"1");
+        let mut v = Vec::new();
+        assert_eq!(c.read_to_end(&mut v), Ok(()));
+        assert_eq!(v, b"1");
+    }
+
+    #[test]
+    fn read_to_string() {
+        let mut c = Cursor::new(b"");
+        let mut v = String::new();
+        assert_eq!(c.read_to_string(&mut v), Ok(()));
+        assert_eq!(v, "");
+
+        let mut c = Cursor::new(b"1");
+        let mut v = String::new();
+        assert_eq!(c.read_to_string(&mut v), Ok(()));
+        assert_eq!(v, "1");
+
+        let mut c = Cursor::new(b"\xff");
+        let mut v = String::new();
+        assert!(c.read_to_string(&mut v).is_err());
+    }
+}
diff --git a/src/libstd/io/prelude.rs b/src/libstd/io/prelude.rs
new file mode 100644
index 00000000000..475ada2ff84
--- /dev/null
+++ b/src/libstd/io/prelude.rs
@@ -0,0 +1,27 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! The I/O Prelude
+//!
+//! The purpose of this module is to alleviate imports of many common I/O traits
+//! by adding a glob import to the top of I/O heavy modules:
+//!
+//! ```
+//! use std::io::prelude::*;
+//! ```
+//!
+//! This module contains reexports of many core I/O traits such as `Read`,
+//! `Write`, `ReadExt`, and `WriteExt`. Structures and functions are not
+//! contained in this module.
+
+pub use super::{Read, ReadExt, Write, WriteExt, BufRead, BufReadExt};
+
+// FIXME: pub use as `Seek` when the name isn't in the actual prelude any more
+pub use super::Seek as NewSeek;
diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs
new file mode 100644
index 00000000000..3d342137c62
--- /dev/null
+++ b/src/libstd/io/util.rs
@@ -0,0 +1,153 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(missing_copy_implementations)]
+
+use prelude::v1::*;
+
+use io::{self, Read, Write, ErrorKind};
+
+/// Copies the entire contents of a reader into a writer.
+///
+/// This function will continuously read data from `r` and then write it into
+/// `w` in a streaming fashion until `r` returns EOF.
+///
+/// On success the total number of bytes that were copied from `r` to `w` is
+/// returned.
+///
+/// # Errors
+///
+/// This function will return an error immediately if any call to `read` or
+/// `write` returns an error. All instances of `ErrorKind::Interrupted` are
+/// handled by this function and the underlying operation is retried.
+pub fn copy<R: Read, W: Write>(r: &mut R, w: &mut W) -> io::Result<u64> {
+    let mut buf = [0; super::DEFAULT_BUF_SIZE];
+    let mut written = 0;
+    loop {
+        let len = match r.read(&mut buf) {
+            Ok(0) => return Ok(written),
+            Ok(len) => len,
+            Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
+            Err(e) => return Err(e),
+        };
+        try!(w.write_all(&buf[..len]));
+        written += len as u64;
+    }
+}
+
+/// A reader which is always at EOF.
+pub struct Empty { _priv: () }
+
+/// Creates an instance of an empty reader.
+///
+/// All reads from the returned reader will return `Ok(0)`.
+pub fn empty() -> Empty { Empty { _priv: () } }
+
+impl Read for Empty {
+    fn read(&mut self, _buf: &mut [u8]) -> io::Result<usize> { Ok(0) }
+}
+
+/// A reader which infinitely yields one byte.
+pub struct Repeat { byte: u8 }
+
+/// Creates an instance of a reader that infinitely repeats one byte.
+///
+/// All reads from this reader will succeed by filling the specified buffer with
+/// the given byte.
+pub fn repeat(byte: u8) -> Repeat { Repeat { byte: byte } }
+
+impl Read for Repeat {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        for slot in buf.iter_mut() {
+            *slot = self.byte;
+        }
+        Ok(buf.len())
+    }
+}
+
+/// A writer which will move data into the void.
+pub struct Sink { _priv: () }
+
+/// Creates an instance of a writer which will successfully consume all data.
+///
+/// All calls to `write` on the returned instance will return `Ok(buf.len())`
+/// and the contents of the buffer will not be inspected.
+pub fn sink() -> Sink { Sink { _priv: () } }
+
+impl Write for Sink {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> { Ok(buf.len()) }
+    fn flush(&mut self) -> io::Result<()> { Ok(()) }
+}
+
+#[cfg(test)]
+mod test {
+    use prelude::v1::*;
+
+    use io::prelude::*;
+    use io::{sink, empty, repeat};
+
+    #[test]
+    fn sink_sinks() {
+        let mut s = sink();
+        assert_eq!(s.write(&[]), Ok(0));
+        assert_eq!(s.write(&[0]), Ok(1));
+        assert_eq!(s.write(&[0; 1024]), Ok(1024));
+        assert_eq!(s.by_ref().write(&[0; 1024]), Ok(1024));
+    }
+
+    #[test]
+    fn empty_reads() {
+        let mut e = empty();
+        assert_eq!(e.read(&mut []), Ok(0));
+        assert_eq!(e.read(&mut [0]), Ok(0));
+        assert_eq!(e.read(&mut [0; 1024]), Ok(0));
+        assert_eq!(e.by_ref().read(&mut [0; 1024]), Ok(0));
+    }
+
+    #[test]
+    fn repeat_repeats() {
+        let mut r = repeat(4);
+        let mut b = [0; 1024];
+        assert_eq!(r.read(&mut b), Ok(1024));
+        assert!(b.iter().all(|b| *b == 4));
+    }
+
+    #[test]
+    fn take_some_bytes() {
+        assert_eq!(repeat(4).take(100).bytes().count(), 100);
+        assert_eq!(repeat(4).take(100).bytes().next(), Some(Ok(4)));
+        assert_eq!(repeat(1).take(10).chain(repeat(2).take(10)).bytes().count(), 20);
+    }
+
+    #[test]
+    fn tee() {
+        let mut buf = [0; 10];
+        {
+            let mut ptr: &mut [u8] = &mut buf;
+            assert_eq!(repeat(4).tee(&mut ptr).take(5).read(&mut [0; 10]), Ok(5));
+        }
+        assert_eq!(buf, [4, 4, 4, 4, 4, 0, 0, 0, 0, 0]);
+    }
+
+    #[test]
+    fn broadcast() {
+        let mut buf1 = [0; 10];
+        let mut buf2 = [0; 10];
+        {
+            let mut ptr1: &mut [u8] = &mut buf1;
+            let mut ptr2: &mut [u8] = &mut buf2;
+
+            assert_eq!((&mut ptr1).broadcast(&mut ptr2)
+                                  .write(&[1, 2, 3]), Ok(3));
+        }
+        assert_eq!(buf1, buf2);
+        assert_eq!(buf1, [1, 2, 3, 0, 0, 0, 0, 0, 0, 0]);
+    }
+}
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index 839983d336d..a46cea7a443 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -128,9 +128,8 @@
 
 #![deny(missing_docs)]
 
-#[cfg(test)]
-#[macro_use]
-extern crate log;
+#[cfg(test)] extern crate test;
+#[cfg(test)] #[macro_use] extern crate log;
 
 #[macro_use]
 #[macro_reexport(assert, assert_eq, debug_assert, debug_assert_eq,
@@ -248,9 +247,11 @@ pub mod dynamic_lib;
 pub mod ffi;
 pub mod fmt;
 pub mod old_io;
+pub mod io;
 pub mod os;
 pub mod env;
 pub mod path;
+pub mod old_path;
 pub mod rand;
 pub mod time;
 
diff --git a/src/libstd/old_io/fs.rs b/src/libstd/old_io/fs.rs
index abf215988bb..88ca6667d55 100644
--- a/src/libstd/old_io/fs.rs
+++ b/src/libstd/old_io/fs.rs
@@ -61,8 +61,8 @@ use old_io;
 use iter::{Iterator, Extend};
 use option::Option;
 use option::Option::{Some, None};
-use path::{Path, GenericPath};
-use path;
+use old_path::{Path, GenericPath};
+use old_path;
 use result::Result::{Err, Ok};
 use slice::SliceExt;
 use string::String;
@@ -782,7 +782,7 @@ pub trait PathExtensions {
     fn is_dir(&self) -> bool;
 }
 
-impl PathExtensions for path::Path {
+impl PathExtensions for old_path::Path {
     fn stat(&self) -> IoResult<FileStat> { stat(self) }
     fn lstat(&self) -> IoResult<FileStat> { lstat(self) }
     fn exists(&self) -> bool {
diff --git a/src/libstd/old_io/net/pipe.rs b/src/libstd/old_io/net/pipe.rs
index 0da7670c5b4..8c4a10a55d4 100644
--- a/src/libstd/old_io/net/pipe.rs
+++ b/src/libstd/old_io/net/pipe.rs
@@ -23,7 +23,7 @@
 use prelude::v1::*;
 
 use ffi::CString;
-use path::BytesContainer;
+use old_path::BytesContainer;
 use old_io::{Listener, Acceptor, IoResult, TimedOut, standard_error};
 use sys::pipe::UnixAcceptor as UnixAcceptorImp;
 use sys::pipe::UnixListener as UnixListenerImp;
diff --git a/src/libstd/old_io/process.rs b/src/libstd/old_io/process.rs
index 61a07bc8208..27af957e18e 100644
--- a/src/libstd/old_io/process.rs
+++ b/src/libstd/old_io/process.rs
@@ -25,7 +25,7 @@ use old_io::{IoResult, IoError};
 use old_io;
 use libc;
 use os;
-use path::BytesContainer;
+use old_path::BytesContainer;
 use sync::mpsc::{channel, Receiver};
 use sys::fs::FileDesc;
 use sys::process::Process as ProcessImp;
diff --git a/src/libstd/old_io/tempfile.rs b/src/libstd/old_io/tempfile.rs
index 83a42549424..a227116dfae 100644
--- a/src/libstd/old_io/tempfile.rs
+++ b/src/libstd/old_io/tempfile.rs
@@ -17,7 +17,7 @@ use old_io;
 use ops::Drop;
 use option::Option::{None, Some};
 use option::Option;
-use path::{Path, GenericPath};
+use old_path::{Path, GenericPath};
 use rand::{Rng, thread_rng};
 use result::Result::{Ok, Err};
 use str::StrExt;
diff --git a/src/libstd/path/mod.rs b/src/libstd/old_path/mod.rs
index 0d80258d7e0..0d80258d7e0 100644
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/old_path/mod.rs
diff --git a/src/libstd/path/posix.rs b/src/libstd/old_path/posix.rs
index 69f815e3f8b..8bcdd89623d 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/old_path/posix.rs
@@ -445,7 +445,7 @@ mod tests {
     use clone::Clone;
     use iter::IteratorExt;
     use option::Option::{self, Some, None};
-    use path::GenericPath;
+    use old_path::GenericPath;
     use slice::{AsSlice, SliceExt};
     use str::{self, Str, StrExt};
     use string::ToString;
diff --git a/src/libstd/path/windows.rs b/src/libstd/old_path/windows.rs
index fcdebaf2cd3..2e25403220d 100644
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/old_path/windows.rs
@@ -1124,7 +1124,7 @@ mod tests {
     use clone::Clone;
     use iter::IteratorExt;
     use option::Option::{self, Some, None};
-    use path::GenericPath;
+    use old_path::GenericPath;
     use slice::{AsSlice, SliceExt};
     use str::Str;
     use string::ToString;
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index d92f361af0b..36122b16ea0 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -48,7 +48,7 @@ use old_io::{IoResult, IoError};
 use ops::{Drop, FnOnce};
 use option::Option::{Some, None};
 use option::Option;
-use path::{Path, GenericPath, BytesContainer};
+use old_path::{Path, GenericPath, BytesContainer};
 use ptr::PtrExt;
 use ptr;
 use result::Result::{Err, Ok};
@@ -267,7 +267,7 @@ pub fn split_paths<T: BytesContainer>(unparsed: T) -> Vec<Path> {
 ///
 /// ```rust
 /// use std::os;
-/// use std::path::Path;
+/// use std::old_path::Path;
 ///
 /// let key = "PATH";
 /// let mut paths = os::getenv_as_bytes(key).map_or(Vec::new(), os::split_paths);
@@ -470,7 +470,7 @@ pub fn tmpdir() -> Path {
 /// # Example
 /// ```rust
 /// use std::os;
-/// use std::path::Path;
+/// use std::old_path::Path;
 ///
 /// // Assume we're in a path like /home/someuser
 /// let rel_path = Path::new("..");
@@ -500,7 +500,7 @@ pub fn make_absolute(p: &Path) -> IoResult<Path> {
 /// # Example
 /// ```rust
 /// use std::os;
-/// use std::path::Path;
+/// use std::old_path::Path;
 ///
 /// let root = Path::new("/");
 /// assert!(os::change_dir(&root).is_ok());
diff --git a/src/libstd/path.rs b/src/libstd/path.rs
new file mode 100755
index 00000000000..3f4f1ec4c0d
--- /dev/null
+++ b/src/libstd/path.rs
@@ -0,0 +1,2577 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Cross-platform path manipulation.
+//!
+//! This module provides two types, `PathBuf` and `Path` (akin to `String` and
+//! `str`), for working with paths abstractly. These types are thin wrappers
+//! around `OsString` and `OsStr` respectively, meaning that they work directly
+//! on strings according to the local platform's path syntax.
+//!
+//! ## Simple usage
+//!
+//! Path manipulation involves both parsing components from slices and building
+//! new owned paths.
+//!
+//! To parse a path, you can create a `Path` slice from a `str`
+//! slice and start asking questions:
+//!
+//! ```rust
+//! use std::path::Path;
+//!
+//! let path = Path::new("/tmp/foo/bar.txt");
+//! let file = path.file_name();
+//! let extension = path.extension();
+//! let parent_dir = path.parent();
+//! ```
+//!
+//! To build or modify paths, use `PathBuf`:
+//!
+//! ```rust
+//! use std::path::PathBuf;
+//!
+//! let mut path = PathBuf::new("c:\\");
+//! path.push("windows");
+//! path.push("system32");
+//! path.set_extension("dll");
+//! ```
+//!
+//! ## Path components and normalization
+//!
+//! The path APIs are built around the notion of "components", which roughly
+//! correspond to the substrings between path separators (`/` and, on Windows,
+//! `\`). The APIs for path parsing are largely specified in terms of the path's
+//! components, so it's important to clearly understand how those are determined.
+//!
+//! A path can always be reconstructed into an equivalent path by putting
+//! together its components via `push`. Syntactically, the paths may differ by
+//! the normalization described below.
+//!
+//! ### Component types
+//!
+//! Components come in several types:
+//!
+//! * Normal components are the default: standard references to files or
+//! directories. The path `a/b` has two normal components, `a` and `b`.
+//!
+//! * Current directory components represent the `.` character. For example,
+//! `a/.` has a normal component `a` and a current directory component.
+//!
+//! * The root directory component represents a separator that designates
+//!   starting from root. For example, `/a/b` has a root directory component
+//!   followed by normal components `a` and `b`.
+//!
+//! On Windows, two additional component types come into play:
+//!
+//! * Prefix components, of which there is a large variety. For example, `C:`
+//! and `\\server\share` are prefixes. The path `C:windows` has a prefix
+//! component `C:` and a normal component `windows`; the path `C:\windows` has a
+//! prefix component `C:`, a root directory component, and a normal component
+//! `windows`.
+//!
+//! * Empty components, a special case for so-called "verbatim" paths where very
+//! little normalization is allowed. For example, `\\?\C:\` has a "verbatim"
+//! prefix `\\?\C:`, a root component, and an empty component (as a way of
+//! representing the trailing `\`. Such a trailing `\` is in fact the only
+//! situation in which an empty component is produced.
+//!
+//! ### Normalization
+//!
+//! Aside from splitting on the separator(s), there is a small amount of
+//! "normalization":
+//!
+//! * Repeated separators are ignored: `a/b` and `a//b` both have components `a`
+//!   and `b`.
+//!
+//! * Paths ending in a separator are treated as if they has a current directory
+//!   component at the end (or, in verbatim paths, an empty component).  For
+//!   example, while `a/b` has components `a` and `b`, the paths `a/b/` and
+//!   `a/b/.` both have components `a`, `b`, and `.` (current directory).  The
+//!   reason for this normalization is that `a/b` and `a/b/` are treated
+//!   differently in some contexts, but `a/b/` and `a/b/.` are always treated
+//!   the same.
+//!
+//! No other normalization takes place by default. In particular, `a/./b/` and
+//! `a/b` are treated distinctly in terms of components, as are `a/c` and
+//! `a/b/../c`. Further normalization is possible to build on top of the
+//! components APIs, and will be included in this library very soon.
+
+#![unstable(feature = "path")]
+
+use core::prelude::*;
+
+use borrow::BorrowFrom;
+use cmp;
+use iter;
+use mem;
+use ops::{self, Deref};
+use string::CowString;
+use vec::Vec;
+use fmt;
+
+use ffi::{OsStr, OsString, AsOsStr};
+
+use self::platform::{is_sep, is_verbatim_sep, MAIN_SEP_STR, parse_prefix, Prefix};
+
+////////////////////////////////////////////////////////////////////////////////
+// GENERAL NOTES
+////////////////////////////////////////////////////////////////////////////////
+//
+// Parsing in this module is done by directly transmuting OsStr to [u8] slices,
+// taking advantage of the fact that OsStr always encodes ASCII characters
+// as-is.  Eventually, this transmutation should be replaced by direct uses of
+// OsStr APIs for parsing, but it will take a while for those to become
+// available.
+
+////////////////////////////////////////////////////////////////////////////////
+// Platform-specific definitions
+////////////////////////////////////////////////////////////////////////////////
+
+// The following modules give the most basic tools for parsing paths on various
+// platforms. The bulk of the code is devoted to parsing prefixes on Windows.
+
+#[cfg(unix)]
+mod platform {
+    use core::prelude::*;
+    use ffi::OsStr;
+
+    #[inline]
+    pub fn is_sep(b: u8) -> bool {
+        b == b'/'
+    }
+
+    #[inline]
+    pub fn is_verbatim_sep(b: u8) -> bool {
+        b == b'/'
+    }
+
+    pub fn parse_prefix(_: &OsStr) -> Option<Prefix> {
+        None
+    }
+
+    #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+    pub struct Prefix<'a>;
+
+    impl<'a> Prefix<'a> {
+        #[inline]
+        pub fn len(&self) -> usize { 0 }
+        #[inline]
+        pub fn is_verbatim(&self) -> bool { false }
+        #[inline]
+        pub fn is_drive(&self) -> bool { false }
+        #[inline]
+        pub fn has_implicit_root(&self) -> bool { false }
+    }
+
+    pub const MAIN_SEP_STR: &'static str = "/";
+}
+
+#[cfg(windows)]
+mod platform {
+    use core::prelude::*;
+
+    use char::CharExt as UnicodeCharExt;
+    use super::{os_str_as_u8_slice, u8_slice_as_os_str};
+    use ascii::*;
+    use ffi::OsStr;
+
+    #[inline]
+    pub fn is_sep(b: u8) -> bool {
+        b == b'/' || b == b'\\'
+    }
+
+    #[inline]
+    pub fn is_verbatim_sep(b: u8) -> bool {
+        b == b'\\'
+    }
+
+    pub fn parse_prefix<'a>(path: &'a OsStr) -> Option<Prefix> {
+        use self::Prefix::*;
+        unsafe {
+            // The unsafety here stems from converting between &OsStr and &[u8]
+            // and back. This is safe to do because (1) we only look at ASCII
+            // contents of the encoding and (2) new &OsStr values are produced
+            // only from ASCII-bounded slices of existing &OsStr values.
+            let mut path = os_str_as_u8_slice(path);
+
+            if path.starts_with(br"\\") {
+                // \\
+                path = &path[2..];
+                if path.starts_with(br"?\") {
+                    // \\?\
+                    path = &path[2..];
+                    if path.starts_with(br"UNC\") {
+                        // \\?\UNC\server\share
+                        path = &path[4..];
+                        let (server, share) = match parse_two_comps(path, is_verbatim_sep) {
+                            Some((server, share)) => (u8_slice_as_os_str(server),
+                                                      u8_slice_as_os_str(share)),
+                            None => (u8_slice_as_os_str(path),
+                                     u8_slice_as_os_str(&[])),
+                        };
+                        return Some(VerbatimUNC(server, share));
+                    } else {
+                        // \\?\path
+                        let idx = path.position_elem(&b'\\');
+                        if idx == Some(2) && path[1] == b':' {
+                            let c = path[0];
+                            if c.is_ascii() && (c as char).is_alphabetic() {
+                                // \\?\C:\ path
+                                let slice = u8_slice_as_os_str(&path[0..1]);
+                                return Some(VerbatimDisk(slice));
+                            }
+                        }
+                        let slice = &path[.. idx.unwrap_or(path.len())];
+                        return Some(Verbatim(u8_slice_as_os_str(slice)));
+                    }
+                } else if path.starts_with(b".\\") {
+                    // \\.\path
+                    path = &path[2..];
+                    let slice = &path[.. path.position_elem(&b'\\').unwrap_or(path.len())];
+                    return Some(DeviceNS(u8_slice_as_os_str(slice)));
+                }
+                match parse_two_comps(path, is_sep) {
+                    Some((server, share)) if server.len() > 0 && share.len() > 0 => {
+                        // \\server\share
+                        return Some(UNC(u8_slice_as_os_str(server),
+                                        u8_slice_as_os_str(share)));
+                    }
+                    _ => ()
+                }
+            } else if path.len() > 1 && path[1] == b':' {
+                // C:
+                let c = path[0];
+                if c.is_ascii() && (c as char).is_alphabetic() {
+                    return Some(Disk(u8_slice_as_os_str(&path[0..1])));
+                }
+            }
+            return None;
+        }
+
+        fn parse_two_comps(mut path: &[u8], f: fn(u8) -> bool) -> Option<(&[u8], &[u8])> {
+            let first = match path.iter().position(|x| f(*x)) {
+                None => return None,
+                Some(x) => &path[.. x]
+            };
+            path = &path[(first.len()+1)..];
+            let idx = path.iter().position(|x| f(*x));
+            let second = &path[.. idx.unwrap_or(path.len())];
+            Some((first, second))
+        }
+    }
+
+    /// Windows path prefixes.
+    ///
+    /// Windows uses a variety of path styles, including references to drive
+    /// volumes (like `C:`), network shared (like `\\server\share`) and
+    /// others. In addition, some path prefixes are "verbatim", in which case
+    /// `/` is *not* treated as a separator and essentially no normalization is
+    /// performed.
+    #[derive(Copy, Clone, Debug, Hash, Eq)]
+    pub enum Prefix<'a> {
+        /// Prefix `\\?\`, together with the given component immediately following it.
+        Verbatim(&'a OsStr),
+
+        /// Prefix `\\?\UNC\`, with the "server" and "share" components following it.
+        VerbatimUNC(&'a OsStr, &'a OsStr),
+
+        /// Prefix like `\\?\C:\`, for the given drive letter
+        VerbatimDisk(&'a OsStr),
+
+        /// Prefix `\\.\`, together with the given component immediately following it.
+        DeviceNS(&'a OsStr),
+
+        /// Prefix `\\server\share`, with the given "server" and "share" components.
+        UNC(&'a OsStr, &'a OsStr),
+
+        /// Prefix `C:` for the given disk drive.
+        Disk(&'a OsStr),
+    }
+
+    impl<'a> Prefix<'a> {
+        #[inline]
+        pub fn len(&self) -> usize {
+            use self::Prefix::*;
+            fn os_str_len(s: &OsStr) -> usize {
+                os_str_as_u8_slice(s).len()
+            }
+            match *self {
+                Verbatim(x) => 4 + os_str_len(x),
+                VerbatimUNC(x,y) => 8 + os_str_len(x) +
+                    if os_str_len(y) > 0 { 1 + os_str_len(y) }
+                    else { 0 },
+                VerbatimDisk(_) => 6,
+                UNC(x,y) => 2 + os_str_len(x) +
+                    if os_str_len(y) > 0 { 1 + os_str_len(y) }
+                    else { 0 },
+                DeviceNS(x) => 4 + os_str_len(x),
+                Disk(_) => 2
+            }
+
+        }
+
+        #[inline]
+        pub fn is_verbatim(&self) -> bool {
+            use self::Prefix::*;
+            match *self {
+                Verbatim(_) | VerbatimDisk(_) | VerbatimUNC(_, _) => true,
+                _ => false
+            }
+        }
+
+        #[inline]
+        pub fn is_drive(&self) -> bool {
+            match *self {
+                Prefix::Disk(_) => true,
+                _ => false,
+            }
+        }
+
+        #[inline]
+        pub fn has_implicit_root(&self) -> bool {
+            !self.is_drive()
+        }
+    }
+
+    impl<'a> PartialEq for Prefix<'a> {
+        fn eq(&self, other: &Prefix<'a>) -> bool {
+            use self::Prefix::*;
+            match (*self, *other) {
+                (Verbatim(x), Verbatim(y)) => x == y,
+                (VerbatimUNC(x1, x2), VerbatimUNC(y1, y2)) => x1 == y1 && x2 == y2,
+                (VerbatimDisk(x), VerbatimDisk(y)) =>
+                    os_str_as_u8_slice(x).eq_ignore_ascii_case(os_str_as_u8_slice(y)),
+                (DeviceNS(x), DeviceNS(y)) => x == y,
+                (UNC(x1, x2), UNC(y1, y2)) => x1 == y1 && x2 == y2,
+                (Disk(x), Disk(y)) =>
+                    os_str_as_u8_slice(x).eq_ignore_ascii_case(os_str_as_u8_slice(y)),
+                _ => false,
+            }
+        }
+    }
+
+    pub const MAIN_SEP_STR: &'static str = "\\";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Misc helpers
+////////////////////////////////////////////////////////////////////////////////
+
+// Iterate through `iter` while it matches `prefix`; return `None` if `prefix`
+// is not a prefix of `iter`, otherwise return `Some(iter_after_prefix)` giving
+// `iter` after having exhausted `prefix`.
+fn iter_after<A, I, J>(mut iter: I, mut prefix: J) -> Option<I> where
+    I: Iterator<Item=A> + Clone, J: Iterator<Item=A>, A: PartialEq
+{
+    loop {
+        let mut iter_next = iter.clone();
+        match (iter_next.next(), prefix.next()) {
+            (Some(x), Some(y)) => {
+                if x != y { return None }
+            }
+            (Some(_), None) => return Some(iter),
+            (None, None) => return Some(iter),
+            (None, Some(_)) => return None,
+        }
+        iter = iter_next;
+    }
+}
+
+// See note at the top of this module to understand why these are used:
+fn os_str_as_u8_slice(s: &OsStr) -> &[u8] {
+    unsafe { mem::transmute(s) }
+}
+unsafe fn u8_slice_as_os_str(s: &[u8]) -> &OsStr {
+    mem::transmute(s)
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Cross-platform parsing
+////////////////////////////////////////////////////////////////////////////////
+
+/// Says whether the path ends in a separator character and therefore needs to
+/// be treated as if it ended with an additional `.`
+fn has_suffix(s: &[u8], prefix: Option<Prefix>) -> bool {
+    let (prefix_len, verbatim) = if let Some(p) = prefix {
+        (p.len(), p.is_verbatim())
+    } else { (0, false) };
+    if prefix_len > 0 && prefix_len == s.len() && !verbatim { return true; }
+    let mut splits = s[prefix_len..].split(|b| is_sep(*b));
+    let last = splits.next_back().unwrap();
+    let more = splits.next_back().is_some();
+    more && last == b""
+}
+
+/// Says whether the first byte after the prefix is a separator.
+fn has_physical_root(s: &[u8], prefix: Option<Prefix>) -> bool {
+    let path = if let Some(p) = prefix { &s[p.len()..] } else { s };
+    path.len() > 0 && is_sep(path[0])
+}
+
+fn parse_single_component(comp: &[u8]) -> Option<Component> {
+    match comp {
+        b"." => Some(Component::CurDir),
+        b".." => Some(Component::ParentDir),
+        b"" => None,
+        _ => Some(Component::Normal(unsafe { u8_slice_as_os_str(comp) }))
+    }
+}
+
+// basic workhorse for splitting stem and extension
+#[allow(unused_unsafe)] // FIXME
+fn split_file_at_dot(file: &OsStr) -> (Option<&OsStr>, Option<&OsStr>) {
+    unsafe {
+        if os_str_as_u8_slice(file) == b".." { return (Some(file), None) }
+
+        // The unsafety here stems from converting between &OsStr and &[u8]
+        // and back. This is safe to do because (1) we only look at ASCII
+        // contents of the encoding and (2) new &OsStr values are produced
+        // only from ASCII-bounded slices of existing &OsStr values.
+
+        let mut iter = os_str_as_u8_slice(file).rsplitn(1, |b| *b == b'.');
+        let after = iter.next();
+        let before = iter.next();
+        if before == Some(b"") {
+            (Some(file), None)
+        } else {
+            (before.map(|s| u8_slice_as_os_str(s)),
+             after.map(|s| u8_slice_as_os_str(s)))
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// The core iterators
+////////////////////////////////////////////////////////////////////////////////
+
+/// Component parsing works by a double-ended state machine; the cursors at the
+/// front and back of the path each keep track of what parts of the path have
+/// been consumed so far.
+///
+/// Going front to back, a path is made up of a prefix, a root component, a body
+/// (of normal components), and a suffix/emptycomponent (normalized `.` or ``
+/// for a path ending with the separator)
+#[derive(Copy, Clone, PartialEq, PartialOrd, Debug)]
+enum State {
+    Prefix = 0,         // c:
+    Root = 1,           // /
+    Body = 2,           // foo/bar/baz
+    Suffix = 3,         // .
+    Done = 4,
+}
+
+/// A single component of a path.
+///
+/// See the module documentation for an in-depth explanation of components and
+/// their role in the API.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub enum Component<'a> {
+    /// A Windows path prefix, e.g. `C:` or `\server\share`
+    Prefix(&'a OsStr),
+
+    /// An empty component. Only used on Windows for the last component of
+    /// verbatim paths ending with a separator (e.g. the last component of
+    /// `\\?\C:\windows\` but not `\\?\C:\windows` or `C:\windows`).
+    Empty,
+
+    /// The root directory component, appears after any prefix and before anything else
+    RootDir,
+
+    /// A reference to the current directory, i.e. `.`
+    CurDir,
+
+    /// A reference to the parent directory, i.e. `..`
+    ParentDir,
+
+    /// A normal component, i.e. `a` and `b` in `a/b`
+    Normal(&'a OsStr),
+}
+
+impl<'a> Component<'a> {
+    /// Extract the underlying `OsStr` slice
+    pub fn as_os_str(self) -> &'a OsStr {
+        match self {
+            Component::Prefix(path) => path,
+            Component::Empty => OsStr::from_str(""),
+            Component::RootDir => OsStr::from_str(MAIN_SEP_STR),
+            Component::CurDir => OsStr::from_str("."),
+            Component::ParentDir => OsStr::from_str(".."),
+            Component::Normal(path) => path,
+        }
+    }
+}
+
+/// The core iterator giving the components of a path.
+///
+/// See the module documentation for an in-depth explanation of components and
+/// their role in the API.
+#[derive(Clone)]
+pub struct Components<'a> {
+    // The path left to parse components from
+    path: &'a [u8],
+
+    // The prefix as it was originally parsed, if any
+    prefix: Option<Prefix<'a>>,
+
+    // true if path *physically* has a root separator; for most Windows
+    // prefixes, it may have a "logical" rootseparator for the purposes of
+    // normalization, e.g.  \\server\share == \\server\share\.
+    has_physical_root: bool,
+
+    // The iterator is double-ended, and these two states keep track of what has
+    // been produced from either end
+    front: State,
+    back: State,
+}
+
+/// An iterator over the components of a path, as `OsStr` slices.
+#[derive(Clone)]
+pub struct Iter<'a> {
+    inner: Components<'a>
+}
+
+impl<'a> Components<'a> {
+    // how long is the prefix, if any?
+    #[inline]
+    fn prefix_len(&self) -> usize {
+        self.prefix.as_ref().map(Prefix::len).unwrap_or(0)
+    }
+
+    #[inline]
+    fn prefix_verbatim(&self) -> bool {
+        self.prefix.as_ref().map(Prefix::is_verbatim).unwrap_or(false)
+    }
+
+    /// how much of the prefix is left from the point of view of iteration?
+    #[inline]
+    fn prefix_remaining(&self) -> usize {
+        if self.front == State::Prefix { self.prefix_len() }
+        else { 0 }
+    }
+
+    fn prefix_and_root(&self) -> usize {
+        let root = if self.front <= State::Root && self.has_physical_root { 1 } else { 0 };
+        self.prefix_remaining() + root
+    }
+
+    // is the iteration complete?
+    #[inline]
+    fn finished(&self) -> bool {
+        self.front == State::Done || self.back == State::Done || self.front > self.back
+    }
+
+    #[inline]
+    fn is_sep(&self, b: u8) -> bool {
+        if self.prefix_verbatim() {
+            is_verbatim_sep(b)
+        } else {
+            is_sep(b)
+        }
+    }
+
+    /// Extract a slice corresponding to the portion of the path remaining for iteration.
+    pub fn as_path(&self) -> &'a Path {
+        let mut comps = self.clone();
+        if comps.front == State::Body { comps.trim_left(); }
+        if comps.back == State::Body { comps.trim_right(); }
+        if comps.path.is_empty() && comps.front < comps.back && comps.back == State::Suffix {
+            Path::new(".")
+        } else {
+            unsafe { Path::from_u8_slice(comps.path) }
+        }
+    }
+
+    /// Is the *original* path rooted?
+    fn has_root(&self) -> bool {
+        if self.has_physical_root { return true }
+        if let Some(p) = self.prefix {
+            if p.has_implicit_root() { return true }
+        }
+        false
+    }
+
+    // parse a component from the left, saying how many bytes to consume to
+    // remove the component
+    fn parse_next_component(&self) -> (usize, Option<Component<'a>>) {
+        debug_assert!(self.front == State::Body);
+        let (extra, comp) = match self.path.iter().position(|b| self.is_sep(*b)) {
+            None => (0, self.path),
+            Some(i) => (1, &self.path[.. i]),
+        };
+        (comp.len() + extra, parse_single_component(comp))
+    }
+
+    // parse a component from the right, saying how many bytes to consume to
+    // remove the component
+    fn parse_next_component_back(&self) -> (usize, Option<Component<'a>>) {
+        debug_assert!(self.back == State::Body);
+        let start = self.prefix_and_root();
+        let (extra, comp) = match self.path[start..].iter().rposition(|b| self.is_sep(*b)) {
+            None => (0, &self.path[start ..]),
+            Some(i) => (1, &self.path[start + i + 1 ..]),
+        };
+        (comp.len() + extra, parse_single_component(comp))
+    }
+
+    // trim away repeated separators (i.e. emtpy components) on the left
+    fn trim_left(&mut self) {
+        while !self.path.is_empty() {
+            let (size, comp) = self.parse_next_component();
+            if comp.is_some() {
+                return;
+            } else {
+                self.path = &self.path[size ..];
+            }
+        }
+    }
+
+    // trim away repeated separators (i.e. emtpy components) on the right
+    fn trim_right(&mut self) {
+        while self.path.len() > self.prefix_and_root() {
+            let (size, comp) = self.parse_next_component_back();
+            if comp.is_some() {
+                return;
+            } else {
+                self.path = &self.path[.. self.path.len() - size];
+            }
+        }
+    }
+
+    /// Examine the next component without consuming it.
+    pub fn peek(&self) -> Option<Component<'a>> {
+        self.clone().next()
+    }
+}
+
+impl<'a> Iter<'a> {
+    /// Extract a slice corresponding to the portion of the path remaining for iteration.
+    pub fn as_path(&self) -> &'a Path {
+        self.inner.as_path()
+    }
+}
+
+impl<'a> Iterator for Iter<'a> {
+    type Item = &'a OsStr;
+
+    fn next(&mut self) -> Option<&'a OsStr> {
+        self.inner.next().map(Component::as_os_str)
+    }
+}
+
+impl<'a> DoubleEndedIterator for Iter<'a> {
+    fn next_back(&mut self) -> Option<&'a OsStr> {
+        self.inner.next_back().map(Component::as_os_str)
+    }
+}
+
+impl<'a> Iterator for Components<'a> {
+    type Item = Component<'a>;
+
+    fn next(&mut self) -> Option<Component<'a>> {
+        while !self.finished() {
+            match self.front {
+                State::Prefix if self.prefix_len() > 0 => {
+                    self.front = State::Root;
+                    debug_assert!(self.prefix_len() <= self.path.len());
+                    let prefix = &self.path[.. self.prefix_len()];
+                    self.path = &self.path[self.prefix_len() .. ];
+                    return Some(Component::Prefix(unsafe { u8_slice_as_os_str(prefix) }))
+                }
+                State::Prefix => {
+                    self.front = State::Root;
+                }
+                State::Root => {
+                    self.front = State::Body;
+                    if self.has_physical_root {
+                        debug_assert!(self.path.len() > 0);
+                        self.path = &self.path[1..];
+                        return Some(Component::RootDir)
+                    } else if let Some(p) = self.prefix {
+                        if p.has_implicit_root() && !p.is_verbatim() {
+                            return Some(Component::RootDir)
+                        }
+                    }
+                }
+                State::Body if !self.path.is_empty() => {
+                    let (size, comp) = self.parse_next_component();
+                    self.path = &self.path[size ..];
+                    if comp.is_some() { return comp }
+                }
+                State::Body => {
+                    self.front = State::Suffix;
+                }
+                State::Suffix => {
+                    self.front = State::Done;
+                    if self.prefix_verbatim() {
+                        return Some(Component::Empty)
+                    } else {
+                        return Some(Component::CurDir)
+                    }
+                }
+                State::Done => unreachable!()
+            }
+        }
+        None
+    }
+}
+
+impl<'a> DoubleEndedIterator for Components<'a> {
+    fn next_back(&mut self) -> Option<Component<'a>> {
+        while !self.finished() {
+            match self.back {
+                State::Suffix => {
+                    self.back = State::Body;
+                    if self.prefix_verbatim() {
+                        return Some(Component::Empty)
+                    } else {
+                        return Some(Component::CurDir)
+                    }
+                }
+                State::Body if self.path.len() > self.prefix_and_root() => {
+                    let (size, comp) = self.parse_next_component_back();
+                    self.path = &self.path[.. self.path.len() - size];
+                    if comp.is_some() { return comp }
+                }
+                State::Body => {
+                    self.back = State::Root;
+                }
+                State::Root => {
+                    self.back = State::Prefix;
+                    if self.has_physical_root {
+                        self.path = &self.path[.. self.path.len() - 1];
+                        return Some(Component::RootDir)
+                    } else if let Some(p) = self.prefix {
+                        if p.has_implicit_root() && !p.is_verbatim() {
+                            return Some(Component::RootDir)
+                        }
+                    }
+                }
+                State::Prefix if self.prefix_len() > 0 => {
+                    self.back = State::Done;
+                    return Some(Component::Prefix(unsafe {
+                        u8_slice_as_os_str(self.path)
+                    }))
+                }
+                State::Prefix => {
+                    self.back = State::Done;
+                    return None
+                }
+                State::Done => unreachable!()
+            }
+        }
+        None
+    }
+}
+
+fn optional_path(path: &Path) -> Option<&Path> {
+    if path.as_u8_slice().is_empty() { None } else { Some(path) }
+}
+
+impl<'a> cmp::PartialEq for Components<'a> {
+    fn eq(&self, other: &Components<'a>) -> bool {
+        iter::order::eq(self.clone(), other.clone())
+    }
+}
+
+impl<'a> cmp::Eq for Components<'a> {}
+
+impl<'a> cmp::PartialOrd for Components<'a> {
+    fn partial_cmp(&self, other: &Components<'a>) -> Option<cmp::Ordering> {
+        iter::order::partial_cmp(self.clone(), other.clone())
+    }
+}
+
+impl<'a> cmp::Ord for Components<'a> {
+    fn cmp(&self, other: &Components<'a>) -> cmp::Ordering {
+        iter::order::cmp(self.clone(), other.clone())
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Basic types and traits
+////////////////////////////////////////////////////////////////////////////////
+
+/// An owned, mutable path (akin to `String`).
+///
+/// This type provides methods like `push` and `set_extension` that mutate the
+/// path in place. It also implements `Deref` to `Path`, meaning that all
+/// methods on `Path` slices are available on `PathBuf` values as well.
+///
+/// More details about the overall approach can be found in
+/// the module documentation.
+///
+/// # Example
+///
+/// ```rust
+/// use std::path::PathBuf;
+///
+/// let mut path = PathBuf::new("c:\\");
+/// path.push("windows");
+/// path.push("system32");
+/// path.set_extension("dll");
+/// ```
+#[derive(Clone, Hash)]
+pub struct PathBuf {
+    inner: OsString
+}
+
+impl PathBuf {
+    fn as_mut_vec(&mut self) -> &mut Vec<u8> {
+        unsafe { mem::transmute(self) }
+    }
+
+    /// Allocate a `PathBuf` with initial contents given by the
+    /// argument.
+    pub fn new<S: ?Sized + AsOsStr>(s: &S) -> PathBuf {
+        PathBuf { inner: s.as_os_str().to_os_string() }
+    }
+
+    /// Extend `self` with `path`.
+    ///
+    /// If `path` is absolute, it replaces the current path.
+    ///
+    /// On Windows:
+    ///
+    /// * if `path` has a root but no prefix (e.g. `\windows`), it
+    ///   replaces everything except for the prefix (if any) of `self`.
+    /// * if `path` has a prefix but no root, it replaces `self.
+    pub fn push<P: ?Sized>(&mut self, path: &P) where P: AsPath {
+        // in general, a separator is needed if the rightmost byte is not a separator
+        let mut need_sep = self.as_mut_vec().last().map(|c| !is_sep(*c)).unwrap_or(false);
+
+        // in the special case of `C:` on Windows, do *not* add a separator
+        {
+            let comps = self.components();
+            if comps.prefix_len() > 0 &&
+                comps.prefix_len() == comps.path.len() &&
+                comps.prefix.unwrap().is_drive()
+            {
+                need_sep = false
+            }
+        }
+
+        let path = path.as_path();
+
+        // absolute `path` replaces `self`
+        if path.is_absolute() || path.prefix().is_some() {
+            self.as_mut_vec().truncate(0);
+
+        // `path` has a root but no prefix, e.g. `\windows` (Windows only)
+        } else if path.has_root() {
+            let prefix_len = self.components().prefix_remaining();
+            self.as_mut_vec().truncate(prefix_len);
+
+        // `path` is a pure relative path
+        } else if need_sep {
+            self.inner.push_os_str(OsStr::from_str(MAIN_SEP_STR));
+        }
+
+        self.inner.push_os_str(path.as_os_str());
+    }
+
+    /// Truncate `self` to `self.parent()`.
+    ///
+    /// Returns `None` and does nothing if `self.parent()` is `None`.
+    pub fn pop(&mut self) -> bool {
+        match self.parent().map(|p| p.as_u8_slice().len()) {
+            Some(len) => {
+                self.as_mut_vec().truncate(len);
+                true
+            }
+            None => false
+        }
+    }
+
+    /// Updates `self.file_name()` to `file_name`.
+    ///
+    /// If `self.file_name()` was `None`, this is equivalent to pushing
+    /// `file_name`.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use std::path::{Path, PathBuf};
+    ///
+    /// let mut buf = PathBuf::new("/foo/");
+    /// assert!(buf.file_name() == None);
+    /// buf.set_file_name("bar");
+    /// assert!(buf == PathBuf::new("/foo/bar"));
+    /// assert!(buf.file_name().is_some());
+    /// buf.set_file_name("baz.txt");
+    /// assert!(buf == PathBuf::new("/foo/baz.txt"));
+    /// ```
+    pub fn set_file_name<S: ?Sized>(&mut self, file_name: &S) where S: AsOsStr {
+        if self.file_name().is_some() && !self.pop() {
+            // Given that there is a file name, this is reachable only for
+            // Windows paths like c:file or paths like `foo`, but not `c:\` or
+            // `/`.
+            let prefix_len = self.components().prefix_remaining();
+            self.as_mut_vec().truncate(prefix_len);
+        }
+        self.push(file_name.as_os_str());
+    }
+
+    /// Updates `self.extension()` to `extension`.
+    ///
+    /// If `self.file_name()` is `None`, does nothing and returns `false`.
+    ///
+    /// Otherwise, returns `tru`; if `self.exension()` is `None`, the extension
+    /// is added; otherwise it is replaced.
+    pub fn set_extension<S: ?Sized + AsOsStr>(&mut self, extension: &S) -> bool {
+        if self.file_name().is_none() { return false; }
+
+        let mut stem = match self.file_stem() {
+            Some(stem) => stem.to_os_string(),
+            None => OsString::from_str(""),
+        };
+
+        let extension = extension.as_os_str();
+        if os_str_as_u8_slice(extension).len() > 0 {
+            stem.push_os_str(OsStr::from_str("."));
+            stem.push_os_str(extension.as_os_str());
+        }
+        self.set_file_name(&stem);
+
+        true
+    }
+}
+
+impl<'a, P: ?Sized + 'a> iter::FromIterator<&'a P> for PathBuf where P: AsPath {
+    fn from_iter<I: Iterator<Item = &'a P>>(iter: I) -> PathBuf {
+        let mut buf = PathBuf::new("");
+        buf.extend(iter);
+        buf
+    }
+}
+
+impl<'a, P: ?Sized + 'a> iter::Extend<&'a P> for PathBuf where P: AsPath {
+    fn extend<I: Iterator<Item = &'a P>>(&mut self, iter: I) {
+        for p in iter {
+            self.push(p)
+        }
+    }
+}
+
+impl fmt::Debug for PathBuf {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        fmt::Debug::fmt(&**self, formatter)
+    }
+}
+
+impl ops::Deref for PathBuf {
+    type Target = Path;
+
+    fn deref(&self) -> &Path {
+        unsafe { mem::transmute(&self.inner[]) }
+    }
+}
+
+impl BorrowFrom<PathBuf> for Path {
+    fn borrow_from(owned: &PathBuf) -> &Path {
+        owned.deref()
+    }
+}
+
+impl cmp::PartialEq for PathBuf {
+    fn eq(&self, other: &PathBuf) -> bool {
+        self.components() == other.components()
+    }
+}
+
+impl cmp::Eq for PathBuf {}
+
+impl cmp::PartialOrd for PathBuf {
+    fn partial_cmp(&self, other: &PathBuf) -> Option<cmp::Ordering> {
+        self.components().partial_cmp(&other.components())
+    }
+}
+
+impl cmp::Ord for PathBuf {
+    fn cmp(&self, other: &PathBuf) -> cmp::Ordering {
+        self.components().cmp(&other.components())
+    }
+}
+
+/// A slice of a path (akin to `str`).
+///
+/// This type supports a number of operations for inspecting a path, including
+/// breaking the path into its components (separated by `/` or `\`, depending on
+/// the platform), extracting the file name, determining whether the path is
+/// absolute, and so on. More details about the overall approach can be found in
+/// the module documentation.
+///
+/// This is an *unsized* type, meaning that it must always be used with behind a
+/// pointer like `&` or `Box`.
+///
+/// # Example
+///
+/// ```rust
+/// use std::path::Path;
+///
+/// let path = Path::new("/tmp/foo/bar.txt");
+/// let file = path.file_name();
+/// let extension = path.extension();
+/// let parent_dir = path.parent();
+/// ```
+///
+pub struct Path {
+    inner: OsStr
+}
+
+impl Path {
+    // The following (private!) function allows construction of a path from a u8
+    // slice, which is only safe when it is known to follow the OsStr encoding.
+    unsafe fn from_u8_slice(s: &[u8]) -> &Path {
+        mem::transmute(s)
+    }
+    // The following (private!) function reveals the byte encoding used for OsStr.
+    fn as_u8_slice(&self) -> &[u8] {
+        unsafe { mem::transmute(self) }
+    }
+
+    /// Directly wrap a string slice as a `Path` slice.
+    ///
+    /// This is a cost-free conversion.
+    pub fn new<S: ?Sized + AsOsStr>(s: &S) -> &Path {
+        unsafe { mem::transmute(s.as_os_str()) }
+    }
+
+    /// Yield a `&str` slice if the `Path` is valid unicode.
+    ///
+    /// This conversion may entail doing a check for UTF-8 validity.
+    pub fn to_str(&self) -> Option<&str> {
+        self.inner.to_str()
+    }
+
+    /// Convert a `Path` to a `CowString`.
+    ///
+    /// Any non-Unicode sequences are replaced with U+FFFD REPLACEMENT CHARACTER.
+    pub fn to_string_lossy(&self) -> CowString {
+        self.inner.to_string_lossy()
+    }
+
+    /// Convert a `Path` to an owned `PathBuf`.
+    pub fn to_path_buf(&self) -> PathBuf {
+        PathBuf::new(self)
+    }
+
+    /// A path is *absolute* if it is indepedent of the current directory.
+    ///
+    /// * On Unix, a path is absolute if it starts with the root, so
+    /// `is_absolute` and `has_root` are equivalent.
+    ///
+    /// * On Windows, a path is absolute if it has a prefix and starts with the
+    /// root: `c:\windows` is absolute, while `c:temp` and `\temp` are not. In
+    /// other words, `path.is_absolute() == path.prefix().is_some() && path.has_root()`.
+    pub fn is_absolute(&self) -> bool {
+        self.has_root() &&
+            (cfg!(unix) || self.prefix().is_some())
+    }
+
+    /// A path is *relative* if it is not absolute.
+    pub fn is_relative(&self) -> bool {
+        !self.is_absolute()
+    }
+
+    /// Returns the *prefix* of a path, if any.
+    ///
+    /// Prefixes are relevant only for Windows paths, and consist of volumes
+    /// like `C:`, UNC prefixes like `\\server`, and others described in more
+    /// detail in `std::os::windows::PathExt`.
+    pub fn prefix(&self) -> Option<&Path> {
+        let iter = self.components();
+        optional_path(unsafe {
+            Path::from_u8_slice(
+                &self.as_u8_slice()[.. iter.prefix_remaining()])
+        })
+    }
+
+    /// A path has a root if the body of the path begins with the directory separator.
+    ///
+    /// * On Unix, a path has a root if it begins with `/`.
+    ///
+    /// * On Windows, a path has a root if it:
+    ///     * has no prefix and begins with a separator, e.g. `\\windows`
+    ///     * has a prefix followed by a separator, e.g. `c:\windows` but not `c:windows`
+    ///     * has any non-disk prefix, e.g. `\\server\share`
+    pub fn has_root(&self) -> bool {
+         self.components().has_root()
+    }
+
+    /// The path without its final component.
+    ///
+    /// Does nothing, returning `None` if the path consists of just a prefix
+    /// and/or root directory reference.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use std::path::Path;
+    ///
+    /// let path = Path::new("/foo/bar");
+    /// let foo = path.parent().unwrap();
+    /// assert!(foo == Path::new("/foo"));
+    /// let root = foo.parent().unwrap();
+    /// assert!(root == Path::new("/"));
+    /// assert!(root.parent() == None);
+    /// ```
+    pub fn parent(&self) -> Option<&Path> {
+        let mut comps = self.components();
+        let comp = comps.next_back();
+        let rest = optional_path(comps.as_path());
+
+        match (comp, comps.next_back()) {
+            (Some(Component::CurDir), Some(Component::RootDir)) => None,
+            (Some(Component::CurDir), Some(Component::Prefix(_))) => None,
+            (Some(Component::Empty), Some(Component::RootDir)) => None,
+            (Some(Component::Empty), Some(Component::Prefix(_))) => None,
+            (Some(Component::Prefix(_)), None) => None,
+            (Some(Component::RootDir), Some(Component::Prefix(_))) => None,
+            _ => rest
+        }
+    }
+
+    /// The final component of the path, if it is a normal file.
+    ///
+    /// If the path terminates in `.`, `..`, or consists solely or a root of
+    /// prefix, `file` will return `None`.
+    pub fn file_name(&self) -> Option<&OsStr> {
+        self.components().next_back().and_then(|p| match p {
+            Component::Normal(p) => Some(p.as_os_str()),
+            _ => None
+        })
+    }
+
+    /// Returns a path that, when joined onto `base`, yields `self`.
+    pub fn relative_from<'a, P: ?Sized>(&'a self, base: &'a P) -> Option<&Path> where
+        P: AsPath
+    {
+        iter_after(self.components(), base.as_path().components()).map(|c| c.as_path())
+    }
+
+    /// Determines whether `base` is a prefix of `self`.
+    pub fn starts_with<P: ?Sized>(&self, base: &P) -> bool where P: AsPath {
+        iter_after(self.components(), base.as_path().components()).is_some()
+    }
+
+    /// Determines whether `base` is a suffix of `self`.
+    pub fn ends_with<P: ?Sized>(&self, child: &P) -> bool where P: AsPath {
+        iter_after(self.components().rev(), child.as_path().components().rev()).is_some()
+    }
+
+    /// Extract the stem (non-extension) portion of `self.file()`.
+    ///
+    /// The stem is:
+    ///
+    /// * None, if there is no file name;
+    /// * The entire file name if there is no embedded `.`;
+    /// * The entire file name if the file name begins with `.` and has no other `.`s within;
+    /// * Otherwise, the portion of the file name before the final `.`
+    pub fn file_stem(&self) -> Option<&OsStr> {
+        self.file_name().map(split_file_at_dot).and_then(|(before, after)| before.or(after))
+    }
+
+    /// Extract the extension of `self.file()`, if possible.
+    ///
+    /// The extension is:
+    ///
+    /// * None, if there is no file name;
+    /// * None, if there is no embedded `.`;
+    /// * None, if the file name begins with `.` and has no other `.`s within;
+    /// * Otherwise, the portion of the file name after the final `.`
+    pub fn extension(&self) -> Option<&OsStr> {
+        self.file_name().map(split_file_at_dot).and_then(|(before, after)| before.and(after))
+    }
+
+    /// Creates an owned `PathBuf` with `path` adjoined to `self`.
+    ///
+    /// See `PathBuf::push` for more details on what it means to adjoin a path.
+    pub fn join<P: ?Sized>(&self, path: &P) -> PathBuf where P: AsPath {
+        let mut buf = self.to_path_buf();
+        buf.push(path);
+        buf
+    }
+
+    /// Creates an owned `PathBuf` like `self` but with the given file name.
+    ///
+    /// See `PathBuf::set_file_name` for more details.
+    pub fn with_file_name<S: ?Sized>(&self, file_name: &S) -> PathBuf where S: AsOsStr {
+        let mut buf = self.to_path_buf();
+        buf.set_file_name(file_name);
+        buf
+    }
+
+    /// Creates an owned `PathBuf` like `self` but with the given extension.
+    ///
+    /// See `PathBuf::set_extension` for more details.
+    pub fn with_extension<S: ?Sized>(&self, extension: &S) -> PathBuf where S: AsOsStr {
+        let mut buf = self.to_path_buf();
+        buf.set_extension(extension);
+        buf
+    }
+
+    /// Produce an iterator over the components of the path.
+    pub fn components(&self) -> Components {
+        let prefix = parse_prefix(self.as_os_str());
+        Components {
+            path: self.as_u8_slice(),
+            prefix: prefix,
+            has_physical_root: has_physical_root(self.as_u8_slice(), prefix),
+            front: State::Prefix,
+            back: if has_suffix(self.as_u8_slice(), prefix) { State::Suffix }
+                  else { State::Body },
+        }
+    }
+
+    /// Produce an iterator over the path's components viewed as `OsStr` slices.
+    pub fn iter(&self) -> Iter {
+        Iter { inner: self.components() }
+    }
+
+    /// Returns an object that implements `Display` for safely printing paths
+    /// that may contain non-Unicode data.
+    pub fn display(&self) -> Display {
+        Display { path: self }
+    }
+}
+
+impl AsOsStr for Path {
+    fn as_os_str(&self) -> &OsStr {
+        &self.inner
+    }
+}
+
+impl fmt::Debug for Path {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        self.inner.fmt(formatter)
+    }
+}
+
+/// Helper struct for safely printing paths with `format!()` and `{}`
+pub struct Display<'a> {
+    path: &'a Path
+}
+
+impl<'a> fmt::Debug for Display<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(&self.path.to_string_lossy(), f)
+    }
+}
+
+impl<'a> fmt::Display for Display<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&self.path.to_string_lossy(), f)
+    }
+}
+
+impl cmp::PartialEq for Path {
+    fn eq(&self, other: &Path) -> bool {
+        iter::order::eq(self.components(), other.components())
+    }
+}
+
+impl cmp::Eq for Path {}
+
+impl cmp::PartialOrd for Path {
+    fn partial_cmp(&self, other: &Path) -> Option<cmp::Ordering> {
+        self.components().partial_cmp(&other.components())
+    }
+}
+
+impl cmp::Ord for Path {
+    fn cmp(&self, other: &Path) -> cmp::Ordering {
+        self.components().cmp(&other.components())
+    }
+}
+
+/// Freely convertible to a `Path`.
+pub trait AsPath {
+    /// Convert to a `Path`.
+    fn as_path(&self) -> &Path;
+}
+
+impl<T: AsOsStr + ?Sized> AsPath for T {
+    fn as_path(&self) -> &Path { Path::new(self.as_os_str()) }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ffi::OsStr;
+    use core::prelude::*;
+    use string::{ToString, String};
+    use vec::Vec;
+
+    macro_rules! t(
+        ($path:expr, iter: $iter:expr) => (
+            {
+                let path = Path::new($path);
+
+                // Forward iteration
+                let comps = path.iter()
+                    .map(|p| p.to_string_lossy().into_owned())
+                    .collect::<Vec<String>>();
+                let exp: &[&str] = &$iter;
+                let exps = exp.iter().map(|s| s.to_string()).collect::<Vec<String>>();
+                assert!(comps == exps, "iter: Expected {:?}, found {:?}",
+                        exps, comps);
+
+                // Reverse iteration
+                let comps = Path::new($path).iter().rev()
+                    .map(|p| p.to_string_lossy().into_owned())
+                    .collect::<Vec<String>>();
+                let exps = exps.into_iter().rev().collect::<Vec<String>>();
+                assert!(comps == exps, "iter().rev(): Expected {:?}, found {:?}",
+                        exps, comps);
+            }
+        );
+
+        ($path:expr, has_root: $has_root:expr, is_absolute: $is_absolute:expr) => (
+            {
+                let path = Path::new($path);
+
+                let act_root = path.has_root();
+                assert!(act_root == $has_root, "has_root: Expected {:?}, found {:?}",
+                        $has_root, act_root);
+
+                let act_abs = path.is_absolute();
+                assert!(act_abs == $is_absolute, "is_absolute: Expected {:?}, found {:?}",
+                        $is_absolute, act_abs);
+            }
+        );
+
+        ($path:expr, parent: $parent:expr, file_name: $file:expr) => (
+            {
+                let path = Path::new($path);
+
+                let parent = path.parent().map(|p| p.to_str().unwrap());
+                let exp_parent: Option<&str> = $parent;
+                assert!(parent == exp_parent, "parent: Expected {:?}, found {:?}",
+                        exp_parent, parent);
+
+                let file = path.file_name().map(|p| p.to_str().unwrap());
+                let exp_file: Option<&str> = $file;
+                assert!(file == exp_file, "file_name: Expected {:?}, found {:?}",
+                        exp_file, file);
+            }
+        );
+
+        ($path:expr, file_stem: $file_stem:expr, extension: $extension:expr) => (
+            {
+                let path = Path::new($path);
+
+                let stem = path.file_stem().map(|p| p.to_str().unwrap());
+                let exp_stem: Option<&str> = $file_stem;
+                assert!(stem == exp_stem, "file_stem: Expected {:?}, found {:?}",
+                        exp_stem, stem);
+
+                let ext = path.extension().map(|p| p.to_str().unwrap());
+                let exp_ext: Option<&str> = $extension;
+                assert!(ext == exp_ext, "extension: Expected {:?}, found {:?}",
+                        exp_ext, ext);
+            }
+        );
+
+        ($path:expr, iter: $iter:expr,
+                     has_root: $has_root:expr, is_absolute: $is_absolute:expr,
+                     parent: $parent:expr, file_name: $file:expr,
+                     file_stem: $file_stem:expr, extension: $extension:expr) => (
+            {
+                t!($path, iter: $iter);
+                t!($path, has_root: $has_root, is_absolute: $is_absolute);
+                t!($path, parent: $parent, file_name: $file);
+                t!($path, file_stem: $file_stem, extension: $extension);
+            }
+        );
+    );
+
+    #[test]
+    #[cfg(unix)]
+    pub fn test_decompositions_unix() {
+        t!("",
+           iter: [],
+           has_root: false,
+           is_absolute: false,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("foo",
+           iter: ["foo"],
+           has_root: false,
+           is_absolute: false,
+           parent: None,
+           file_name: Some("foo"),
+           file_stem: Some("foo"),
+           extension: None
+           );
+
+        t!("/",
+           iter: ["/", "."],
+           has_root: true,
+           is_absolute: true,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("/foo",
+           iter: ["/", "foo"],
+           has_root: true,
+           is_absolute: true,
+           parent: Some("/"),
+           file_name: Some("foo"),
+           file_stem: Some("foo"),
+           extension: None
+           );
+
+        t!("foo/",
+           iter: ["foo", "."],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("foo"),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("/foo/",
+           iter: ["/", "foo", "."],
+           has_root: true,
+           is_absolute: true,
+           parent: Some("/foo"),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("foo/bar",
+           iter: ["foo", "bar"],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("foo"),
+           file_name: Some("bar"),
+           file_stem: Some("bar"),
+           extension: None
+           );
+
+        t!("/foo/bar",
+           iter: ["/", "foo", "bar"],
+           has_root: true,
+           is_absolute: true,
+           parent: Some("/foo"),
+           file_name: Some("bar"),
+           file_stem: Some("bar"),
+           extension: None
+           );
+
+        t!("///foo///",
+           iter: ["/", "foo", "."],
+           has_root: true,
+           is_absolute: true,
+           parent: Some("///foo"),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("///foo///bar",
+           iter: ["/", "foo", "bar"],
+           has_root: true,
+           is_absolute: true,
+           parent: Some("///foo"),
+           file_name: Some("bar"),
+           file_stem: Some("bar"),
+           extension: None
+           );
+
+        t!("./.",
+           iter: [".", "."],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("."),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("./.",
+           iter: [".", "."],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("."),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("/..",
+           iter: ["/", ".."],
+           has_root: true,
+           is_absolute: true,
+           parent: Some("/"),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("../",
+           iter: ["..", "."],
+           has_root: false,
+           is_absolute: false,
+           parent: Some(".."),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("foo/.",
+           iter: ["foo", "."],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("foo"),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("foo/..",
+           iter: ["foo", ".."],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("foo"),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("foo/./",
+           iter: ["foo", ".", "."],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("foo/."),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("foo/./bar",
+           iter: ["foo", ".", "bar"],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("foo/."),
+           file_name: Some("bar"),
+           file_stem: Some("bar"),
+           extension: None
+           );
+
+        t!("foo/../",
+           iter: ["foo", "..", "."],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("foo/.."),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("foo/../bar",
+           iter: ["foo", "..", "bar"],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("foo/.."),
+           file_name: Some("bar"),
+           file_stem: Some("bar"),
+           extension: None
+           );
+
+        t!("./a",
+           iter: [".", "a"],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("."),
+           file_name: Some("a"),
+           file_stem: Some("a"),
+           extension: None
+           );
+
+        t!(".",
+           iter: ["."],
+           has_root: false,
+           is_absolute: false,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("./",
+           iter: [".", "."],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("."),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("a/b",
+           iter: ["a", "b"],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("a"),
+           file_name: Some("b"),
+           file_stem: Some("b"),
+           extension: None
+           );
+
+        t!("a//b",
+           iter: ["a", "b"],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("a"),
+           file_name: Some("b"),
+           file_stem: Some("b"),
+           extension: None
+           );
+
+        t!("a/./b",
+           iter: ["a", ".", "b"],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("a/."),
+           file_name: Some("b"),
+           file_stem: Some("b"),
+           extension: None
+           );
+
+        t!("a/b/c",
+           iter: ["a", "b", "c"],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("a/b"),
+           file_name: Some("c"),
+           file_stem: Some("c"),
+           extension: None
+           );
+    }
+
+    #[test]
+    #[cfg(windows)]
+    pub fn test_decompositions_windows() {
+        t!("",
+           iter: [],
+           has_root: false,
+           is_absolute: false,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("foo",
+           iter: ["foo"],
+           has_root: false,
+           is_absolute: false,
+           parent: None,
+           file_name: Some("foo"),
+           file_stem: Some("foo"),
+           extension: None
+           );
+
+        t!("/",
+           iter: ["\\", "."],
+           has_root: true,
+           is_absolute: false,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("\\",
+           iter: ["\\", "."],
+           has_root: true,
+           is_absolute: false,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("c:",
+           iter: ["c:", "."],
+           has_root: false,
+           is_absolute: false,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("c:\\",
+           iter: ["c:", "\\", "."],
+           has_root: true,
+           is_absolute: true,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("c:\\",
+           iter: ["c:", "\\", "."],
+           has_root: true,
+           is_absolute: true,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("c:/",
+           iter: ["c:", "\\", "."],
+           has_root: true,
+           is_absolute: true,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("/foo",
+           iter: ["\\", "foo"],
+           has_root: true,
+           is_absolute: false,
+           parent: Some("/"),
+           file_name: Some("foo"),
+           file_stem: Some("foo"),
+           extension: None
+           );
+
+        t!("foo/",
+           iter: ["foo", "."],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("foo"),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("/foo/",
+           iter: ["\\", "foo", "."],
+           has_root: true,
+           is_absolute: false,
+           parent: Some("/foo"),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("foo/bar",
+           iter: ["foo", "bar"],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("foo"),
+           file_name: Some("bar"),
+           file_stem: Some("bar"),
+           extension: None
+           );
+
+        t!("/foo/bar",
+           iter: ["\\", "foo", "bar"],
+           has_root: true,
+           is_absolute: false,
+           parent: Some("/foo"),
+           file_name: Some("bar"),
+           file_stem: Some("bar"),
+           extension: None
+           );
+
+        t!("///foo///",
+           iter: ["\\", "foo", "."],
+           has_root: true,
+           is_absolute: false,
+           parent: Some("///foo"),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("///foo///bar",
+           iter: ["\\", "foo", "bar"],
+           has_root: true,
+           is_absolute: false,
+           parent: Some("///foo"),
+           file_name: Some("bar"),
+           file_stem: Some("bar"),
+           extension: None
+           );
+
+        t!("./.",
+           iter: [".", "."],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("."),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("./.",
+           iter: [".", "."],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("."),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("/..",
+           iter: ["\\", ".."],
+           has_root: true,
+           is_absolute: false,
+           parent: Some("/"),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("../",
+           iter: ["..", "."],
+           has_root: false,
+           is_absolute: false,
+           parent: Some(".."),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("foo/.",
+           iter: ["foo", "."],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("foo"),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("foo/..",
+           iter: ["foo", ".."],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("foo"),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("foo/./",
+           iter: ["foo", ".", "."],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("foo/."),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("foo/./bar",
+           iter: ["foo", ".", "bar"],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("foo/."),
+           file_name: Some("bar"),
+           file_stem: Some("bar"),
+           extension: None
+           );
+
+        t!("foo/../",
+           iter: ["foo", "..", "."],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("foo/.."),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("foo/../bar",
+           iter: ["foo", "..", "bar"],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("foo/.."),
+           file_name: Some("bar"),
+           file_stem: Some("bar"),
+           extension: None
+           );
+
+        t!("./a",
+           iter: [".", "a"],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("."),
+           file_name: Some("a"),
+           file_stem: Some("a"),
+           extension: None
+           );
+
+        t!(".",
+           iter: ["."],
+           has_root: false,
+           is_absolute: false,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("./",
+           iter: [".", "."],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("."),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("a/b",
+           iter: ["a", "b"],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("a"),
+           file_name: Some("b"),
+           file_stem: Some("b"),
+           extension: None
+           );
+
+        t!("a//b",
+           iter: ["a", "b"],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("a"),
+           file_name: Some("b"),
+           file_stem: Some("b"),
+           extension: None
+           );
+
+        t!("a/./b",
+           iter: ["a", ".", "b"],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("a/."),
+           file_name: Some("b"),
+           file_stem: Some("b"),
+           extension: None
+           );
+
+        t!("a/b/c",
+           iter: ["a", "b", "c"],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("a/b"),
+           file_name: Some("c"),
+           file_stem: Some("c"),
+           extension: None);
+
+        t!("a\\b\\c",
+           iter: ["a", "b", "c"],
+           has_root: false,
+           is_absolute: false,
+           parent: Some("a\\b"),
+           file_name: Some("c"),
+           file_stem: Some("c"),
+           extension: None
+           );
+
+        t!("\\a",
+           iter: ["\\", "a"],
+           has_root: true,
+           is_absolute: false,
+           parent: Some("\\"),
+           file_name: Some("a"),
+           file_stem: Some("a"),
+           extension: None
+           );
+
+        t!("c:\\foo.txt",
+           iter: ["c:", "\\", "foo.txt"],
+           has_root: true,
+           is_absolute: true,
+           parent: Some("c:\\"),
+           file_name: Some("foo.txt"),
+           file_stem: Some("foo"),
+           extension: Some("txt")
+           );
+
+        t!("\\\\server\\share\\foo.txt",
+           iter: ["\\\\server\\share", "\\", "foo.txt"],
+           has_root: true,
+           is_absolute: true,
+           parent: Some("\\\\server\\share\\"),
+           file_name: Some("foo.txt"),
+           file_stem: Some("foo"),
+           extension: Some("txt")
+           );
+
+        t!("\\\\server\\share",
+           iter: ["\\\\server\\share", "\\", "."],
+           has_root: true,
+           is_absolute: true,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("\\\\server",
+           iter: ["\\", "server"],
+           has_root: true,
+           is_absolute: false,
+           parent: Some("\\"),
+           file_name: Some("server"),
+           file_stem: Some("server"),
+           extension: None
+           );
+
+        t!("\\\\?\\bar\\foo.txt",
+           iter: ["\\\\?\\bar", "\\", "foo.txt"],
+           has_root: true,
+           is_absolute: true,
+           parent: Some("\\\\?\\bar\\"),
+           file_name: Some("foo.txt"),
+           file_stem: Some("foo"),
+           extension: Some("txt")
+           );
+
+        t!("\\\\?\\bar",
+           iter: ["\\\\?\\bar"],
+           has_root: true,
+           is_absolute: true,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("\\\\?\\",
+           iter: ["\\\\?\\"],
+           has_root: true,
+           is_absolute: true,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("\\\\?\\UNC\\server\\share\\foo.txt",
+           iter: ["\\\\?\\UNC\\server\\share", "\\", "foo.txt"],
+           has_root: true,
+           is_absolute: true,
+           parent: Some("\\\\?\\UNC\\server\\share\\"),
+           file_name: Some("foo.txt"),
+           file_stem: Some("foo"),
+           extension: Some("txt")
+           );
+
+        t!("\\\\?\\UNC\\server",
+           iter: ["\\\\?\\UNC\\server"],
+           has_root: true,
+           is_absolute: true,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("\\\\?\\UNC\\",
+           iter: ["\\\\?\\UNC\\"],
+           has_root: true,
+           is_absolute: true,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("\\\\?\\C:\\foo.txt",
+           iter: ["\\\\?\\C:", "\\", "foo.txt"],
+           has_root: true,
+           is_absolute: true,
+           parent: Some("\\\\?\\C:\\"),
+           file_name: Some("foo.txt"),
+           file_stem: Some("foo"),
+           extension: Some("txt")
+           );
+
+
+        t!("\\\\?\\C:\\",
+           iter: ["\\\\?\\C:", "\\", ""],
+           has_root: true,
+           is_absolute: true,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+
+        t!("\\\\?\\C:",
+           iter: ["\\\\?\\C:"],
+           has_root: true,
+           is_absolute: true,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+
+        t!("\\\\?\\foo/bar",
+           iter: ["\\\\?\\foo/bar"],
+           has_root: true,
+           is_absolute: true,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+
+        t!("\\\\?\\C:/foo",
+           iter: ["\\\\?\\C:/foo"],
+           has_root: true,
+           is_absolute: true,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+
+        t!("\\\\.\\foo\\bar",
+           iter: ["\\\\.\\foo", "\\", "bar"],
+           has_root: true,
+           is_absolute: true,
+           parent: Some("\\\\.\\foo\\"),
+           file_name: Some("bar"),
+           file_stem: Some("bar"),
+           extension: None
+           );
+
+
+        t!("\\\\.\\foo",
+           iter: ["\\\\.\\foo", "\\", "."],
+           has_root: true,
+           is_absolute: true,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+
+        t!("\\\\.\\foo/bar",
+           iter: ["\\\\.\\foo/bar", "\\", "."],
+           has_root: true,
+           is_absolute: true,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+
+        t!("\\\\.\\foo\\bar/baz",
+           iter: ["\\\\.\\foo", "\\", "bar", "baz"],
+           has_root: true,
+           is_absolute: true,
+           parent: Some("\\\\.\\foo\\bar"),
+           file_name: Some("baz"),
+           file_stem: Some("baz"),
+           extension: None
+           );
+
+
+        t!("\\\\.\\",
+           iter: ["\\\\.\\", "\\", "."],
+           has_root: true,
+           is_absolute: true,
+           parent: None,
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+
+        t!("\\\\?\\a\\b\\",
+           iter: ["\\\\?\\a", "\\", "b", ""],
+           has_root: true,
+           is_absolute: true,
+           parent: Some("\\\\?\\a\\b"),
+           file_name: None,
+           file_stem: None,
+           extension: None
+           );
+    }
+
+    #[test]
+    pub fn test_stem_ext() {
+        t!("foo",
+           file_stem: Some("foo"),
+           extension: None
+           );
+
+        t!("foo.",
+           file_stem: Some("foo"),
+           extension: Some("")
+           );
+
+        t!(".foo",
+           file_stem: Some(".foo"),
+           extension: None
+           );
+
+        t!("foo.txt",
+           file_stem: Some("foo"),
+           extension: Some("txt")
+           );
+
+        t!("foo.bar.txt",
+           file_stem: Some("foo.bar"),
+           extension: Some("txt")
+           );
+
+        t!("foo.bar.",
+           file_stem: Some("foo.bar"),
+           extension: Some("")
+           );
+
+        t!(".",
+           file_stem: None,
+           extension: None
+           );
+
+        t!("..",
+           file_stem: None,
+           extension: None
+           );
+
+        t!("",
+           file_stem: None,
+           extension: None
+           );
+    }
+
+    #[test]
+    pub fn test_push() {
+        macro_rules! tp(
+            ($path:expr, $push:expr, $expected:expr) => ( {
+                let mut actual = PathBuf::new($path);
+                actual.push($push);
+                assert!(actual.to_str() == Some($expected),
+                        "pushing {:?} onto {:?}: Expected {:?}, got {:?}",
+                        $push, $path, $expected, actual.to_str().unwrap());
+            });
+        );
+
+        if cfg!(unix) {
+            tp!("", "foo", "foo");
+            tp!("foo", "bar", "foo/bar");
+            tp!("foo/", "bar", "foo/bar");
+            tp!("foo//", "bar", "foo//bar");
+            tp!("foo/.", "bar", "foo/./bar");
+            tp!("foo./.", "bar", "foo././bar");
+            tp!("foo", "", "foo/");
+            tp!("foo", ".", "foo/.");
+            tp!("foo", "..", "foo/..");
+            tp!("foo", "/", "/");
+            tp!("/foo/bar", "/", "/");
+            tp!("/foo/bar", "/baz", "/baz");
+            tp!("/foo/bar", "./baz", "/foo/bar/./baz");
+        } else {
+            tp!("", "foo", "foo");
+            tp!("foo", "bar", r"foo\bar");
+            tp!("foo/", "bar", r"foo/bar");
+            tp!(r"foo\", "bar", r"foo\bar");
+            tp!("foo//", "bar", r"foo//bar");
+            tp!(r"foo\\", "bar", r"foo\\bar");
+            tp!("foo/.", "bar", r"foo/.\bar");
+            tp!("foo./.", "bar", r"foo./.\bar");
+            tp!(r"foo\.", "bar", r"foo\.\bar");
+            tp!(r"foo.\.", "bar", r"foo.\.\bar");
+            tp!("foo", "", "foo\\");
+            tp!("foo", ".", r"foo\.");
+            tp!("foo", "..", r"foo\..");
+            tp!("foo", "/", "/");
+            tp!("foo", r"\", r"\");
+            tp!("/foo/bar", "/", "/");
+            tp!(r"\foo\bar", r"\", r"\");
+            tp!("/foo/bar", "/baz", "/baz");
+            tp!("/foo/bar", r"\baz", r"\baz");
+            tp!("/foo/bar", "./baz", r"/foo/bar\./baz");
+            tp!("/foo/bar", r".\baz", r"/foo/bar\.\baz");
+
+            tp!("c:\\", "windows", "c:\\windows");
+            tp!("c:", "windows", "c:windows");
+
+            tp!("a\\b\\c", "d", "a\\b\\c\\d");
+            tp!("\\a\\b\\c", "d", "\\a\\b\\c\\d");
+            tp!("a\\b", "c\\d", "a\\b\\c\\d");
+            tp!("a\\b", "\\c\\d", "\\c\\d");
+            tp!("a\\b", ".", "a\\b\\.");
+            tp!("a\\b", "..\\c", "a\\b\\..\\c");
+            tp!("a\\b", "C:a.txt", "C:a.txt");
+            tp!("a\\b", "C:\\a.txt", "C:\\a.txt");
+            tp!("C:\\a", "C:\\b.txt", "C:\\b.txt");
+            tp!("C:\\a\\b\\c", "C:d", "C:d");
+            tp!("C:a\\b\\c", "C:d", "C:d");
+            tp!("C:", r"a\b\c", r"C:a\b\c");
+            tp!("C:", r"..\a", r"C:..\a");
+            tp!("\\\\server\\share\\foo", "bar", "\\\\server\\share\\foo\\bar");
+            tp!("\\\\server\\share\\foo", "C:baz", "C:baz");
+            tp!("\\\\?\\C:\\a\\b", "C:c\\d", "C:c\\d");
+            tp!("\\\\?\\C:a\\b", "C:c\\d", "C:c\\d");
+            tp!("\\\\?\\C:\\a\\b", "C:\\c\\d", "C:\\c\\d");
+            tp!("\\\\?\\foo\\bar", "baz", "\\\\?\\foo\\bar\\baz");
+            tp!("\\\\?\\UNC\\server\\share\\foo", "bar", "\\\\?\\UNC\\server\\share\\foo\\bar");
+            tp!("\\\\?\\UNC\\server\\share", "C:\\a", "C:\\a");
+            tp!("\\\\?\\UNC\\server\\share", "C:a", "C:a");
+
+            // Note: modified from old path API
+            tp!("\\\\?\\UNC\\server", "foo", "\\\\?\\UNC\\server\\foo");
+
+            tp!("C:\\a", "\\\\?\\UNC\\server\\share", "\\\\?\\UNC\\server\\share");
+            tp!("\\\\.\\foo\\bar", "baz", "\\\\.\\foo\\bar\\baz");
+            tp!("\\\\.\\foo\\bar", "C:a", "C:a");
+            // again, not sure about the following, but I'm assuming \\.\ should be verbatim
+            tp!("\\\\.\\foo", "..\\bar", "\\\\.\\foo\\..\\bar");
+
+            tp!("\\\\?\\C:", "foo", "\\\\?\\C:\\foo"); // this is a weird one
+        }
+    }
+
+    #[test]
+    pub fn test_pop() {
+        macro_rules! tp(
+            ($path:expr, $expected:expr, $output:expr) => ( {
+                let mut actual = PathBuf::new($path);
+                let output = actual.pop();
+                assert!(actual.to_str() == Some($expected) && output == $output,
+                        "popping from {:?}: Expected {:?}/{:?}, got {:?}/{:?}",
+                        $path, $expected, $output,
+                        actual.to_str().unwrap(), output);
+            });
+        );
+
+        tp!("", "", false);
+        tp!("/", "/", false);
+        tp!("foo", "foo", false);
+        tp!(".", ".", false);
+        tp!("/foo", "/", true);
+        tp!("/foo/bar", "/foo", true);
+        tp!("foo/bar", "foo", true);
+        tp!("foo/.", "foo", true);
+        tp!("foo//bar", "foo", true);
+
+        if cfg!(windows) {
+            tp!("a\\b\\c", "a\\b", true);
+            tp!("\\a", "\\", true);
+            tp!("\\", "\\", false);
+
+            tp!("C:\\a\\b", "C:\\a", true);
+            tp!("C:\\a", "C:\\", true);
+            tp!("C:\\", "C:\\", false);
+            tp!("C:a\\b", "C:a", true);
+            tp!("C:a", "C:", true);
+            tp!("C:", "C:", false);
+            tp!("\\\\server\\share\\a\\b", "\\\\server\\share\\a", true);
+            tp!("\\\\server\\share\\a", "\\\\server\\share\\", true);
+            tp!("\\\\server\\share", "\\\\server\\share", false);
+            tp!("\\\\?\\a\\b\\c", "\\\\?\\a\\b", true);
+            tp!("\\\\?\\a\\b", "\\\\?\\a\\", true);
+            tp!("\\\\?\\a", "\\\\?\\a", false);
+            tp!("\\\\?\\C:\\a\\b", "\\\\?\\C:\\a", true);
+            tp!("\\\\?\\C:\\a", "\\\\?\\C:\\", true);
+            tp!("\\\\?\\C:\\", "\\\\?\\C:\\", false);
+            tp!("\\\\?\\UNC\\server\\share\\a\\b", "\\\\?\\UNC\\server\\share\\a", true);
+            tp!("\\\\?\\UNC\\server\\share\\a", "\\\\?\\UNC\\server\\share\\", true);
+            tp!("\\\\?\\UNC\\server\\share", "\\\\?\\UNC\\server\\share", false);
+            tp!("\\\\.\\a\\b\\c", "\\\\.\\a\\b", true);
+            tp!("\\\\.\\a\\b", "\\\\.\\a\\", true);
+            tp!("\\\\.\\a", "\\\\.\\a", false);
+
+            tp!("\\\\?\\a\\b\\", "\\\\?\\a\\b", true);
+        }
+    }
+
+    #[test]
+    pub fn test_set_file_name() {
+        macro_rules! tfn(
+                ($path:expr, $file:expr, $expected:expr) => ( {
+                let mut p = PathBuf::new($path);
+                p.set_file_name($file);
+                assert!(p.to_str() == Some($expected),
+                        "setting file name of {:?} to {:?}: Expected {:?}, got {:?}",
+                        $path, $file, $expected,
+                        p.to_str().unwrap());
+            });
+        );
+
+        tfn!("foo", "foo", "foo");
+        tfn!("foo", "bar", "bar");
+        tfn!("foo", "", "");
+        tfn!("", "foo", "foo");
+        if cfg!(unix) {
+            tfn!(".", "foo", "./foo");
+            tfn!("foo/", "bar", "foo/bar");
+            tfn!("foo/.", "bar", "foo/./bar");
+            tfn!("..", "foo", "../foo");
+            tfn!("foo/..", "bar", "foo/../bar");
+            tfn!("/", "foo", "/foo");
+        } else {
+            tfn!(".", "foo", r".\foo");
+            tfn!(r"foo\", "bar", r"foo\bar");
+            tfn!(r"foo\.", "bar", r"foo\.\bar");
+            tfn!("..", "foo", r"..\foo");
+            tfn!(r"foo\..", "bar", r"foo\..\bar");
+            tfn!(r"\", "foo", r"\foo");
+        }
+    }
+
+    #[test]
+    pub fn test_set_extension() {
+        macro_rules! tfe(
+                ($path:expr, $ext:expr, $expected:expr, $output:expr) => ( {
+                let mut p = PathBuf::new($path);
+                let output = p.set_extension($ext);
+                assert!(p.to_str() == Some($expected) && output == $output,
+                        "setting extension of {:?} to {:?}: Expected {:?}/{:?}, got {:?}/{:?}",
+                        $path, $ext, $expected, $output,
+                        p.to_str().unwrap(), output);
+            });
+        );
+
+        tfe!("foo", "txt", "foo.txt", true);
+        tfe!("foo.bar", "txt", "foo.txt", true);
+        tfe!("foo.bar.baz", "txt", "foo.bar.txt", true);
+        tfe!(".test", "txt", ".test.txt", true);
+        tfe!("foo.txt", "", "foo", true);
+        tfe!("foo", "", "foo", true);
+        tfe!("", "foo", "", false);
+        tfe!(".", "foo", ".", false);
+        tfe!("foo/", "bar", "foo/", false);
+        tfe!("foo/.", "bar", "foo/.", false);
+        tfe!("..", "foo", "..",  false);
+        tfe!("foo/..", "bar", "foo/..", false);
+        tfe!("/", "foo", "/", false);
+    }
+
+    #[test]
+    pub fn test_compare() {
+        macro_rules! tc(
+            ($path1:expr, $path2:expr, eq: $eq:expr,
+             starts_with: $starts_with:expr, ends_with: $ends_with:expr,
+             relative_from: $relative_from:expr) => ({
+                 let path1 = Path::new($path1);
+                 let path2 = Path::new($path2);
+
+                 let eq = path1 == path2;
+                 assert!(eq == $eq, "{:?} == {:?}, expected {:?}, got {:?}",
+                         $path1, $path2, $eq, eq);
+
+                 let starts_with = path1.starts_with(path2);
+                 assert!(starts_with == $starts_with,
+                         "{:?}.starts_with({:?}), expected {:?}, got {:?}", $path1, $path2,
+                         $starts_with, starts_with);
+
+                 let ends_with = path1.ends_with(path2);
+                 assert!(ends_with == $ends_with,
+                         "{:?}.ends_with({:?}), expected {:?}, got {:?}", $path1, $path2,
+                         $ends_with, ends_with);
+
+                 let relative_from = path1.relative_from(path2).map(|p| p.to_str().unwrap());
+                 let exp: Option<&str> = $relative_from;
+                 assert!(relative_from == exp,
+                         "{:?}.relative_from({:?}), expected {:?}, got {:?}", $path1, $path2,
+                         exp, relative_from);
+            });
+        );
+
+        tc!("", "",
+            eq: true,
+            starts_with: true,
+            ends_with: true,
+            relative_from: Some("")
+            );
+
+        tc!("foo", "",
+            eq: false,
+            starts_with: true,
+            ends_with: true,
+            relative_from: Some("foo")
+            );
+
+        tc!("", "foo",
+            eq: false,
+            starts_with: false,
+            ends_with: false,
+            relative_from: None
+            );
+
+        tc!("foo", "foo",
+            eq: true,
+            starts_with: true,
+            ends_with: true,
+            relative_from: Some("")
+            );
+
+        tc!("foo/", "foo",
+            eq: false,
+            starts_with: true,
+            ends_with: false,
+            relative_from: Some(".")
+            );
+
+        tc!("foo/bar", "foo",
+            eq: false,
+            starts_with: true,
+            ends_with: false,
+            relative_from: Some("bar")
+            );
+
+        tc!("foo/bar/baz", "foo/bar",
+            eq: false,
+            starts_with: true,
+            ends_with: false,
+            relative_from: Some("baz")
+            );
+
+        tc!("foo/bar", "foo/bar/baz",
+            eq: false,
+            starts_with: false,
+            ends_with: false,
+            relative_from: None
+            );
+
+        tc!("./foo/bar/", ".",
+            eq: false,
+            starts_with: true,
+            ends_with: true,
+            relative_from: Some("foo/bar/")
+            );
+    }
+}
diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs
index 2398485afef..d2dc3345120 100644
--- a/src/libstd/prelude/v1.rs
+++ b/src/libstd/prelude/v1.rs
@@ -56,7 +56,7 @@
 #[doc(no_inline)] pub use vec::Vec;
 
 // NB: remove when path reform lands
-#[doc(no_inline)] pub use path::{Path, GenericPath};
+#[doc(no_inline)] pub use old_path::{Path, GenericPath};
 // NB: remove when I/O reform lands
 #[doc(no_inline)] pub use old_io::{Buffer, Writer, Reader, Seek, BufferPrelude};
 // NB: remove when range syntax lands
diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs
index 4b45d5501c2..797b9332f17 100644
--- a/src/libstd/rand/os.rs
+++ b/src/libstd/rand/os.rs
@@ -20,7 +20,7 @@ mod imp {
     use self::OsRngInner::*;
 
     use old_io::{IoResult, File};
-    use path::Path;
+    use old_path::Path;
     use rand::Rng;
     use rand::reader::ReaderRng;
     use result::Result::Ok;
diff --git a/src/libstd/sys/common/mod.rs b/src/libstd/sys/common/mod.rs
index ae01586c703..6f6b4c58717 100644
--- a/src/libstd/sys/common/mod.rs
+++ b/src/libstd/sys/common/mod.rs
@@ -16,7 +16,7 @@ use prelude::v1::*;
 use sys::{last_error, retry};
 use ffi::CString;
 use num::Int;
-use path::BytesContainer;
+use old_path::BytesContainer;
 use collections;
 
 pub mod backtrace;
diff --git a/src/libstd/sys/unix/c.rs b/src/libstd/sys/unix/c.rs
index 89bd9a23406..50a8e6b73e3 100644
--- a/src/libstd/sys/unix/c.rs
+++ b/src/libstd/sys/unix/c.rs
@@ -143,6 +143,7 @@ extern {
     pub fn sigdelset(set: *mut sigset_t, signum: libc::c_int) -> libc::c_int;
     pub fn sigemptyset(set: *mut sigset_t) -> libc::c_int;
 
+    #[cfg(not(target_os = "ios"))]
     pub fn getpwuid_r(uid: libc::uid_t,
                       pwd: *mut passwd,
                       buf: *mut libc::c_char,
diff --git a/src/libstd/sys/unix/mod.rs b/src/libstd/sys/unix/mod.rs
index b03b9046966..427cf21ac70 100644
--- a/src/libstd/sys/unix/mod.rs
+++ b/src/libstd/sys/unix/mod.rs
@@ -18,10 +18,11 @@
 use prelude::v1::*;
 
 use ffi;
-use old_io::{self, IoResult, IoError};
+use io::ErrorKind;
 use libc;
 use num::{Int, SignedInt};
 use num;
+use old_io::{self, IoResult, IoError};
 use str;
 use sys_common::mkerr_libc;
 
@@ -133,6 +134,35 @@ pub fn decode_error_detailed(errno: i32) -> IoError {
     err
 }
 
+pub fn decode_error_kind(errno: i32) -> ErrorKind {
+    match errno as libc::c_int {
+        libc::ECONNREFUSED => ErrorKind::ConnectionRefused,
+        libc::ECONNRESET => ErrorKind::ConnectionReset,
+        libc::EPERM | libc::EACCES => ErrorKind::PermissionDenied,
+        libc::EPIPE => ErrorKind::BrokenPipe,
+        libc::ENOTCONN => ErrorKind::NotConnected,
+        libc::ECONNABORTED => ErrorKind::ConnectionAborted,
+        libc::EADDRNOTAVAIL => ErrorKind::ConnectionRefused,
+        libc::EADDRINUSE => ErrorKind::ConnectionRefused,
+        libc::ENOENT => ErrorKind::FileNotFound,
+        libc::EISDIR => ErrorKind::InvalidInput,
+        libc::EINTR => ErrorKind::Interrupted,
+        libc::EINVAL => ErrorKind::InvalidInput,
+        libc::ENOTTY => ErrorKind::MismatchedFileTypeForOperation,
+        libc::ETIMEDOUT => ErrorKind::TimedOut,
+        libc::ECANCELED => ErrorKind::TimedOut,
+        libc::consts::os::posix88::EEXIST => ErrorKind::PathAlreadyExists,
+
+        // These two constants can have the same value on some systems,
+        // but different values on others, so we can't use a match
+        // clause
+        x if x == libc::EAGAIN || x == libc::EWOULDBLOCK =>
+            ErrorKind::ResourceUnavailable,
+
+        _ => ErrorKind::Other,
+    }
+}
+
 #[inline]
 pub fn retry<T, F> (mut f: F) -> T where
     T: SignedInt,
diff --git a/src/libstd/sys/unix/os.rs b/src/libstd/sys/unix/os.rs
index b3f37962945..5004ff713c4 100644
--- a/src/libstd/sys/unix/os.rs
+++ b/src/libstd/sys/unix/os.rs
@@ -307,23 +307,23 @@ pub fn args() -> Args {
     let mut res = Vec::new();
 
     unsafe {
-        let processInfoSel = sel_registerName("processInfo\0".as_ptr());
-        let argumentsSel = sel_registerName("arguments\0".as_ptr());
-        let utf8Sel = sel_registerName("UTF8String\0".as_ptr());
-        let countSel = sel_registerName("count\0".as_ptr());
-        let objectAtSel = sel_registerName("objectAtIndex:\0".as_ptr());
+        let process_info_sel = sel_registerName("processInfo\0".as_ptr());
+        let arguments_sel = sel_registerName("arguments\0".as_ptr());
+        let utf8_sel = sel_registerName("UTF8String\0".as_ptr());
+        let count_sel = sel_registerName("count\0".as_ptr());
+        let object_at_sel = sel_registerName("objectAtIndex:\0".as_ptr());
 
         let klass = objc_getClass("NSProcessInfo\0".as_ptr());
-        let info = objc_msgSend(klass, processInfoSel);
-        let args = objc_msgSend(info, argumentsSel);
+        let info = objc_msgSend(klass, process_info_sel);
+        let args = objc_msgSend(info, arguments_sel);
 
-        let cnt: int = mem::transmute(objc_msgSend(args, countSel));
+        let cnt: int = mem::transmute(objc_msgSend(args, count_sel));
         for i in range(0, cnt) {
-            let tmp = objc_msgSend(args, objectAtSel, i);
+            let tmp = objc_msgSend(args, object_at_sel, i);
             let utf_c_str: *const libc::c_char =
-                mem::transmute(objc_msgSend(tmp, utf8Sel));
-            let bytes = ffi::c_str_to_bytes(&utf_c_str).to_vec();
-            res.push(OsString::from_vec(bytes))
+                mem::transmute(objc_msgSend(tmp, utf8_sel));
+            let bytes = ffi::c_str_to_bytes(&utf_c_str);
+            res.push(OsString::from_str(str::from_utf8(bytes).unwrap()))
         }
     }
 
@@ -455,9 +455,11 @@ pub fn home_dir() -> Option<Path> {
         Path::new(os.into_vec())
     });
 
-    #[cfg(target_os = "android")]
+    #[cfg(any(target_os = "android",
+              target_os = "ios"))]
     unsafe fn fallback() -> Option<OsString> { None }
-    #[cfg(not(target_os = "android"))]
+    #[cfg(not(any(target_os = "android",
+                  target_os = "ios")))]
     unsafe fn fallback() -> Option<OsString> {
         let mut amt = match libc::sysconf(c::_SC_GETPW_R_SIZE_MAX) {
             n if n < 0 => 512 as usize,
diff --git a/src/libstd/sys/unix/os_str.rs b/src/libstd/sys/unix/os_str.rs
index 3dd89ad0759..a2c93dea6a4 100644
--- a/src/libstd/sys/unix/os_str.rs
+++ b/src/libstd/sys/unix/os_str.rs
@@ -20,7 +20,7 @@ use str;
 use string::{String, CowString};
 use mem;
 
-#[derive(Clone)]
+#[derive(Clone, Hash)]
 pub struct Buf {
     pub inner: Vec<u8>
 }
diff --git a/src/libstd/sys/unix/process.rs b/src/libstd/sys/unix/process.rs
index 7e117b10a34..20f86227e8e 100644
--- a/src/libstd/sys/unix/process.rs
+++ b/src/libstd/sys/unix/process.rs
@@ -20,7 +20,7 @@ use old_io::{self, IoResult, IoError, EndOfFile};
 use libc::{self, pid_t, c_void, c_int};
 use mem;
 use os;
-use path::BytesContainer;
+use old_path::BytesContainer;
 use ptr;
 use sync::mpsc::{channel, Sender, Receiver};
 use sys::fs::FileDesc;
diff --git a/src/libstd/sys/windows/backtrace.rs b/src/libstd/sys/windows/backtrace.rs
index 66712b9e3a1..92e309da34b 100644
--- a/src/libstd/sys/windows/backtrace.rs
+++ b/src/libstd/sys/windows/backtrace.rs
@@ -32,7 +32,7 @@ use libc;
 use mem;
 use ops::Drop;
 use option::Option::{Some};
-use path::Path;
+use old_path::Path;
 use ptr;
 use result::Result::{Ok, Err};
 use slice::SliceExt;
diff --git a/src/libstd/sys/windows/mod.rs b/src/libstd/sys/windows/mod.rs
index 8dd467eba9e..f1af70e2cf7 100644
--- a/src/libstd/sys/windows/mod.rs
+++ b/src/libstd/sys/windows/mod.rs
@@ -15,6 +15,7 @@
 use prelude::v1::*;
 
 use ffi::OsStr;
+use io::ErrorKind;
 use libc;
 use mem;
 use old_io::{self, IoResult, IoError};
@@ -143,6 +144,34 @@ pub fn decode_error_detailed(errno: i32) -> IoError {
     err
 }
 
+pub fn decode_error_kind(errno: i32) -> ErrorKind {
+    match errno as libc::c_int {
+        libc::ERROR_ACCESS_DENIED => ErrorKind::PermissionDenied,
+        libc::ERROR_ALREADY_EXISTS => ErrorKind::PathAlreadyExists,
+        libc::ERROR_BROKEN_PIPE => ErrorKind::BrokenPipe,
+        libc::ERROR_FILE_NOT_FOUND => ErrorKind::FileNotFound,
+        libc::ERROR_INVALID_FUNCTION => ErrorKind::InvalidInput,
+        libc::ERROR_INVALID_HANDLE => ErrorKind::MismatchedFileTypeForOperation,
+        libc::ERROR_INVALID_NAME => ErrorKind::InvalidInput,
+        libc::ERROR_NOTHING_TO_TERMINATE => ErrorKind::InvalidInput,
+        libc::ERROR_NO_DATA => ErrorKind::BrokenPipe,
+        libc::ERROR_OPERATION_ABORTED => ErrorKind::TimedOut,
+
+        libc::WSAEACCES => ErrorKind::PermissionDenied,
+        libc::WSAEADDRINUSE => ErrorKind::ConnectionRefused,
+        libc::WSAEADDRNOTAVAIL => ErrorKind::ConnectionRefused,
+        libc::WSAECONNABORTED => ErrorKind::ConnectionAborted,
+        libc::WSAECONNREFUSED => ErrorKind::ConnectionRefused,
+        libc::WSAECONNRESET => ErrorKind::ConnectionReset,
+        libc::WSAEINVAL => ErrorKind::InvalidInput,
+        libc::WSAENOTCONN => ErrorKind::NotConnected,
+        libc::WSAEWOULDBLOCK => ErrorKind::ResourceUnavailable,
+
+        _ => ErrorKind::Other,
+    }
+}
+
+
 #[inline]
 pub fn retry<I, F>(f: F) -> I where F: FnOnce() -> I { f() } // PR rust-lang/rust/#17020
 
diff --git a/src/libstd/sys/windows/os_str.rs b/src/libstd/sys/windows/os_str.rs
index aab2406cef9..af94b56bf1f 100644
--- a/src/libstd/sys/windows/os_str.rs
+++ b/src/libstd/sys/windows/os_str.rs
@@ -18,7 +18,7 @@ use result::Result;
 use option::Option;
 use mem;
 
-#[derive(Clone)]
+#[derive(Clone, Hash)]
 pub struct Buf {
     pub inner: Wtf8Buf
 }
diff --git a/src/libstd/sys/windows/process.rs b/src/libstd/sys/windows/process.rs
index 3ca735f7fdf..315c41e779a 100644
--- a/src/libstd/sys/windows/process.rs
+++ b/src/libstd/sys/windows/process.rs
@@ -23,7 +23,7 @@ use old_io::process::{ProcessExit, ExitStatus};
 use old_io::{IoResult, IoError};
 use old_io;
 use os;
-use path::BytesContainer;
+use old_path::BytesContainer;
 use ptr;
 use str;
 use sync::{StaticMutex, MUTEX_INIT};
diff --git a/src/libstd/thread_local/mod.rs b/src/libstd/thread_local/mod.rs
index d4d777789dd..9de5fd1c770 100644
--- a/src/libstd/thread_local/mod.rs
+++ b/src/libstd/thread_local/mod.rs
@@ -45,6 +45,7 @@ pub mod scoped;
 
 // Sure wish we had macro hygiene, no?
 #[doc(hidden)]
+#[stable(feature = "rust1", since = "1.0.0")]
 pub mod __impl {
     pub use super::imp::Key as KeyInner;
     pub use super::imp::destroy_value;