diff --git a/Cargo.toml b/Cargo.toml
index a41cad9afcad4109666912f31eb5ffe86b65d605..dda63ee4c7a17361450f882eb6e60360d586fda1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "core_io"
-version = "0.1.20180307"
+version = "0.1.20180619"
authors = ["The Rust Project Developers", "Jethro Beekman"]
license = "MIT/Apache-2.0"
description = """
diff --git a/mapping.rs b/mapping.rs
index b9bfb4b68adc3ffbbe18c66051447270e2af6562..d1ee5a652cf8b7fb40515a514408e0ccb10254e7 100644
--- a/mapping.rs
+++ b/mapping.rs
@@ -589,3 +589,4 @@
-Mapping("b75d1f0ce252f4b53f8a97aee0fcf4a785186fef","72e8009185b537083015f43a8e0fd34509ab1938")
-Mapping("d6d711dd8f7ad5885294b8e1f0009a23dc1f8b1f","d52acbe37f69a2ebc9d161c479ed628da1cbea4e")
-Mapping("8503b3ff822c1ed01c89773d30e4e10b886d77a5","02c1862fb55c6ae4198038b1b317bcdd06e395d1")
+-Mapping("5230979794db209de492b3f7cc688020b72bc7c6","b81da278623d9dcda1776008612bd42e1922e9c3")
diff --git a/patches/b81da278623d9dcda1776008612bd42e1922e9c3.patch b/patches/b81da278623d9dcda1776008612bd42e1922e9c3.patch
new file mode 100644
index 0000000000000000000000000000000000000000..fc2ac6f907b56a9b23320df01daed872ea0dad0f
--- /dev/null
+++ b/patches/b81da278623d9dcda1776008612bd42e1922e9c3.patch
@@ -0,0 +1,1676 @@
+diff --git a/buffered.rs b/buffered.rs
+index ee297d3..3994fc9 100644
+--- a/buffered.rs
++++ b/buffered.rs
+@@ -10,13 +10,13 @@
+
+ //! Buffering wrappers for I/O traits
+
++use core::prelude::v1::*;
+ use io::prelude::*;
+
+-use cmp;
+-use error;
+-use fmt;
++use core::cmp;
++use core::fmt;
+ use io::{self, Initializer, DEFAULT_BUF_SIZE, Error, ErrorKind, SeekFrom};
+-use memchr;
++use io::memchr;
+
+ /// The `BufReader` struct adds buffering to any reader.
+ ///
+@@ -52,7 +52,6 @@ use memchr;
+ /// Ok(())
+ /// }
+ /// ```
+-#[stable(feature = "rust1", since = "1.0.0")]
+ pub struct BufReader<R> {
+ inner: R,
+ buf: Box<[u8]>,
+@@ -75,7 +74,6 @@ impl<R: Read> BufReader<R> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn new(inner: R) -> BufReader<R> {
+ BufReader::with_capacity(DEFAULT_BUF_SIZE, inner)
+ }
+@@ -96,7 +94,6 @@ impl<R: Read> BufReader<R> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn with_capacity(cap: usize, inner: R) -> BufReader<R> {
+ unsafe {
+ let mut buffer = Vec::with_capacity(cap);
+@@ -129,7 +126,6 @@ impl<R: Read> BufReader<R> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn get_ref(&self) -> &R { &self.inner }
+
+ /// Gets a mutable reference to the underlying reader.
+@@ -150,7 +146,6 @@ impl<R: Read> BufReader<R> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn get_mut(&mut self) -> &mut R { &mut self.inner }
+
+ /// Returns `true` if there are no bytes in the internal buffer.
+@@ -174,8 +169,6 @@ impl<R: Read> BufReader<R> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[unstable(feature = "bufreader_is_empty", issue = "45323", reason = "recently added")]
+- #[rustc_deprecated(since = "1.26.0", reason = "use .buffer().is_empty() instead")]
+ pub fn is_empty(&self) -> bool {
+ self.buffer().is_empty()
+ }
+@@ -202,7 +195,6 @@ impl<R: Read> BufReader<R> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[unstable(feature = "bufreader_buffer", issue = "45323")]
+ pub fn buffer(&self) -> &[u8] {
+ &self.buf[self.pos..self.cap]
+ }
+@@ -225,7 +217,6 @@ impl<R: Read> BufReader<R> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn into_inner(self) -> R { self.inner }
+ }
+
+@@ -234,7 +225,6 @@ impl<R: Seek> BufReader<R> {
+ /// the buffer will not be flushed, allowing for more efficient seeks.
+ /// This method does not return the location of the underlying reader, so the caller
+ /// must track this information themselves if it is required.
+- #[unstable(feature = "bufreader_seek_relative", issue = "31100")]
+ pub fn seek_relative(&mut self, offset: i64) -> io::Result<()> {
+ let pos = self.pos as u64;
+ if offset < 0 {
+@@ -254,7 +244,6 @@ impl<R: Seek> BufReader<R> {
+ }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ 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
+@@ -277,7 +266,6 @@ impl<R: Read> Read for BufReader<R> {
+ }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ 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
+@@ -297,7 +285,6 @@ impl<R: Read> BufRead for BufReader<R> {
+ }
+ }
+
+-#[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 {
+ fmt.debug_struct("BufReader")
+@@ -307,7 +294,6 @@ impl<R> fmt::Debug for BufReader<R> where R: fmt::Debug {
+ }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<R: Seek> Seek for BufReader<R> {
+ /// Seek to an offset, in bytes, in the underlying reader.
+ ///
+@@ -415,7 +401,6 @@ impl<R: Seek> Seek for BufReader<R> {
+ /// [`Tcpstream::write`]: ../../std/net/struct.TcpStream.html#method.write
+ /// [`TcpStream`]: ../../std/net/struct.TcpStream.html
+ /// [`flush`]: #method.flush
+-#[stable(feature = "rust1", since = "1.0.0")]
+ pub struct BufWriter<W: Write> {
+ inner: Option<W>,
+ buf: Vec<u8>,
+@@ -450,7 +435,6 @@ pub struct BufWriter<W: Write> {
+ /// };
+ /// ```
+ #[derive(Debug)]
+-#[stable(feature = "rust1", since = "1.0.0")]
+ pub struct IntoInnerError<W>(W, Error);
+
+ impl<W: Write> BufWriter<W> {
+@@ -464,7 +448,6 @@ impl<W: Write> BufWriter<W> {
+ ///
+ /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn new(inner: W) -> BufWriter<W> {
+ BufWriter::with_capacity(DEFAULT_BUF_SIZE, inner)
+ }
+@@ -482,7 +465,6 @@ impl<W: Write> BufWriter<W> {
+ /// let stream = TcpStream::connect("127.0.0.1:34254").unwrap();
+ /// let mut buffer = BufWriter::with_capacity(100, stream);
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn with_capacity(cap: usize, inner: W) -> BufWriter<W> {
+ BufWriter {
+ inner: Some(inner),
+@@ -531,7 +513,6 @@ impl<W: Write> BufWriter<W> {
+ /// // we can use reference just like buffer
+ /// let reference = buffer.get_ref();
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn get_ref(&self) -> &W { self.inner.as_ref().unwrap() }
+
+ /// Gets a mutable reference to the underlying writer.
+@@ -549,7 +530,6 @@ impl<W: Write> BufWriter<W> {
+ /// // we can use reference just like buffer
+ /// let reference = buffer.get_mut();
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn get_mut(&mut self) -> &mut W { self.inner.as_mut().unwrap() }
+
+ /// Unwraps this `BufWriter`, returning the underlying writer.
+@@ -571,7 +551,6 @@ impl<W: Write> BufWriter<W> {
+ /// // unwrap the TcpStream and flush the buffer
+ /// let stream = buffer.into_inner().unwrap();
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn into_inner(mut self) -> Result<W, IntoInnerError<BufWriter<W>>> {
+ match self.flush_buf() {
+ Err(e) => Err(IntoInnerError(self, e)),
+@@ -580,7 +559,6 @@ impl<W: Write> BufWriter<W> {
+ }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ 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() {
+@@ -600,7 +578,6 @@ impl<W: Write> Write for BufWriter<W> {
+ }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<W: Write> fmt::Debug for BufWriter<W> where W: fmt::Debug {
+ fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fmt.debug_struct("BufWriter")
+@@ -610,7 +587,6 @@ impl<W: Write> fmt::Debug for BufWriter<W> where W: fmt::Debug {
+ }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<W: Write + Seek> Seek for BufWriter<W> {
+ /// Seek to the offset, in bytes, in the underlying writer.
+ ///
+@@ -620,7 +596,6 @@ impl<W: Write + Seek> Seek for BufWriter<W> {
+ }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<W: Write> Drop for BufWriter<W> {
+ fn drop(&mut self) {
+ if self.inner.is_some() && !self.panicked {
+@@ -659,7 +634,6 @@ impl<W> IntoInnerError<W> {
+ /// }
+ /// };
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn error(&self) -> &Error { &self.1 }
+
+ /// Returns the buffered writer instance which generated the error.
+@@ -692,23 +666,13 @@ impl<W> IntoInnerError<W> {
+ /// }
+ /// };
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn into_inner(self) -> W { self.0 }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<W> From<IntoInnerError<W>> for Error {
+ fn from(iie: IntoInnerError<W>) -> Error { iie.1 }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+-impl<W: Send + fmt::Debug> error::Error for IntoInnerError<W> {
+- fn description(&self) -> &str {
+- error::Error::description(self.error())
+- }
+-}
+-
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<W> fmt::Display for IntoInnerError<W> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.error().fmt(f)
+@@ -766,7 +730,6 @@ impl<W> fmt::Display for IntoInnerError<W> {
+ /// Ok(())
+ /// }
+ /// ```
+-#[stable(feature = "rust1", since = "1.0.0")]
+ pub struct LineWriter<W: Write> {
+ inner: BufWriter<W>,
+ need_flush: bool,
+@@ -787,7 +750,6 @@ impl<W: Write> LineWriter<W> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn new(inner: W) -> LineWriter<W> {
+ // Lines typically aren't that long, don't use a giant buffer
+ LineWriter::with_capacity(1024, inner)
+@@ -808,7 +770,6 @@ impl<W: Write> LineWriter<W> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn with_capacity(cap: usize, inner: W) -> LineWriter<W> {
+ LineWriter {
+ inner: BufWriter::with_capacity(cap, inner),
+@@ -832,7 +793,6 @@ impl<W: Write> LineWriter<W> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn get_ref(&self) -> &W { self.inner.get_ref() }
+
+ /// Gets a mutable reference to the underlying writer.
+@@ -855,7 +815,6 @@ impl<W: Write> LineWriter<W> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn get_mut(&mut self) -> &mut W { self.inner.get_mut() }
+
+ /// Unwraps this `LineWriter`, returning the underlying writer.
+@@ -881,7 +840,6 @@ impl<W: Write> LineWriter<W> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn into_inner(self) -> Result<W, IntoInnerError<LineWriter<W>>> {
+ self.inner.into_inner().map_err(|IntoInnerError(buf, e)| {
+ IntoInnerError(LineWriter {
+@@ -892,7 +850,6 @@ impl<W: Write> LineWriter<W> {
+ }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<W: Write> Write for LineWriter<W> {
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+ if self.need_flush {
+@@ -937,7 +894,6 @@ impl<W: Write> Write for LineWriter<W> {
+ }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<W: Write> fmt::Debug for LineWriter<W> where W: fmt::Debug {
+ fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fmt.debug_struct("LineWriter")
+diff --git a/cursor.rs b/cursor.rs
+index 8ac5257..3f9b7b0 100644
+--- a/cursor.rs
++++ b/cursor.rs
+@@ -10,7 +10,7 @@
+
+ use io::prelude::*;
+
+-use cmp;
++use core::cmp;
+ use io::{self, Initializer, SeekFrom, Error, ErrorKind};
+
+ /// A `Cursor` wraps another type and provides it with a
+@@ -78,7 +78,6 @@ use io::{self, Initializer, SeekFrom, Error, ErrorKind};
+ /// assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+ /// }
+ /// ```
+-#[stable(feature = "rust1", since = "1.0.0")]
+ #[derive(Clone, Debug)]
+ pub struct Cursor<T> {
+ inner: T,
+@@ -101,7 +100,6 @@ impl<T> Cursor<T> {
+ /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
+ /// # force_inference(&buff);
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn new(inner: T) -> Cursor<T> {
+ Cursor { pos: 0, inner: inner }
+ }
+@@ -119,7 +117,6 @@ impl<T> Cursor<T> {
+ ///
+ /// let vec = buff.into_inner();
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn into_inner(self) -> T { self.inner }
+
+ /// Gets a reference to the underlying value in this cursor.
+@@ -135,7 +132,6 @@ impl<T> Cursor<T> {
+ ///
+ /// let reference = buff.get_ref();
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn get_ref(&self) -> &T { &self.inner }
+
+ /// Gets a mutable reference to the underlying value in this cursor.
+@@ -154,7 +150,6 @@ impl<T> Cursor<T> {
+ ///
+ /// let reference = buff.get_mut();
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn get_mut(&mut self) -> &mut T { &mut self.inner }
+
+ /// Returns the current position of this cursor.
+@@ -176,7 +171,6 @@ impl<T> Cursor<T> {
+ /// buff.seek(SeekFrom::Current(-1)).unwrap();
+ /// assert_eq!(buff.position(), 1);
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn position(&self) -> u64 { self.pos }
+
+ /// Sets the position of this cursor.
+@@ -196,11 +190,9 @@ impl<T> Cursor<T> {
+ /// buff.set_position(4);
+ /// assert_eq!(buff.position(), 4);
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn set_position(&mut self, pos: u64) { self.pos = pos; }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<T> io::Seek for Cursor<T> where T: AsRef<[u8]> {
+ fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
+ let (base_pos, offset) = match style {
+@@ -221,17 +213,16 @@ impl<T> io::Seek for Cursor<T> where T: AsRef<[u8]> {
+ }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<T> Read for Cursor<T> where T: AsRef<[u8]> {
+ fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+- let n = Read::read(&mut self.fill_buf()?, buf)?;
++ let n = Read::read(&mut self.get_buf()?, buf)?;
+ self.pos += n as u64;
+ Ok(n)
+ }
+
+ fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+ let n = buf.len();
+- Read::read_exact(&mut self.fill_buf()?, buf)?;
++ Read::read_exact(&mut self.get_buf()?, buf)?;
+ self.pos += n as u64;
+ Ok(())
+ }
+@@ -242,12 +233,16 @@ impl<T> Read for Cursor<T> where T: AsRef<[u8]> {
+ }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+-impl<T> BufRead for Cursor<T> where T: AsRef<[u8]> {
+- fn fill_buf(&mut self) -> io::Result<&[u8]> {
++impl<T> Cursor<T> where T: AsRef<[u8]> {
++ fn get_buf(&mut self) -> io::Result<&[u8]> {
+ let amt = cmp::min(self.pos, self.inner.as_ref().len() as u64);
+ Ok(&self.inner.as_ref()[(amt as usize)..])
+ }
++}
++
++#[cfg(feature="collections")]
++impl<T> BufRead for Cursor<T> where T: AsRef<[u8]> {
++ fn fill_buf(&mut self) -> io::Result<&[u8]> { self.get_buf() }
+ fn consume(&mut self, amt: usize) { self.pos += amt as u64; }
+ }
+
+@@ -277,6 +272,7 @@ fn try_into(n: u64) -> Result<usize, ()> {
+ }
+
+ // Resizing write implementation
++#[cfg(feature="collections")]
+ fn vec_write(pos_mut: &mut u64, vec: &mut Vec<u8>, buf: &[u8]) -> io::Result<usize> {
+ let pos: usize = try_into(*pos_mut).map_err(|_| {
+ Error::new(ErrorKind::InvalidInput,
+@@ -303,7 +299,6 @@ fn vec_write(pos_mut: &mut u64, vec: &mut Vec<u8>, buf: &[u8]) -> io::Result<usi
+ Ok(buf.len())
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<'a> Write for Cursor<&'a mut [u8]> {
+ #[inline]
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+@@ -312,7 +307,7 @@ impl<'a> Write for Cursor<&'a mut [u8]> {
+ fn flush(&mut self) -> io::Result<()> { Ok(()) }
+ }
+
+-#[stable(feature = "cursor_mut_vec", since = "1.25.0")]
++#[cfg(feature="collections")]
+ impl<'a> Write for Cursor<&'a mut Vec<u8>> {
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+ vec_write(&mut self.pos, self.inner, buf)
+@@ -320,7 +315,7 @@ impl<'a> Write for Cursor<&'a mut Vec<u8>> {
+ fn flush(&mut self) -> io::Result<()> { Ok(()) }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
++#[cfg(feature = "collections")]
+ impl Write for Cursor<Vec<u8>> {
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+ vec_write(&mut self.pos, &mut self.inner, buf)
+@@ -328,8 +323,8 @@ impl Write for Cursor<Vec<u8>> {
+ fn flush(&mut self) -> io::Result<()> { Ok(()) }
+ }
+
+-#[stable(feature = "cursor_box_slice", since = "1.5.0")]
+-impl Write for Cursor<Box<[u8]>> {
++#[cfg(feature = "alloc")]
++impl Write for Cursor<::alloc::boxed::Box<[u8]>> {
+ #[inline]
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+ slice_write(&mut self.pos, &mut self.inner, buf)
+diff --git a/error.rs b/error.rs
+index bdd675e..3acdadf 100644
+--- a/error.rs
++++ b/error.rs
+@@ -8,11 +8,16 @@
+ // option. This file may not be copied, modified, or distributed
+ // except according to those terms.
+
+-use error;
+-use fmt;
+-use result;
+-use sys;
+-use convert::From;
++#[cfg(feature="alloc")] use alloc::boxed::Box;
++#[cfg(not(feature="alloc"))] use ::FakeBox as Box;
++use core::convert::Into;
++use core::fmt;
++use core::marker::{Send, Sync};
++use core::option::Option::{self, Some, None};
++use core::result;
++#[cfg(feature="collections")] use collections::string::String;
++#[cfg(not(feature="collections"))] use ::ErrorString as String;
++use core::convert::From;
+
+ /// A specialized [`Result`](../result/enum.Result.html) type for I/O
+ /// operations.
+@@ -48,7 +53,6 @@ use convert::From;
+ /// Ok(buffer)
+ /// }
+ /// ```
+-#[stable(feature = "rust1", since = "1.0.0")]
+ pub type Result<T> = result::Result<T, Error>;
+
+ /// The error type for I/O operations of the [`Read`], [`Write`], [`Seek`], and
+@@ -62,12 +66,10 @@ pub type Result<T> = result::Result<T, Error>;
+ /// [`Write`]: ../io/trait.Write.html
+ /// [`Seek`]: ../io/trait.Seek.html
+ /// [`ErrorKind`]: enum.ErrorKind.html
+-#[stable(feature = "rust1", since = "1.0.0")]
+ pub struct Error {
+ repr: Repr,
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl fmt::Debug for Error {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::Debug::fmt(&self.repr, f)
+@@ -77,13 +79,16 @@ impl fmt::Debug for Error {
+ enum Repr {
+ Os(i32),
+ Simple(ErrorKind),
++ #[cfg(feature="alloc")]
+ Custom(Box<Custom>),
++ #[cfg(not(feature="alloc"))]
++ Custom(Custom),
+ }
+
+ #[derive(Debug)]
+ struct Custom {
+ kind: ErrorKind,
+- error: Box<error::Error+Send+Sync>,
++ error: String,
+ }
+
+ /// A list specifying general categories of I/O error.
+@@ -95,47 +100,34 @@ struct Custom {
+ ///
+ /// [`io::Error`]: struct.Error.html
+ #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+-#[stable(feature = "rust1", since = "1.0.0")]
+ #[allow(deprecated)]
+ pub enum ErrorKind {
+ /// An entity was not found, often a file.
+- #[stable(feature = "rust1", since = "1.0.0")]
+ NotFound,
+ /// The operation lacked the necessary privileges to complete.
+- #[stable(feature = "rust1", since = "1.0.0")]
+ PermissionDenied,
+ /// The connection was refused by the remote server.
+- #[stable(feature = "rust1", since = "1.0.0")]
+ ConnectionRefused,
+ /// The connection was reset by the remote server.
+- #[stable(feature = "rust1", since = "1.0.0")]
+ ConnectionReset,
+ /// The connection was aborted (terminated) by the remote server.
+- #[stable(feature = "rust1", since = "1.0.0")]
+ ConnectionAborted,
+ /// The network operation failed because it was not connected yet.
+- #[stable(feature = "rust1", since = "1.0.0")]
+ NotConnected,
+ /// A socket address could not be bound because the address is already in
+ /// use elsewhere.
+- #[stable(feature = "rust1", since = "1.0.0")]
+ AddrInUse,
+ /// A nonexistent interface was requested or the requested address was not
+ /// local.
+- #[stable(feature = "rust1", since = "1.0.0")]
+ AddrNotAvailable,
+ /// The operation failed because a pipe was closed.
+- #[stable(feature = "rust1", since = "1.0.0")]
+ BrokenPipe,
+ /// An entity already exists, often a file.
+- #[stable(feature = "rust1", since = "1.0.0")]
+ AlreadyExists,
+ /// The operation needs to block to complete, but the blocking operation was
+ /// requested to not occur.
+- #[stable(feature = "rust1", since = "1.0.0")]
+ WouldBlock,
+ /// A parameter was incorrect.
+- #[stable(feature = "rust1", since = "1.0.0")]
+ InvalidInput,
+ /// Data not valid for the operation were encountered.
+ ///
+@@ -147,10 +139,8 @@ pub enum ErrorKind {
+ /// `InvalidData` if the file's contents are not valid UTF-8.
+ ///
+ /// [`InvalidInput`]: #variant.InvalidInput
+- #[stable(feature = "io_invalid_data", since = "1.2.0")]
+ InvalidData,
+ /// The I/O operation's timeout expired, causing it to be canceled.
+- #[stable(feature = "rust1", since = "1.0.0")]
+ TimedOut,
+ /// An error returned when an operation could not be completed because a
+ /// call to [`write`] returned [`Ok(0)`].
+@@ -161,15 +151,12 @@ pub enum ErrorKind {
+ ///
+ /// [`write`]: ../../std/io/trait.Write.html#tymethod.write
+ /// [`Ok(0)`]: ../../std/io/type.Result.html
+- #[stable(feature = "rust1", since = "1.0.0")]
+ WriteZero,
+ /// This operation was interrupted.
+ ///
+ /// Interrupted operations can typically be retried.
+- #[stable(feature = "rust1", since = "1.0.0")]
+ Interrupted,
+ /// Any I/O error not part of this list.
+- #[stable(feature = "rust1", since = "1.0.0")]
+ Other,
+
+ /// An error returned when an operation could not be completed because an
+@@ -178,15 +165,10 @@ pub enum ErrorKind {
+ /// This typically means that an operation could only succeed if it read a
+ /// particular number of bytes but only a smaller number of bytes could be
+ /// read.
+- #[stable(feature = "read_exact", since = "1.6.0")]
+ UnexpectedEof,
+
+ /// A marker variant that tells the compiler that users of this enum cannot
+ /// match it exhaustively.
+- #[unstable(feature = "io_error_internals",
+- reason = "better expressed through extensible enums that this \
+- enum cannot be exhaustively matched against",
+- issue = "0")]
+ #[doc(hidden)]
+ __Nonexhaustive,
+ }
+@@ -219,7 +201,6 @@ impl ErrorKind {
+
+ /// Intended for use for errors not exposed to the user, where allocating onto
+ /// the heap (for normal construction via Error::new) is too costly.
+-#[stable(feature = "io_error_from_errorkind", since = "1.14.0")]
+ impl From<ErrorKind> for Error {
+ #[inline]
+ fn from(kind: ErrorKind) -> Error {
+@@ -248,14 +229,13 @@ impl Error {
+ /// // errors can also be created from other errors
+ /// let custom_error2 = Error::new(ErrorKind::Interrupted, custom_error);
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn new<E>(kind: ErrorKind, error: E) -> Error
+- where E: Into<Box<error::Error+Send+Sync>>
++ where E: Into<String>
+ {
+ Self::_new(kind, error.into())
+ }
+
+- fn _new(kind: ErrorKind, error: Box<error::Error+Send+Sync>) -> Error {
++ fn _new(kind: ErrorKind, error: String) -> Error {
+ Error {
+ repr: Repr::Custom(Box::new(Custom {
+ kind,
+@@ -264,24 +244,6 @@ impl Error {
+ }
+ }
+
+- /// 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.
+- ///
+- /// # Examples
+- ///
+- /// ```
+- /// use std::io::Error;
+- ///
+- /// println!("last OS error: {:?}", Error::last_os_error());
+- /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+- pub fn last_os_error() -> Error {
+- Error::from_raw_os_error(sys::os::errno() as i32)
+- }
+-
+ /// Creates a new instance of an `Error` from a particular OS error code.
+ ///
+ /// # Examples
+@@ -307,7 +269,6 @@ impl Error {
+ /// assert_eq!(error.kind(), io::ErrorKind::InvalidInput);
+ /// # }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn from_raw_os_error(code: i32) -> Error {
+ Error { repr: Repr::Os(code) }
+ }
+@@ -338,7 +299,6 @@ impl Error {
+ /// print_os_error(&Error::new(ErrorKind::Other, "oh no!"));
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn raw_os_error(&self) -> Option<i32> {
+ match self.repr {
+ Repr::Os(i) => Some(i),
+@@ -372,12 +332,11 @@ impl Error {
+ /// print_error(&Error::new(ErrorKind::Other, "oh no!"));
+ /// }
+ /// ```
+- #[stable(feature = "io_error_inner", since = "1.3.0")]
+- pub fn get_ref(&self) -> Option<&(error::Error+Send+Sync+'static)> {
++ pub fn get_ref(&self) -> Option<&String> {
+ match self.repr {
+ Repr::Os(..) => None,
+ Repr::Simple(..) => None,
+- Repr::Custom(ref c) => Some(&*c.error),
++ Repr::Custom(ref c) => Some(&c.error),
+ }
+ }
+
+@@ -443,12 +402,11 @@ impl Error {
+ /// print_error(&change_error(Error::new(ErrorKind::Other, MyError::new())));
+ /// }
+ /// ```
+- #[stable(feature = "io_error_inner", since = "1.3.0")]
+- pub fn get_mut(&mut self) -> Option<&mut (error::Error+Send+Sync+'static)> {
++ pub fn get_mut(&mut self) -> Option<&mut String> {
+ match self.repr {
+ Repr::Os(..) => None,
+ Repr::Simple(..) => None,
+- Repr::Custom(ref mut c) => Some(&mut *c.error),
++ Repr::Custom(ref mut c) => Some(&mut c.error),
+ }
+ }
+
+@@ -477,8 +435,7 @@ impl Error {
+ /// print_error(Error::new(ErrorKind::Other, "oh no!"));
+ /// }
+ /// ```
+- #[stable(feature = "io_error_inner", since = "1.3.0")]
+- pub fn into_inner(self) -> Option<Box<error::Error+Send+Sync>> {
++ pub fn into_inner(self) -> Option<String> {
+ match self.repr {
+ Repr::Os(..) => None,
+ Repr::Simple(..) => None,
+@@ -504,10 +461,9 @@ impl Error {
+ /// print_error(Error::new(ErrorKind::AddrInUse, "oh no!"));
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn kind(&self) -> ErrorKind {
+ match self.repr {
+- Repr::Os(code) => sys::decode_error_kind(code),
++ Repr::Os(_code) => ErrorKind::Other,
+ Repr::Custom(ref c) => c.kind,
+ Repr::Simple(kind) => kind,
+ }
+@@ -519,22 +475,18 @@ impl fmt::Debug for Repr {
+ match *self {
+ Repr::Os(code) =>
+ fmt.debug_struct("Os")
+- .field("code", &code)
+- .field("kind", &sys::decode_error_kind(code))
+- .field("message", &sys::os::error_string(code)).finish(),
++ .field("code", &code).finish(),
+ Repr::Custom(ref c) => fmt::Debug::fmt(&c, fmt),
+ Repr::Simple(kind) => fmt.debug_tuple("Kind").field(&kind).finish(),
+ }
+ }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ 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)
++ write!(fmt, "os error {}", code)
+ }
+ Repr::Custom(ref c) => c.error.fmt(fmt),
+ Repr::Simple(kind) => write!(fmt, "{}", kind.as_str()),
+@@ -542,24 +494,6 @@ impl fmt::Display for Error {
+ }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+-impl error::Error for Error {
+- fn description(&self) -> &str {
+- match self.repr {
+- Repr::Os(..) | Repr::Simple(..) => self.kind().as_str(),
+- Repr::Custom(ref c) => c.error.description(),
+- }
+- }
+-
+- fn cause(&self) -> Option<&error::Error> {
+- match self.repr {
+- Repr::Os(..) => None,
+- Repr::Simple(..) => None,
+- Repr::Custom(ref c) => c.error.cause(),
+- }
+- }
+-}
+-
+ fn _assert_error_is_sync_send() {
+ fn _is_sync_send<T: Sync+Send>() {}
+ _is_sync_send::<Error>();
+diff --git a/impls.rs b/impls.rs
+index fe1179a..452b8b7 100644
+--- a/impls.rs
++++ b/impls.rs
+@@ -8,15 +8,18 @@
+ // option. This file may not be copied, modified, or distributed
+ // except according to those terms.
+
+-use cmp;
+-use io::{self, SeekFrom, Read, Initializer, Write, Seek, BufRead, Error, ErrorKind};
+-use fmt;
+-use mem;
++#[cfg(feature="alloc")] use alloc::boxed::Box;
++use core::cmp;
++use io::{self, SeekFrom, Read, Initializer, Write, Seek, Error, ErrorKind};
++#[cfg(feature="collections")] use io::BufRead;
++use core::fmt;
++use core::mem;
++#[cfg(feature="collections")] use collections::string::String;
++#[cfg(feature="collections")] use collections::vec::Vec;
+
+ // =============================================================================
+ // Forwarding implementations
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<'a, R: Read + ?Sized> Read for &'a mut R {
+ #[inline]
+ fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+@@ -28,11 +31,13 @@ impl<'a, R: Read + ?Sized> Read for &'a mut R {
+ (**self).initializer()
+ }
+
++ #[cfg(feature="collections")]
+ #[inline]
+ fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+ (**self).read_to_end(buf)
+ }
+
++ #[cfg(feature="collections")]
+ #[inline]
+ fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
+ (**self).read_to_string(buf)
+@@ -43,7 +48,6 @@ impl<'a, R: Read + ?Sized> Read for &'a mut R {
+ (**self).read_exact(buf)
+ }
+ }
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<'a, W: Write + ?Sized> Write for &'a mut W {
+ #[inline]
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> { (**self).write(buf) }
+@@ -61,12 +65,11 @@ impl<'a, W: Write + ?Sized> Write for &'a mut W {
+ (**self).write_fmt(fmt)
+ }
+ }
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<'a, S: Seek + ?Sized> Seek for &'a mut S {
+ #[inline]
+ fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { (**self).seek(pos) }
+ }
+-#[stable(feature = "rust1", since = "1.0.0")]
++#[cfg(feature="collections")]
+ impl<'a, B: BufRead + ?Sized> BufRead for &'a mut B {
+ #[inline]
+ fn fill_buf(&mut self) -> io::Result<&[u8]> { (**self).fill_buf() }
+@@ -85,7 +88,7 @@ impl<'a, B: BufRead + ?Sized> BufRead for &'a mut B {
+ }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
++#[cfg(feature="alloc")]
+ impl<R: Read + ?Sized> Read for Box<R> {
+ #[inline]
+ fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+@@ -97,11 +100,13 @@ impl<R: Read + ?Sized> Read for Box<R> {
+ (**self).initializer()
+ }
+
++ #[cfg(feature="collections")]
+ #[inline]
+ fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+ (**self).read_to_end(buf)
+ }
+
++ #[cfg(feature="collections")]
+ #[inline]
+ fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
+ (**self).read_to_string(buf)
+@@ -112,7 +117,7 @@ impl<R: Read + ?Sized> Read for Box<R> {
+ (**self).read_exact(buf)
+ }
+ }
+-#[stable(feature = "rust1", since = "1.0.0")]
++#[cfg(feature="alloc")]
+ impl<W: Write + ?Sized> Write for Box<W> {
+ #[inline]
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> { (**self).write(buf) }
+@@ -130,12 +135,12 @@ impl<W: Write + ?Sized> Write for Box<W> {
+ (**self).write_fmt(fmt)
+ }
+ }
+-#[stable(feature = "rust1", since = "1.0.0")]
++#[cfg(feature="alloc")]
+ impl<S: Seek + ?Sized> Seek for Box<S> {
+ #[inline]
+ fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { (**self).seek(pos) }
+ }
+-#[stable(feature = "rust1", since = "1.0.0")]
++#[cfg(feature="collections")]
+ impl<B: BufRead + ?Sized> BufRead for Box<B> {
+ #[inline]
+ fn fill_buf(&mut self) -> io::Result<&[u8]> { (**self).fill_buf() }
+@@ -161,7 +166,6 @@ impl<B: BufRead + ?Sized> BufRead for Box<B> {
+ ///
+ /// Note that reading updates the slice to point to the yet unread part.
+ /// The slice will be empty when EOF is reached.
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<'a> Read for &'a [u8] {
+ #[inline]
+ fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+@@ -207,6 +211,7 @@ impl<'a> Read for &'a [u8] {
+ Ok(())
+ }
+
++ #[cfg(feature="collections")]
+ #[inline]
+ fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+ buf.extend_from_slice(*self);
+@@ -216,7 +221,7 @@ impl<'a> Read for &'a [u8] {
+ }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
++#[cfg(feature="collections")]
+ impl<'a> BufRead for &'a [u8] {
+ #[inline]
+ fn fill_buf(&mut self) -> io::Result<&[u8]> { Ok(*self) }
+@@ -230,7 +235,6 @@ impl<'a> BufRead for &'a [u8] {
+ ///
+ /// Note that writing updates the slice to point to the yet unwritten part.
+ /// The slice will be empty when it has been completely overwritten.
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<'a> Write for &'a mut [u8] {
+ #[inline]
+ fn write(&mut self, data: &[u8]) -> io::Result<usize> {
+@@ -256,7 +260,7 @@ impl<'a> Write for &'a mut [u8] {
+
+ /// Write is implemented for `Vec<u8>` by appending to the vector.
+ /// The vector will grow as needed.
+-#[stable(feature = "rust1", since = "1.0.0")]
++#[cfg(feature="collections")]
+ impl Write for Vec<u8> {
+ #[inline]
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+diff --git a/mod.rs b/mod.rs
+index eba4e9f..a5706ec 100644
+--- a/mod.rs
++++ b/mod.rs
+@@ -267,50 +267,38 @@
+ //! [`Result`]: ../result/enum.Result.html
+ //! [`.unwrap()`]: ../result/enum.Result.html#method.unwrap
+
+-#![stable(feature = "rust1", since = "1.0.0")]
+-
+-use cmp;
++use core::cmp;
+ use core::str as core_str;
+-use error as std_error;
+-use fmt;
+-use result;
+-use str;
+-use memchr;
+-use ptr;
+-
+-#[stable(feature = "rust1", since = "1.0.0")]
+-pub use self::buffered::{BufReader, BufWriter, LineWriter};
+-#[stable(feature = "rust1", since = "1.0.0")]
+-pub use self::buffered::IntoInnerError;
+-#[stable(feature = "rust1", since = "1.0.0")]
++use core::fmt;
++use core::result;
++#[cfg(feature="collections")] use collections::string::String;
++use core::str;
++#[cfg(feature="collections")] use collections::vec::Vec;
++#[cfg(not(core_memchr))]
++mod memchr;
++#[cfg(all(feature="collections",core_memchr))]
++use core::slice::memchr;
++use core::ptr;
++
++#[cfg(feature="collections")] pub use self::buffered::{BufReader, BufWriter, LineWriter};
++#[cfg(feature="collections")] pub use self::buffered::IntoInnerError;
+ pub use self::cursor::Cursor;
+-#[stable(feature = "rust1", since = "1.0.0")]
+ pub use self::error::{Result, Error, ErrorKind};
+-#[stable(feature = "rust1", since = "1.0.0")]
+ pub use self::util::{copy, sink, Sink, empty, Empty, repeat, Repeat};
+-#[stable(feature = "rust1", since = "1.0.0")]
+-pub use self::stdio::{stdin, stdout, stderr, Stdin, Stdout, Stderr};
+-#[stable(feature = "rust1", since = "1.0.0")]
+-pub use self::stdio::{StdoutLock, StderrLock, StdinLock};
+-#[unstable(feature = "print_internals", issue = "0")]
+-pub use self::stdio::{_print, _eprint};
+-#[unstable(feature = "libstd_io_internals", issue = "42788")]
+-#[doc(no_inline, hidden)]
+-pub use self::stdio::{set_panic, set_print};
+
+ pub mod prelude;
+-mod buffered;
++#[cfg(feature="collections")] mod buffered;
+ mod cursor;
+ mod error;
+ mod impls;
+-mod lazy;
+ mod util;
+-mod stdio;
+
+-const DEFAULT_BUF_SIZE: usize = ::sys_common::io::DEFAULT_BUF_SIZE;
++const DEFAULT_BUF_SIZE: usize = 8 * 1024;
+
++#[cfg(feature="collections")]
+ struct Guard<'a> { buf: &'a mut Vec<u8>, len: usize }
+
++#[cfg(feature="collections")]
+ impl<'a> Drop for Guard<'a> {
+ fn drop(&mut self) {
+ unsafe { self.buf.set_len(self.len); }
+@@ -335,6 +323,7 @@ impl<'a> Drop for Guard<'a> {
+ // 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.
++#[cfg(feature="collections")]
+ fn append_to_string<F>(buf: &mut String, f: F) -> Result<usize>
+ where F: FnOnce(&mut Vec<u8>) -> Result<usize>
+ {
+@@ -362,6 +351,7 @@ fn append_to_string<F>(buf: &mut String, f: F) -> Result<usize>
+ //
+ // Because we're extending the buffer with uninitialized data for trusted
+ // readers, we need to make sure to truncate that if any of this panics.
++#[cfg(feature="collections")]
+ fn read_to_end<R: Read + ?Sized>(r: &mut R, buf: &mut Vec<u8>) -> Result<usize> {
+ let start_len = buf.len();
+ let mut g = Guard { len: buf.len(), buf: buf };
+@@ -465,7 +455,6 @@ fn read_to_end<R: Read + ?Sized>(r: &mut R, buf: &mut Vec<u8>) -> Result<usize>
+ /// [`BufReader`]: struct.BufReader.html
+ /// [`&str`]: ../../std/primitive.str.html
+ /// [slice]: ../../std/primitive.slice.html
+-#[stable(feature = "rust1", since = "1.0.0")]
+ #[doc(spotlight)]
+ pub trait Read {
+ /// Pull some bytes from this source into the specified buffer, returning
+@@ -522,7 +511,6 @@ pub trait Read {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
+
+ /// Determines if this `Read`er can work with buffers of uninitialized
+@@ -547,7 +535,6 @@ pub trait Read {
+ ///
+ /// [`Initializer::nop()`]: ../../std/io/struct.Initializer.html#method.nop
+ /// [`Initializer`]: ../../std/io/struct.Initializer.html
+- #[unstable(feature = "read_initializer", issue = "42788")]
+ #[inline]
+ unsafe fn initializer(&self) -> Initializer {
+ Initializer::zeroing()
+@@ -600,7 +587,7 @@ pub trait Read {
+ /// file.)
+ ///
+ /// [`std::fs::read`]: ../fs/fn.read.html
+- #[stable(feature = "rust1", since = "1.0.0")]
++ #[cfg(feature = "collections")]
+ fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize> {
+ read_to_end(self, buf)
+ }
+@@ -643,7 +630,7 @@ pub trait Read {
+ /// reading from a file.)
+ ///
+ /// [`std::fs::read_to_string`]: ../fs/fn.read_to_string.html
+- #[stable(feature = "rust1", since = "1.0.0")]
++ #[cfg(feature = "collections")]
+ fn read_to_string(&mut self, buf: &mut String) -> Result<usize> {
+ // 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`
+@@ -706,7 +693,6 @@ pub trait Read {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "read_exact", since = "1.6.0")]
+ fn read_exact(&mut self, mut buf: &mut [u8]) -> Result<()> {
+ while !buf.is_empty() {
+ match self.read(buf) {
+@@ -758,7 +744,6 @@ pub trait Read {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ fn by_ref(&mut self) -> &mut Self where Self: Sized { self }
+
+ /// Transforms this `Read` instance to an [`Iterator`] over its bytes.
+@@ -795,7 +780,6 @@ pub trait Read {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ fn bytes(self) -> Bytes<Self> where Self: Sized {
+ Bytes { inner: self }
+ }
+@@ -836,12 +820,6 @@ pub trait Read {
+ /// Ok(())
+ /// }
+ /// ```
+- #[unstable(feature = "io", reason = "the semantics of a partial read/write \
+- of where errors happen is currently \
+- unclear and may change",
+- issue = "27802")]
+- #[rustc_deprecated(since = "1.27.0", reason = "Use str::from_utf8 instead:
+- https://doc.rust-lang.org/nightly/std/str/struct.Utf8Error.html#examples")]
+ #[allow(deprecated)]
+ fn chars(self) -> Chars<Self> where Self: Sized {
+ Chars { inner: self }
+@@ -877,7 +855,6 @@ pub trait Read {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ fn chain<R: Read>(self, next: R) -> Chain<Self, R> where Self: Sized {
+ Chain { first: self, second: next, done_first: false }
+ }
+@@ -913,20 +890,17 @@ pub trait Read {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ fn take(self, limit: u64) -> Take<Self> where Self: Sized {
+ Take { inner: self, limit: limit }
+ }
+ }
+
+ /// A type used to conditionally initialize buffers passed to `Read` methods.
+-#[unstable(feature = "read_initializer", issue = "42788")]
+ #[derive(Debug)]
+ pub struct Initializer(bool);
+
+ impl Initializer {
+ /// Returns a new `Initializer` which will zero out buffers.
+- #[unstable(feature = "read_initializer", issue = "42788")]
+ #[inline]
+ pub fn zeroing() -> Initializer {
+ Initializer(true)
+@@ -940,21 +914,18 @@ impl Initializer {
+ /// read from buffers passed to `Read` methods, and that the return value of
+ /// the method accurately reflects the number of bytes that have been
+ /// written to the head of the buffer.
+- #[unstable(feature = "read_initializer", issue = "42788")]
+ #[inline]
+ pub unsafe fn nop() -> Initializer {
+ Initializer(false)
+ }
+
+ /// Indicates if a buffer should be initialized.
+- #[unstable(feature = "read_initializer", issue = "42788")]
+ #[inline]
+ pub fn should_initialize(&self) -> bool {
+ self.0
+ }
+
+ /// Initializes a buffer if necessary.
+- #[unstable(feature = "read_initializer", issue = "42788")]
+ #[inline]
+ pub fn initialize(&self, buf: &mut [u8]) {
+ if self.should_initialize() {
+@@ -997,7 +968,6 @@ impl Initializer {
+ /// Ok(())
+ /// }
+ /// ```
+-#[stable(feature = "rust1", since = "1.0.0")]
+ #[doc(spotlight)]
+ pub trait Write {
+ /// Write a buffer into this object, returning how many bytes were written.
+@@ -1046,7 +1016,6 @@ pub trait Write {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ fn write(&mut self, buf: &[u8]) -> Result<usize>;
+
+ /// Flush this output stream, ensuring that all intermediately buffered
+@@ -1072,7 +1041,6 @@ pub trait Write {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ fn flush(&mut self) -> Result<()>;
+
+ /// Attempts to write an entire buffer into this write.
+@@ -1105,7 +1073,6 @@ pub trait Write {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ fn write_all(&mut self, mut buf: &[u8]) -> Result<()> {
+ while !buf.is_empty() {
+ match self.write(buf) {
+@@ -1157,7 +1124,6 @@ pub trait Write {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()> {
+ // Create a shim which translates a Write to a fmt::Write and saves
+ // off I/O errors. instead of discarding them
+@@ -1213,7 +1179,6 @@ pub trait Write {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ fn by_ref(&mut self) -> &mut Self where Self: Sized { self }
+ }
+
+@@ -1243,7 +1208,6 @@ pub trait Write {
+ /// Ok(())
+ /// }
+ /// ```
+-#[stable(feature = "rust1", since = "1.0.0")]
+ pub trait Seek {
+ /// Seek to an offset, in bytes, in a stream.
+ ///
+@@ -1259,7 +1223,6 @@ pub trait Seek {
+ /// Seeking to a negative offset is considered an error.
+ ///
+ /// [`SeekFrom::Start`]: enum.SeekFrom.html#variant.Start
+- #[stable(feature = "rust1", since = "1.0.0")]
+ fn seek(&mut self, pos: SeekFrom) -> Result<u64>;
+ }
+
+@@ -1269,29 +1232,26 @@ pub trait Seek {
+ ///
+ /// [`Seek`]: trait.Seek.html
+ #[derive(Copy, PartialEq, Eq, Clone, Debug)]
+-#[stable(feature = "rust1", since = "1.0.0")]
+ pub enum SeekFrom {
+ /// Set the offset to the provided number of bytes.
+- #[stable(feature = "rust1", since = "1.0.0")]
+- Start(#[stable(feature = "rust1", since = "1.0.0")] u64),
++ 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 it's an error to
+ /// seek before byte 0.
+- #[stable(feature = "rust1", since = "1.0.0")]
+- End(#[stable(feature = "rust1", since = "1.0.0")] i64),
++ 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 it's an error to
+ /// seek before byte 0.
+- #[stable(feature = "rust1", since = "1.0.0")]
+- Current(#[stable(feature = "rust1", since = "1.0.0")] i64),
++ Current(i64),
+ }
+
++#[cfg(feature="collections")]
+ fn read_until<R: BufRead + ?Sized>(r: &mut R, delim: u8, buf: &mut Vec<u8>)
+ -> Result<usize> {
+ let mut read = 0;
+@@ -1371,7 +1331,7 @@ fn read_until<R: BufRead + ?Sized>(r: &mut R, delim: u8, buf: &mut Vec<u8>)
+ /// }
+ /// ```
+ ///
+-#[stable(feature = "rust1", since = "1.0.0")]
++#[cfg(feature="collections")]
+ pub trait BufRead: Read {
+ /// Fills the internal buffer of this object, returning the buffer contents.
+ ///
+@@ -1416,7 +1376,6 @@ pub trait BufRead: Read {
+ /// // ensure the bytes we worked with aren't returned again later
+ /// stdin.consume(length);
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ fn fill_buf(&mut self) -> Result<&[u8]>;
+
+ /// Tells this buffer that `amt` bytes have been consumed from the buffer,
+@@ -1438,7 +1397,6 @@ pub trait BufRead: Read {
+ /// that method's example includes an example of `consume()`.
+ ///
+ /// [`fill_buf`]: #tymethod.fill_buf
+- #[stable(feature = "rust1", since = "1.0.0")]
+ fn consume(&mut self, amt: usize);
+
+ /// Read all bytes into `buf` until the delimiter `byte` or EOF is reached.
+@@ -1494,7 +1452,6 @@ pub trait BufRead: Read {
+ /// assert_eq!(num_bytes, 0);
+ /// assert_eq!(buf, b"");
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize> {
+ read_until(self, byte, buf)
+ }
+@@ -1553,7 +1510,6 @@ pub trait BufRead: Read {
+ /// assert_eq!(num_bytes, 0);
+ /// assert_eq!(buf, "");
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ fn read_line(&mut self, buf: &mut String) -> Result<usize> {
+ // Note that we are not calling the `.read_until` method here, but
+ // rather our hardcoded implementation. For more details as to why, see
+@@ -1594,7 +1550,6 @@ pub trait BufRead: Read {
+ /// assert_eq!(split_iter.next(), Some(b"dolor".to_vec()));
+ /// assert_eq!(split_iter.next(), None);
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ fn split(self, byte: u8) -> Split<Self> where Self: Sized {
+ Split { buf: self, delim: byte }
+ }
+@@ -1633,7 +1588,6 @@ pub trait BufRead: Read {
+ /// Each line of the iterator has the same error semantics as [`BufRead::read_line`].
+ ///
+ /// [`BufRead::read_line`]: trait.BufRead.html#method.read_line
+- #[stable(feature = "rust1", since = "1.0.0")]
+ fn lines(self) -> Lines<Self> where Self: Sized {
+ Lines { buf: self }
+ }
+@@ -1645,7 +1599,6 @@ pub trait BufRead: Read {
+ /// Please see the documentation of [`chain`] for more details.
+ ///
+ /// [`chain`]: trait.Read.html#method.chain
+-#[stable(feature = "rust1", since = "1.0.0")]
+ pub struct Chain<T, U> {
+ first: T,
+ second: U,
+@@ -1671,7 +1624,6 @@ impl<T, U> Chain<T, U> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "more_io_inner_methods", since = "1.20.0")]
+ pub fn into_inner(self) -> (T, U) {
+ (self.first, self.second)
+ }
+@@ -1694,7 +1646,6 @@ impl<T, U> Chain<T, U> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "more_io_inner_methods", since = "1.20.0")]
+ pub fn get_ref(&self) -> (&T, &U) {
+ (&self.first, &self.second)
+ }
+@@ -1721,13 +1672,11 @@ impl<T, U> Chain<T, U> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "more_io_inner_methods", since = "1.20.0")]
+ pub fn get_mut(&mut self) -> (&mut T, &mut U) {
+ (&mut self.first, &mut self.second)
+ }
+ }
+
+-#[stable(feature = "std_debug", since = "1.16.0")]
+ impl<T: fmt::Debug, U: fmt::Debug> fmt::Debug for Chain<T, U> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.debug_struct("Chain")
+@@ -1737,7 +1686,6 @@ impl<T: fmt::Debug, U: fmt::Debug> fmt::Debug for Chain<T, U> {
+ }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<T: Read, U: Read> Read for Chain<T, U> {
+ fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+ if !self.done_first {
+@@ -1759,7 +1707,7 @@ impl<T: Read, U: Read> Read for Chain<T, U> {
+ }
+ }
+
+-#[stable(feature = "chain_bufread", since = "1.9.0")]
++#[cfg(feature="collections")]
+ impl<T: BufRead, U: BufRead> BufRead for Chain<T, U> {
+ fn fill_buf(&mut self) -> Result<&[u8]> {
+ if !self.done_first {
+@@ -1786,7 +1734,6 @@ impl<T: BufRead, U: BufRead> BufRead for Chain<T, U> {
+ /// Please see the documentation of [`take`] for more details.
+ ///
+ /// [`take`]: trait.Read.html#method.take
+-#[stable(feature = "rust1", since = "1.0.0")]
+ #[derive(Debug)]
+ pub struct Take<T> {
+ inner: T,
+@@ -1821,7 +1768,6 @@ impl<T> Take<T> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn limit(&self) -> u64 { self.limit }
+
+ /// Sets the number of bytes that can be read before this instance will
+@@ -1847,7 +1793,6 @@ impl<T> Take<T> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "take_set_limit", since = "1.27.0")]
+ pub fn set_limit(&mut self, limit: u64) {
+ self.limit = limit;
+ }
+@@ -1872,7 +1817,6 @@ impl<T> Take<T> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "io_take_into_inner", since = "1.15.0")]
+ pub fn into_inner(self) -> T {
+ self.inner
+ }
+@@ -1897,7 +1841,6 @@ impl<T> Take<T> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "more_io_inner_methods", since = "1.20.0")]
+ pub fn get_ref(&self) -> &T {
+ &self.inner
+ }
+@@ -1926,13 +1869,11 @@ impl<T> Take<T> {
+ /// Ok(())
+ /// }
+ /// ```
+- #[stable(feature = "more_io_inner_methods", since = "1.20.0")]
+ pub fn get_mut(&mut self) -> &mut T {
+ &mut self.inner
+ }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<T: Read> Read for Take<T> {
+ fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+ // Don't call into inner reader at all at EOF because it may still block
+@@ -1951,7 +1892,7 @@ impl<T: Read> Read for Take<T> {
+ }
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
++#[cfg(feature="collections")]
+ impl<T: BufRead> BufRead for Take<T> {
+ fn fill_buf(&mut self) -> Result<&[u8]> {
+ // Don't call into inner reader at all at EOF because it may still block
+@@ -1990,13 +1931,11 @@ fn read_one_byte(reader: &mut Read) -> Option<Result<u8>> {
+ /// Please see the documentation of [`bytes`] for more details.
+ ///
+ /// [`bytes`]: trait.Read.html#method.bytes
+-#[stable(feature = "rust1", since = "1.0.0")]
+ #[derive(Debug)]
+ pub struct Bytes<R> {
+ inner: R,
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl<R: Read> Iterator for Bytes<R> {
+ type Item = Result<u8>;
+
+@@ -2011,10 +1950,6 @@ impl<R: Read> Iterator for Bytes<R> {
+ /// Please see the documentation of `chars()` for more details.
+ ///
+ /// [chars]: trait.Read.html#method.chars
+-#[unstable(feature = "io", reason = "awaiting stability of Read::chars",
+- issue = "27802")]
+-#[rustc_deprecated(since = "1.27.0", reason = "Use str::from_utf8 instead:
+- https://doc.rust-lang.org/nightly/std/str/struct.Utf8Error.html#examples")]
+ #[derive(Debug)]
+ #[allow(deprecated)]
+ pub struct Chars<R> {
+@@ -2023,10 +1958,6 @@ pub struct Chars<R> {
+
+ /// An enumeration of possible errors that can be generated from the `Chars`
+ /// adapter.
+-#[unstable(feature = "io", reason = "awaiting stability of Read::chars",
+- issue = "27802")]
+-#[rustc_deprecated(since = "1.27.0", reason = "Use str::from_utf8 instead:
+- https://doc.rust-lang.org/nightly/std/str/struct.Utf8Error.html#examples")]
+ #[derive(Debug)]
+ #[allow(deprecated)]
+ pub enum CharsError {
+@@ -2038,8 +1969,6 @@ pub enum CharsError {
+ Other(Error),
+ }
+
+-#[unstable(feature = "io", reason = "awaiting stability of Read::chars",
+- issue = "27802")]
+ #[allow(deprecated)]
+ impl<R: Read> Iterator for Chars<R> {
+ type Item = result::Result<char, CharsError>;
+@@ -2071,26 +2000,6 @@ impl<R: Read> Iterator for Chars<R> {
+ }
+ }
+
+-#[unstable(feature = "io", reason = "awaiting stability of Read::chars",
+- issue = "27802")]
+-#[allow(deprecated)]
+-impl std_error::Error for CharsError {
+- fn description(&self) -> &str {
+- match *self {
+- CharsError::NotUtf8 => "invalid utf8 encoding",
+- CharsError::Other(ref e) => std_error::Error::description(e),
+- }
+- }
+- fn cause(&self) -> Option<&std_error::Error> {
+- match *self {
+- CharsError::NotUtf8 => None,
+- CharsError::Other(ref e) => e.cause(),
+- }
+- }
+-}
+-
+-#[unstable(feature = "io", reason = "awaiting stability of Read::chars",
+- issue = "27802")]
+ #[allow(deprecated)]
+ impl fmt::Display for CharsError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+@@ -2110,14 +2019,14 @@ impl fmt::Display for CharsError {
+ /// `BufRead`. Please see the documentation of `split()` for more details.
+ ///
+ /// [split]: trait.BufRead.html#method.split
+-#[stable(feature = "rust1", since = "1.0.0")]
++#[cfg(feature="collections")]
+ #[derive(Debug)]
+ pub struct Split<B> {
+ buf: B,
+ delim: u8,
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
++#[cfg(feature="collections")]
+ impl<B: BufRead> Iterator for Split<B> {
+ type Item = Result<Vec<u8>>;
+
+@@ -2142,13 +2051,13 @@ impl<B: BufRead> Iterator for Split<B> {
+ /// `BufRead`. Please see the documentation of `lines()` for more details.
+ ///
+ /// [lines]: trait.BufRead.html#method.lines
+-#[stable(feature = "rust1", since = "1.0.0")]
++#[cfg(feature="collections")]
+ #[derive(Debug)]
+ pub struct Lines<B> {
+ buf: B,
+ }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
++#[cfg(feature="collections")]
+ impl<B: BufRead> Iterator for Lines<B> {
+ type Item = Result<String>;
+
+diff --git a/prelude.rs b/prelude.rs
+index 8772d0f..49d66c9 100644
+--- a/prelude.rs
++++ b/prelude.rs
+@@ -18,7 +18,8 @@
+ //! use std::io::prelude::*;
+ //! ```
+
+-#![stable(feature = "rust1", since = "1.0.0")]
++pub use super::{Read, Write, Seek};
++#[cfg(feature="collections")] pub use super::BufRead;
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+-pub use super::{Read, Write, BufRead, Seek};
++#[cfg(feature="collections")] pub use alloc::boxed::Box;
++#[cfg(feature="collections")] pub use collections::vec::Vec;
+diff --git a/util.rs b/util.rs
+index 195310a..20755b7 100644
+--- a/util.rs
++++ b/util.rs
+@@ -10,9 +10,10 @@
+
+ #![allow(missing_copy_implementations)]
+
+-use fmt;
+-use io::{self, Read, Initializer, Write, ErrorKind, BufRead};
+-use mem;
++use core::fmt;
++use io::{self, Read, Initializer, Write, ErrorKind};
++use core::mem;
++#[cfg(feature="collections")] use io::BufRead;
+
+ /// Copies the entire contents of a reader into a writer.
+ ///
+@@ -44,7 +45,6 @@ use mem;
+ /// Ok(())
+ /// }
+ /// ```
+-#[stable(feature = "rust1", since = "1.0.0")]
+ pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<u64>
+ where R: Read, W: Write
+ {
+@@ -73,7 +73,6 @@ pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<
+ /// the documentation of [`empty()`][`empty`] for more details.
+ ///
+ /// [`empty`]: fn.empty.html
+-#[stable(feature = "rust1", since = "1.0.0")]
+ pub struct Empty { _priv: () }
+
+ /// Constructs a new handle to an empty reader.
+@@ -93,10 +92,8 @@ pub struct Empty { _priv: () }
+ /// io::empty().read_to_string(&mut buffer).unwrap();
+ /// assert!(buffer.is_empty());
+ /// ```
+-#[stable(feature = "rust1", since = "1.0.0")]
+ pub fn empty() -> Empty { Empty { _priv: () } }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl Read for Empty {
+ #[inline]
+ fn read(&mut self, _buf: &mut [u8]) -> io::Result<usize> { Ok(0) }
+@@ -106,7 +103,8 @@ impl Read for Empty {
+ Initializer::nop()
+ }
+ }
+-#[stable(feature = "rust1", since = "1.0.0")]
++
++#[cfg(feature="collections")]
+ impl BufRead for Empty {
+ #[inline]
+ fn fill_buf(&mut self) -> io::Result<&[u8]> { Ok(&[]) }
+@@ -114,7 +112,6 @@ impl BufRead for Empty {
+ fn consume(&mut self, _n: usize) {}
+ }
+
+-#[stable(feature = "std_debug", since = "1.16.0")]
+ impl fmt::Debug for Empty {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.pad("Empty { .. }")
+@@ -127,7 +124,6 @@ impl fmt::Debug for Empty {
+ /// see the documentation of `repeat()` for more details.
+ ///
+ /// [repeat]: fn.repeat.html
+-#[stable(feature = "rust1", since = "1.0.0")]
+ pub struct Repeat { byte: u8 }
+
+ /// Creates an instance of a reader that infinitely repeats one byte.
+@@ -144,10 +140,8 @@ pub struct Repeat { byte: u8 }
+ /// io::repeat(0b101).read_exact(&mut buffer).unwrap();
+ /// assert_eq!(buffer, [0b101, 0b101, 0b101]);
+ /// ```
+-#[stable(feature = "rust1", since = "1.0.0")]
+ pub fn repeat(byte: u8) -> Repeat { Repeat { byte: byte } }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl Read for Repeat {
+ #[inline]
+ fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+@@ -163,7 +157,6 @@ impl Read for Repeat {
+ }
+ }
+
+-#[stable(feature = "std_debug", since = "1.16.0")]
+ impl fmt::Debug for Repeat {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.pad("Repeat { .. }")
+@@ -176,7 +169,6 @@ impl fmt::Debug for Repeat {
+ /// see the documentation of `sink()` for more details.
+ ///
+ /// [sink]: fn.sink.html
+-#[stable(feature = "rust1", since = "1.0.0")]
+ pub struct Sink { _priv: () }
+
+ /// Creates an instance of a writer which will successfully consume all data.
+@@ -193,10 +185,8 @@ pub struct Sink { _priv: () }
+ /// let num_bytes = io::sink().write(&buffer).unwrap();
+ /// assert_eq!(num_bytes, 5);
+ /// ```
+-#[stable(feature = "rust1", since = "1.0.0")]
+ pub fn sink() -> Sink { Sink { _priv: () } }
+
+-#[stable(feature = "rust1", since = "1.0.0")]
+ impl Write for Sink {
+ #[inline]
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> { Ok(buf.len()) }
+@@ -204,7 +194,6 @@ impl Write for Sink {
+ fn flush(&mut self) -> io::Result<()> { Ok(()) }
+ }
+
+-#[stable(feature = "std_debug", since = "1.16.0")]
+ impl fmt::Debug for Sink {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.pad("Sink { .. }")