---

yaml
---
r: 206431
b: refs/heads/beta
c: 252b544
h: refs/heads/master
i:
  206429: 3e72edb
  206427: 48bec23
  206423: 60e27f8
  206415: 99680c0
  206399: 89ad8fb
v: v3

Author: bors

[refs]

@@ -29,7 +29,7 @@ refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/batch: b7fd822592a4fb577552d93010c4a4e14f314346
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
-refs/heads/beta: d507c38e00977856e163276a9a501403237f10de
+refs/heads/beta: 252b5444daf83a9f1b18e2dfe4b46830d2be4447
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 579e31929feff51dcaf8d444648eff8de735f91a

branches/beta/src/libstd/io/buffered.rs

@@ -433,15 +433,19 @@ impl<W: Read + Write> Read for InternalBufWriter<W> {
 /// infrequent calls to `read` and `write` on the underlying `Read+Write`.
 ///
 /// The output buffer will be written out when this stream is dropped.
-#[stable(feature = "rust1", since = "1.0.0")]
+#[unstable(feature = "buf_stream",
+           reason = "unsure about semantics of buffering two directions, \
+                     leading to issues like #17136")]
 pub struct BufStream<S: Write> {
     inner: BufReader<InternalBufWriter<S>>
 }
 
+#[unstable(feature = "buf_stream",
+           reason = "unsure about semantics of buffering two directions, \
+                     leading to issues like #17136")]
 impl<S: Read + Write> BufStream<S> {
     /// Creates a new buffered stream with explicitly listed capacities for the
     /// reader/writer buffer.
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn with_capacities(reader_cap: usize, writer_cap: usize, inner: S)
                            -> BufStream<S> {
         let writer = BufWriter::with_capacity(writer_cap, inner);
@@ -452,13 +456,11 @@ impl<S: Read + Write> BufStream<S> {
 
     /// Creates a new buffered stream with the default reader/writer buffer
     /// capacities.
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn new(inner: S) -> BufStream<S> {
         BufStream::with_capacities(DEFAULT_BUF_SIZE, DEFAULT_BUF_SIZE, inner)
     }
 
     /// Gets a reference to the underlying stream.
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn get_ref(&self) -> &S {
         let InternalBufWriter(ref w) = self.inner.inner;
         w.get_ref()
@@ -470,7 +472,6 @@ impl<S: Read + Write> BufStream<S> {
     ///
     /// It is inadvisable to read directly from or write directly to the
     /// underlying stream.
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn get_mut(&mut self) -> &mut S {
         let InternalBufWriter(ref mut w) = self.inner.inner;
         w.get_mut()
@@ -480,7 +481,6 @@ impl<S: Read + Write> BufStream<S> {
     ///
     /// The internal write buffer is written out before returning the stream.
     /// Any leftover data in the read buffer is lost.
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn into_inner(self) -> Result<S, IntoInnerError<BufStream<S>>> {
         let BufReader { inner: InternalBufWriter(w), buf, pos, cap } = self.inner;
         w.into_inner().map_err(|IntoInnerError(w, e)| {
@@ -491,20 +491,26 @@ impl<S: Read + Write> BufStream<S> {
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
+#[unstable(feature = "buf_stream",
+           reason = "unsure about semantics of buffering two directions, \
+                     leading to issues like #17136")]
 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: usize) { self.inner.consume(amt) }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
+#[unstable(feature = "buf_stream",
+           reason = "unsure about semantics of buffering two directions, \
+                     leading to issues like #17136")]
 impl<S: Read + Write> Read for BufStream<S> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         self.inner.read(buf)
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
+#[unstable(feature = "buf_stream",
+           reason = "unsure about semantics of buffering two directions, \
+                     leading to issues like #17136")]
 impl<S: Read + Write> Write for BufStream<S> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         self.inner.inner.get_mut().write(buf)
@@ -514,7 +520,9 @@ impl<S: Read + Write> Write for BufStream<S> {
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
+#[unstable(feature = "buf_stream",
+           reason = "unsure about semantics of buffering two directions, \
+                     leading to issues like #17136")]
 impl<S: Write> fmt::Debug for BufStream<S> where S: fmt::Debug {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let reader = &self.inner;