Register new snapshots

2 files changed, 0 insertions, 111 deletions

diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs
index ffbcdd87bfe..b61e7c6b441 100644
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -37,25 +37,6 @@ use ptr::RawPtr;
 ///
 /// Any error other than `EndOfFile` that is produced by the underlying Reader
 /// is returned by the iterator and should be handled by the caller.
-#[cfg(stage0)]
-pub struct Bytes<'r, T> {
-    reader: &'r mut T,
-}
-
-/// An iterator that reads a single byte on each iteration,
-/// until `.read_byte()` returns `EndOfFile`.
-///
-/// # Notes about the Iteration Protocol
-///
-/// The `Bytes` may yield `None` and thus terminate
-/// an iteration, but continue to yield elements if iteration
-/// is attempted again.
-///
-/// # Error
-///
-/// Any error other than `EndOfFile` that is produced by the underlying Reader
-/// is returned by the iterator and should be handled by the caller.
-#[cfg(not(stage0))]
 pub struct Bytes<'r, T:'r> {
     reader: &'r mut T,
 }
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 38aa58f1c6a..905012b7bf3 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -976,13 +976,6 @@ unsafe fn slice_vec_capacity<'a, T>(v: &'a mut Vec<T>, start: uint, end: uint) -
     })
 }
 
-/// Note: stage0-specific version that lacks bound.
-#[cfg(stage0)]
-pub struct RefReader<'a, R> {
-    /// The underlying reader which this is referencing
-    inner: &'a mut R
-}
-
 /// A `RefReader` is a struct implementing `Reader` which contains a reference
 /// to another reader. This is often useful when composing streams.
 ///
@@ -1007,7 +1000,6 @@ pub struct RefReader<'a, R> {
 ///
 /// # }
 /// ```
-#[cfg(not(stage0))]
 pub struct RefReader<'a, R:'a> {
     /// The underlying reader which this is referencing
     inner: &'a mut R
@@ -1066,16 +1058,8 @@ pub trait Writer {
     ///
     /// This function will return any I/O error reported while formatting.
     fn write_fmt(&mut self, fmt: &fmt::Arguments) -> IoResult<()> {
-        // Note: stage0-specific version that lacks bound.
-        #[cfg(stage0)]
-        struct Adaptor<'a, T> {
-            inner: &'a mut T,
-            error: IoResult<()>,
-        }
-
         // Create a shim which translates a Writer to a FormatWriter and saves
         // off I/O errors. instead of discarding them
-        #[cfg(not(stage0))]
         struct Adaptor<'a, T:'a> {
             inner: &'a mut T,
             error: IoResult<()>,
@@ -1335,37 +1319,6 @@ impl<'a> Writer for &'a mut Writer+'a {
 /// println!("input processed: {}", output.unwrap());
 /// # }
 /// ```
-#[cfg(stage0)]
-pub struct RefWriter<'a, W> {
-    /// The underlying writer which this is referencing
-    inner: &'a mut W
-}
-
-/// A `RefWriter` is a struct implementing `Writer` which contains a reference
-/// to another writer. This is often useful when composing streams.
-///
-/// # Example
-///
-/// ```
-/// # fn main() {}
-/// # fn process_input<R: Reader>(r: R) {}
-/// # fn foo () {
-/// use std::io::util::TeeReader;
-/// use std::io::{stdin, MemWriter};
-///
-/// let mut output = MemWriter::new();
-///
-/// {
-///     // Don't give ownership of 'output' to the 'tee'. Instead we keep a
-///     // handle to it in the outer scope
-///     let mut tee = TeeReader::new(stdin(), output.by_ref());
-///     process_input(tee);
-/// }
-///
-/// println!("input processed: {}", output.unwrap());
-/// # }
-/// ```
-#[cfg(not(stage0))]
 pub struct RefWriter<'a, W:'a> {
     /// The underlying writer which this is referencing
     inner: &'a mut W
@@ -1399,25 +1352,6 @@ impl<T: Reader + Writer> Stream for T {}
 ///
 /// Any error other than `EndOfFile` that is produced by the underlying Reader
 /// is returned by the iterator and should be handled by the caller.
-#[cfg(stage0)]
-pub struct Lines<'r, T> {
-    buffer: &'r mut T,
-}
-
-/// An iterator that reads a line on each iteration,
-/// until `.read_line()` encounters `EndOfFile`.
-///
-/// # Notes about the Iteration Protocol
-///
-/// The `Lines` may yield `None` and thus terminate
-/// an iteration, but continue to yield elements if iteration
-/// is attempted again.
-///
-/// # Error
-///
-/// Any error other than `EndOfFile` that is produced by the underlying Reader
-/// is returned by the iterator and should be handled by the caller.
-#[cfg(not(stage0))]
 pub struct Lines<'r, T:'r> {
     buffer: &'r mut T,
 }
@@ -1445,25 +1379,6 @@ impl<'r, T: Buffer> Iterator<IoResult<String>> for Lines<'r, T> {
 ///
 /// Any error other than `EndOfFile` that is produced by the underlying Reader
 /// is returned by the iterator and should be handled by the caller.
-#[cfg(stage0)]
-pub struct Chars<'r, T> {
-    buffer: &'r mut T
-}
-
-/// An iterator that reads a utf8-encoded character on each iteration,
-/// until `.read_char()` encounters `EndOfFile`.
-///
-/// # Notes about the Iteration Protocol
-///
-/// The `Chars` may yield `None` and thus terminate
-/// an iteration, but continue to yield elements if iteration
-/// is attempted again.
-///
-/// # Error
-///
-/// Any error other than `EndOfFile` that is produced by the underlying Reader
-/// is returned by the iterator and should be handled by the caller.
-#[cfg(not(stage0))]
 pub struct Chars<'r, T:'r> {
     buffer: &'r mut T
 }
@@ -1697,12 +1612,6 @@ pub trait Acceptor<T> {
     }
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct IncomingConnections<'a, A> {
-    inc: &'a mut A,
-}
-
 /// An infinite iterator over incoming connection attempts.
 /// Calling `next` will block the task until a connection is attempted.
 ///
@@ -1710,7 +1619,6 @@ pub struct IncomingConnections<'a, A> {
 /// `Some`. The `Some` contains the `IoResult` representing whether the
 /// connection attempt was successful.  A successful connection will be wrapped
 /// in `Ok`. A failed connection is represented as an `Err`.
-#[cfg(not(stage0))]
 pub struct IncomingConnections<'a, A:'a> {
     inc: &'a mut A,
 }