Register new snapshots

src/libcollections/dlist.rs

@@ -49,16 +49,7 @@ struct Node<T> {
     value: T,
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct Items<'a, T> {
-    head: &'a Link<T>,
-    tail: Rawlink<Node<T>>,
-    nelem: uint,
-}
-
 /// An iterator over references to the items of a `DList`.
-#[cfg(not(stage0))]
 pub struct Items<'a, T:'a> {
     head: &'a Link<T>,
     tail: Rawlink<Node<T>>,
@@ -70,17 +61,7 @@ impl<'a, T> Clone for Items<'a, T> {
     fn clone(&self) -> Items<'a, T> { *self }
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct MutItems<'a, T> {
-    list: &'a mut DList<T>,
-    head: Rawlink<Node<T>>,
-    tail: Rawlink<Node<T>>,
-    nelem: uint,
-}
-
 /// An iterator over mutable references to the items of a `DList`.
-#[cfg(not(stage0))]
 pub struct MutItems<'a, T:'a> {
     list: &'a mut DList<T>,
     head: Rawlink<Node<T>>,

src/libcollections/lib.rs

@@ -23,9 +23,6 @@
 #![feature(unsafe_destructor, import_shadowing)]
 #![no_std]
 
-// NOTE(stage0, pcwalton): Remove after snapshot.
-#![allow(unknown_features)]
-
 #[phase(plugin, link)] extern crate core;
 extern crate unicode;
 extern crate alloc;

src/libcollections/priority_queue.rs

@@ -515,14 +515,7 @@ impl<T: Ord> PriorityQueue<T> {
     }
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct Items <'a, T> {
-    iter: slice::Items<'a, T>,
-}
-
 /// `PriorityQueue` iterator.
-#[cfg(not(stage0))]
 pub struct Items <'a, T:'a> {
     iter: slice::Items<'a, T>,
 }

src/libcollections/ringbuf.rs

@@ -293,17 +293,7 @@ impl<T> RingBuf<T> {
     }
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct Items<'a, T> {
-    lo: uint,
-    index: uint,
-    rindex: uint,
-    elts: &'a [Option<T>],
-}
-
 /// `RingBuf` iterator.
-#[cfg(not(stage0))]
 pub struct Items<'a, T:'a> {
     lo: uint,
     index: uint,
@@ -358,16 +348,7 @@ impl<'a, T> RandomAccessIterator<&'a T> for Items<'a, T> {
     }
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct MutItems<'a, T> {
-    remaining1: &'a mut [Option<T>],
-    remaining2: &'a mut [Option<T>],
-    nelts: uint,
-}
-
 /// `RingBuf` mutable iterator.
-#[cfg(not(stage0))]
 pub struct MutItems<'a, T:'a> {
     remaining1: &'a mut [Option<T>],
     remaining2: &'a mut [Option<T>],

src/libcollections/smallintmap.rs

@@ -489,16 +489,7 @@ macro_rules! double_ended_iterator {
     }
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct Entries<'a, T> {
-    front: uint,
-    back: uint,
-    iter: slice::Items<'a, Option<T>>
-}
-
 /// Forward iterator over a map.
-#[cfg(not(stage0))]
 pub struct Entries<'a, T:'a> {
     front: uint,
     back: uint,
@@ -508,17 +499,8 @@ pub struct Entries<'a, T:'a> {
 iterator!(impl Entries -> (uint, &'a T), get_ref)
 double_ended_iterator!(impl Entries -> (uint, &'a T), get_ref)
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct MutEntries<'a, T> {
-    front: uint,
-    back: uint,
-    iter: slice::MutItems<'a, Option<T>>
-}
-
 /// Forward iterator over the key-value pairs of a map, with the
 /// values being mutable.
-#[cfg(not(stage0))]
 pub struct MutEntries<'a, T:'a> {
     front: uint,
     back: uint,

src/libcollections/treemap.rs

@@ -668,20 +668,7 @@ impl<K: Ord, V> TreeMap<K, V> {
     }
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct Entries<'a, K, V> {
-    stack: Vec<&'a TreeNode<K, V>>,
-    // See the comment on MutEntries; this is just to allow
-    // code-sharing (for this immutable-values iterator it *could* very
-    // well be Option<&'a TreeNode<K,V>>).
-    node: *const TreeNode<K, V>,
-    remaining_min: uint,
-    remaining_max: uint
-}
-
 /// Lazy forward iterator over a map
-#[cfg(not(stage0))]
 pub struct Entries<'a, K:'a, V:'a> {
     stack: Vec<&'a TreeNode<K, V>>,
     // See the comment on MutEntries; this is just to allow
@@ -692,49 +679,13 @@ pub struct Entries<'a, K:'a, V:'a> {
     remaining_max: uint
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct RevEntries<'a, K, V> {
-    iter: Entries<'a, K, V>,
-}
-
 /// Lazy backward iterator over a map
-#[cfg(not(stage0))]
 pub struct RevEntries<'a, K:'a, V:'a> {
     iter: Entries<'a, K, V>,
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct MutEntries<'a, K, V> {
-    stack: Vec<&'a mut TreeNode<K, V>>,
-    // Unfortunately, we require some unsafe-ness to get around the
-    // fact that we would be storing a reference *into* one of the
-    // nodes in the stack.
-    //
-    // As far as the compiler knows, this would let us invalidate the
-    // reference by assigning a new value to this node's position in
-    // its parent, which would cause this current one to be
-    // deallocated so this reference would be invalid. (i.e. the
-    // compilers complaints are 100% correct.)
-    //
-    // However, as far as you humans reading this code know (or are
-    // about to know, if you haven't read far enough down yet), we are
-    // only reading from the TreeNode.{left,right} fields. the only
-    // thing that is ever mutated is the .value field (although any
-    // actual mutation that happens is done externally, by the
-    // iterator consumer). So, don't be so concerned, rustc, we've got
-    // it under control.
-    //
-    // (This field can legitimately be null.)
-    node: *mut TreeNode<K, V>,
-    remaining_min: uint,
-    remaining_max: uint
-}
-
 /// Lazy forward iterator over a map that allows for the mutation of
 /// the values.
-#[cfg(not(stage0))]
 pub struct MutEntries<'a, K:'a, V:'a> {
     stack: Vec<&'a mut TreeNode<K, V>>,
     // Unfortunately, we require some unsafe-ness to get around the
@@ -761,14 +712,7 @@ pub struct MutEntries<'a, K:'a, V:'a> {
     remaining_max: uint
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct RevMutEntries<'a, K, V> {
-    iter: MutEntries<'a, K, V>,
-}
-
 /// Lazy backward iterator over a map
-#[cfg(not(stage0))]
 pub struct RevMutEntries<'a, K:'a, V:'a> {
     iter: MutEntries<'a, K, V>,
 }
@@ -1375,26 +1319,12 @@ impl<T: Ord> TreeSet<T> {
     }
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct SetItems<'a, T> {
-    iter: Entries<'a, T, ()>
-}
-
 /// A lazy forward iterator over a set.
-#[cfg(not(stage0))]
 pub struct SetItems<'a, T:'a> {
     iter: Entries<'a, T, ()>
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct RevSetItems<'a, T> {
-    iter: RevEntries<'a, T, ()>
-}
-
 /// A lazy backward iterator over a set.
-#[cfg(not(stage0))]
 pub struct RevSetItems<'a, T:'a> {
     iter: RevEntries<'a, T, ()>
 }
@@ -1402,57 +1332,25 @@ pub struct RevSetItems<'a, T:'a> {
 /// A lazy forward iterator over a set that consumes the set while iterating.
 pub type MoveSetItems<T> = iter::Map<'static, (T, ()), T, MoveEntries<T, ()>>;
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct DifferenceItems<'a, T> {
-    a: Peekable<&'a T, SetItems<'a, T>>,
-    b: Peekable<&'a T, SetItems<'a, T>>,
-}
-
 /// A lazy iterator producing elements in the set difference (in-order).
-#[cfg(not(stage0))]
 pub struct DifferenceItems<'a, T:'a> {
     a: Peekable<&'a T, SetItems<'a, T>>,
     b: Peekable<&'a T, SetItems<'a, T>>,
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct SymDifferenceItems<'a, T> {
-    a: Peekable<&'a T, SetItems<'a, T>>,
-    b: Peekable<&'a T, SetItems<'a, T>>,
-}
-
 /// A lazy iterator producing elements in the set symmetric difference (in-order).
-#[cfg(not(stage0))]
 pub struct SymDifferenceItems<'a, T:'a> {
     a: Peekable<&'a T, SetItems<'a, T>>,
     b: Peekable<&'a T, SetItems<'a, T>>,
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct IntersectionItems<'a, T> {
-    a: Peekable<&'a T, SetItems<'a, T>>,
-    b: Peekable<&'a T, SetItems<'a, T>>,
-}
-
 /// A lazy iterator producing elements in the set intersection (in-order).
-#[cfg(not(stage0))]
 pub struct IntersectionItems<'a, T:'a> {
     a: Peekable<&'a T, SetItems<'a, T>>,
     b: Peekable<&'a T, SetItems<'a, T>>,
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct UnionItems<'a, T> {
-    a: Peekable<&'a T, SetItems<'a, T>>,
-    b: Peekable<&'a T, SetItems<'a, T>>,
-}
-
 /// A lazy iterator producing elements in the set union (in-order).
-#[cfg(not(stage0))]
 pub struct UnionItems<'a, T:'a> {
     a: Peekable<&'a T, SetItems<'a, T>>,
     b: Peekable<&'a T, SetItems<'a, T>>,

src/libcollections/trie.rs

@@ -857,17 +857,7 @@ fn remove<T>(count: &mut uint, child: &mut Child<T>, key: uint,
     return ret;
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct Entries<'a, T> {
-    stack: [slice::Items<'a, Child<T>>, .. NUM_CHUNKS],
-    length: uint,
-    remaining_min: uint,
-    remaining_max: uint
-}
-
 /// A forward iterator over a map.
-#[cfg(not(stage0))]
 pub struct Entries<'a, T:'a> {
     stack: [slice::Items<'a, Child<T>>, .. NUM_CHUNKS],
     length: uint,
@@ -875,18 +865,8 @@ pub struct Entries<'a, T:'a> {
     remaining_max: uint
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct MutEntries<'a, T> {
-    stack: [slice::MutItems<'a, Child<T>>, .. NUM_CHUNKS],
-    length: uint,
-    remaining_min: uint,
-    remaining_max: uint
-}
-
 /// A forward iterator over the key-value pairs of a map, with the
 /// values being mutable.
-#[cfg(not(stage0))]
 pub struct MutEntries<'a, T:'a> {
     stack: [slice::MutItems<'a, Child<T>>, .. NUM_CHUNKS],
     length: uint,

src/libcore/cell.rs

@@ -324,22 +324,12 @@ impl<T: PartialEq> PartialEq for RefCell<T> {
 
 /// Wraps a borrowed reference to a value in a `RefCell` box.
 #[unstable]
-#[cfg(not(stage0))]
 pub struct Ref<'b, T:'b> {
     // FIXME #12808: strange name to try to avoid interfering with
     // field accesses of the contained type via Deref
     _parent: &'b RefCell<T>
 }
 
-/// Dox.
-#[unstable]
-#[cfg(stage0)]
-pub struct Ref<'b, T> {
-    // FIXME #12808: strange name to try to avoid interfering with
-    // field accesses of the contained type via Deref
-    _parent: &'b RefCell<T>
-}
-
 #[unsafe_destructor]
 #[unstable]
 impl<'b, T> Drop for Ref<'b, T> {
@@ -379,22 +369,12 @@ pub fn clone_ref<'b, T>(orig: &Ref<'b, T>) -> Ref<'b, T> {
 
 /// Wraps a mutable borrowed reference to a value in a `RefCell` box.
 #[unstable]
-#[cfg(not(stage0))]
 pub struct RefMut<'b, T:'b> {
     // FIXME #12808: strange name to try to avoid interfering with
     // field accesses of the contained type via Deref
     _parent: &'b RefCell<T>
 }
 
-/// Dox.
-#[unstable]
-#[cfg(stage0)]
-pub struct RefMut<'b, T> {
-    // FIXME #12808: strange name to try to avoid interfering with
-    // field accesses of the contained type via Deref
-    _parent: &'b RefCell<T>
-}
-
 #[unsafe_destructor]
 #[unstable]
 impl<'b, T> Drop for RefMut<'b, T> {

src/libcore/finally.rs

@@ -102,18 +102,11 @@ pub fn try_finally<T,U,R>(mutate: &mut T,
     try_fn(&mut *f.mutate, drop)
 }
 
-#[cfg(not(stage0))]
 struct Finallyalizer<'a,A:'a> {
     mutate: &'a mut A,
     dtor: |&mut A|: 'a
 }
 
-#[cfg(stage0)]
-struct Finallyalizer<'a,A> {
-    mutate: &'a mut A,
-    dtor: |&mut A|: 'a
-}
-
 #[unsafe_destructor]
 impl<'a,A> Drop for Finallyalizer<'a,A> {
     #[inline]

src/libcore/intrinsics.rs

@@ -93,9 +93,6 @@ pub trait TyVisitor {
     fn visit_char(&mut self) -> bool;
 
     fn visit_estr_slice(&mut self) -> bool;
-    // NOTE: remove after snapshot
-    #[cfg(stage0)]
-    fn visit_estr_fixed(&mut self, n: uint, sz: uint, align: uint) -> bool;
 
     fn visit_box(&mut self, mtbl: uint, inner: *const TyDesc) -> bool;
     fn visit_uniq(&mut self, mtbl: uint, inner: *const TyDesc) -> bool;
@@ -103,11 +100,6 @@ pub trait TyVisitor {
     fn visit_rptr(&mut self, mtbl: uint, inner: *const TyDesc) -> bool;
 
     fn visit_evec_slice(&mut self, mtbl: uint, inner: *const TyDesc) -> bool;
-    // NOTE: remove after snapshot
-    #[cfg(stage0)]
-    fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint,
-                        mtbl: uint, inner: *const TyDesc) -> bool;
-    #[cfg(not(stage0))]
     fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint,
                         inner: *const TyDesc) -> bool;
 

src/libcore/iter.rs

@@ -777,18 +777,10 @@ impl<A, T: DoubleEndedIterator<A> + RandomAccessIterator<A>> RandomAccessIterato
 
 /// A mutable reference to an iterator
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-#[cfg(not(stage0))]
 pub struct ByRef<'a, T:'a> {
     iter: &'a mut T
 }
 
-/// Dox
-#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-#[cfg(stage0)]
-pub struct ByRef<'a, T> {
-    iter: &'a mut T
-}
-
 impl<'a, A, T: Iterator<A>+'a> Iterator<A> for ByRef<'a, T> {
     #[inline]
     fn next(&mut self) -> Option<A> { self.iter.next() }

src/libcore/lib.rs

@@ -58,7 +58,7 @@
 
 #![no_std]
 #![feature(globs, intrinsics, lang_items, macro_rules, managed_boxes, phase)]
-#![feature(simd, unsafe_destructor, issue_5723_bootstrap)]
+#![feature(simd, unsafe_destructor)]
 #![deny(missing_doc)]
 
 mod macros;

src/libcore/raw.rs

@@ -51,12 +51,6 @@ pub struct Procedure {
 ///
 /// This struct does not have a `Repr` implementation
 /// because there is no way to refer to all trait objects generically.
-#[cfg(stage0)]
-pub struct TraitObject {
-    pub vtable: *mut (),
-    pub data: *mut (),
-}
-#[cfg(not(stage0))]
 pub struct TraitObject {
     pub data: *mut (),
     pub vtable: *mut (),

src/libcore/slice.rs

@@ -1125,7 +1125,6 @@ impl<'a, T> ExactSize<&'a mut T> for MutItems<'a, T> {}
 
 /// An iterator over the slices of a vector separated by elements that
 /// match a predicate function.
-#[cfg(not(stage0))]
 #[experimental = "needs review"]
 pub struct Splits<'a, T:'a> {
     v: &'a [T],
@@ -1133,14 +1132,6 @@ pub struct Splits<'a, T:'a> {
     finished: bool
 }
 
-/// Dox.
-#[cfg(stage0)]
-pub struct Splits<'a, T> {
-    v: &'a [T],
-    pred: |t: &T|: 'a -> bool,
-    finished: bool
-}
-
 #[experimental = "needs review"]
 impl<'a, T> Iterator<&'a [T]> for Splits<'a, T> {
     #[inline]
@@ -1192,7 +1183,6 @@ impl<'a, T> DoubleEndedIterator<&'a [T]> for Splits<'a, T> {
 
 /// An iterator over the subslices of the vector which are separated
 /// by elements that match `pred`.
-#[cfg(not(stage0))]
 #[experimental = "needs review"]
 pub struct MutSplits<'a, T:'a> {
     v: &'a mut [T],
@@ -1200,14 +1190,6 @@ pub struct MutSplits<'a, T:'a> {
     finished: bool
 }
 
-/// Dox
-#[cfg(stage0)]
-pub struct MutSplits<'a, T> {
-    v: &'a mut [T],
-    pred: |t: &T|: 'a -> bool,
-    finished: bool
-}
-
 #[experimental = "needs review"]
 impl<'a, T> Iterator<&'a mut [T]> for MutSplits<'a, T> {
     #[inline]
@@ -1270,7 +1252,6 @@ impl<'a, T> DoubleEndedIterator<&'a mut [T]> for MutSplits<'a, T> {
 
 /// An iterator over the slices of a vector separated by elements that
 /// match a predicate function, splitting at most a fixed number of times.
-#[cfg(not(stage0))]
 #[experimental = "needs review"]
 pub struct SplitsN<'a, T:'a> {
     iter: Splits<'a, T>,
@@ -1278,14 +1259,6 @@ pub struct SplitsN<'a, T:'a> {
     invert: bool
 }
 
-/// Dox.
-#[cfg(stage0)]
-pub struct SplitsN<'a, T> {
-    iter: Splits<'a, T>,
-    count: uint,
-    invert: bool
-}
-
 #[experimental = "needs review"]
 impl<'a, T> Iterator<&'a [T]> for SplitsN<'a, T> {
     #[inline]
@@ -1315,17 +1288,6 @@ impl<'a, T> Iterator<&'a [T]> for SplitsN<'a, T> {
 
 /// An iterator over the (overlapping) slices of length `size` within
 /// a vector.
-#[cfg(stage0)]
-#[deriving(Clone)]
-#[experimental = "needs review"]
-pub struct Windows<'a, T> {
-    v: &'a [T],
-    size: uint
-}
-
-/// An iterator over the (overlapping) slices of length `size` within
-/// a vector.
-#[cfg(not(stage0))]
 #[deriving(Clone)]
 #[experimental = "needs review"]
 pub struct Windows<'a, T:'a> {
@@ -1361,21 +1323,8 @@ impl<'a, T> Iterator<&'a [T]> for Windows<'a, T> {
 ///
 /// When the vector len is not evenly divided by the chunk size,
 /// the last slice of the iteration will be the remainder.
-#[cfg(stage0)]
 #[deriving(Clone)]
 #[experimental = "needs review"]
-pub struct Chunks<'a, T> {
-    v: &'a [T],
-    size: uint
-}
-
-/// An iterator over a vector in (non-overlapping) chunks (`size`
-/// elements at a time).
-///
-/// When the vector len is not evenly divided by the chunk size,
-/// the last slice of the iteration will be the remainder.
-#[cfg(not(stage0))]
-#[deriving(Clone)]
 pub struct Chunks<'a, T:'a> {
     v: &'a [T],
     size: uint
@@ -1447,20 +1396,12 @@ impl<'a, T> RandomAccessIterator<&'a [T]> for Chunks<'a, T> {
 /// An iterator over a vector in (non-overlapping) mutable chunks (`size`  elements at a time). When
 /// the vector len is not evenly divided by the chunk size, the last slice of the iteration will be
 /// the remainder.
-#[cfg(not(stage0))]
 #[experimental = "needs review"]
 pub struct MutChunks<'a, T:'a> {
     v: &'a mut [T],
     chunk_size: uint
 }
 
-/// Dox.
-#[cfg(stage0)]
-pub struct MutChunks<'a, T> {
-    v: &'a mut [T],
-    chunk_size: uint
-}
-
 #[experimental = "needs review"]
 impl<'a, T> Iterator<&'a mut [T]> for MutChunks<'a, T> {
     #[inline]

src/libdebug/lib.rs

@@ -25,7 +25,7 @@
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/master/")]
 #![experimental]
-#![feature(managed_boxes, macro_rules, issue_5723_bootstrap)]
+#![feature(managed_boxes, macro_rules)]
 #![allow(experimental)]
 
 pub mod fmt;

src/libdebug/reflect.rs

@@ -193,17 +193,6 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
         true
     }
 
-    // NOTE: remove after snapshot
-    #[cfg(stage0)]
-    fn visit_estr_fixed(&mut self, n: uint,
-                        sz: uint,
-                        align: uint) -> bool {
-        self.align(align);
-        if ! self.inner.visit_estr_fixed(n, sz, align) { return false; }
-        self.bump(sz);
-        true
-    }
-
     fn visit_box(&mut self, mtbl: uint, inner: *const TyDesc) -> bool {
         self.align_to::<Gc<u8>>();
         if ! self.inner.visit_box(mtbl, inner) { return false; }
@@ -239,17 +228,6 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
         true
     }
 
-    #[cfg(stage0)]
-    fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint,
-                        mtbl: uint, inner: *const TyDesc) -> bool {
-        self.align(align);
-        if ! self.inner.visit_evec_fixed(n, sz, align, mtbl, inner) {
-            return false;
-        }
-        self.bump(sz);
-        true
-    }
-    #[cfg(not(stage0))]
     fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint,
                         inner: *const TyDesc) -> bool {
         self.align(align);

src/libdebug/repr.rs

@@ -274,12 +274,6 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
         self.get::<&str>(|this, s| this.write_escaped_slice(*s))
     }
 
-    // Type no longer exists, vestigial function.
-    // NOTE: remove after snapshot
-    #[cfg(stage0)]
-    fn visit_estr_fixed(&mut self, _n: uint, _sz: uint,
-                        _align: uint) -> bool { fail!(); }
-
     fn visit_box(&mut self, mtbl: uint, inner: *const TyDesc) -> bool {
         try!(self, self.writer.write("box(GC) ".as_bytes()));
         self.write_mut_qualifier(mtbl);
@@ -330,17 +324,6 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
         })
     }
 
-    // NOTE: remove after snapshot
-    #[cfg(stage0)]
-    fn visit_evec_fixed(&mut self, n: uint, sz: uint, _align: uint,
-                        _: uint, inner: *const TyDesc) -> bool {
-        let assumed_size = if sz == 0 { n } else { sz };
-        self.get::<()>(|this, b| {
-            this.write_vec_range(b, assumed_size, inner)
-        })
-    }
-
-    #[cfg(not(stage0))]
     fn visit_evec_fixed(&mut self, n: uint, sz: uint, _align: uint,
                         inner: *const TyDesc) -> bool {
         let assumed_size = if sz == 0 { n } else { sz };

src/libfmt_macros/lib.rs

@@ -21,9 +21,6 @@
 #![crate_type = "dylib"]
 #![feature(macro_rules, globs, import_shadowing)]
 
-// NOTE(stage0, pcwalton): Remove after snapshot.
-#![allow(unknown_features)]
-
 use std::char;
 use std::str;
 

src/libgetopts/lib.rs

@@ -91,9 +91,6 @@
 #![feature(import_shadowing)]
 #![deny(missing_doc)]
 
-// NOTE(stage0, pcwalton): Remove after snapshot.
-#![allow(unknown_features)]
-
 #[cfg(test)] extern crate debug;
 #[cfg(test)] #[phase(plugin, link)] extern crate log;
 

src/libgraphviz/lib.rs

@@ -271,7 +271,6 @@ pub fn main() {
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![license = "MIT/ASL2"]
-#![feature(issue_5723_bootstrap)]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/master/")]

src/libgraphviz/maybe_owned_vec.rs

@@ -34,19 +34,11 @@ use std::slice;
 /// Some clients will have a pre-allocated vector ready to hand off in
 /// a slice; others will want to create the set on the fly and hand
 /// off ownership, via `Growable`.
-#[cfg(not(stage0))]
 pub enum MaybeOwnedVector<'a,T:'a> {
     Growable(Vec<T>),
     Borrowed(&'a [T]),
 }
 
-/// Stage0 only.
-#[cfg(stage0)]
-pub enum MaybeOwnedVector<'a,T> {
-    Growable(Vec<T>),
-    Borrowed(&'a [T]),
-}
-
 /// Trait for moving into a `MaybeOwnedVector`
 pub trait IntoMaybeOwnedVector<'a,T> {
     /// Moves self into a `MaybeOwnedVector`

src/librand/distributions/mod.rs

@@ -79,13 +79,6 @@ pub struct Weighted<T> {
     pub item: T,
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct WeightedChoice<'a, T> {
-    items: &'a mut [Weighted<T>],
-    weight_range: Range<uint>
-}
-
 /// A distribution that selects from a finite collection of weighted items.
 ///
 /// Each item has an associated weight that influences how likely it
@@ -112,7 +105,6 @@ pub struct WeightedChoice<'a, T> {
 ///      println!("{}", wc.ind_sample(&mut rng));
 /// }
 /// ```
-#[cfg(not(stage0))]
 pub struct WeightedChoice<'a, T:'a> {
     items: &'a mut [Weighted<T>],
     weight_range: Range<uint>

src/librand/lib.rs

@@ -269,16 +269,9 @@ pub trait Rng {
     }
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct Generator<'a, T, R> {
-    rng: &'a mut R,
-}
-
 /// Iterator which will generate a stream of random items.
 ///
 /// This iterator is created via the `gen_iter` method on `Rng`.
-#[cfg(not(stage0))]
 pub struct Generator<'a, T, R:'a> {
     rng: &'a mut R,
 }
@@ -289,16 +282,9 @@ impl<'a, T: Rand, R: Rng> Iterator<T> for Generator<'a, T, R> {
     }
 }
 
-/// Note: stage0-specific version.
-#[cfg(stage0)]
-pub struct AsciiGenerator<'a, R> {
-    rng: &'a mut R,
-}
-
 /// Iterator which will continuously generate random ascii characters.
 ///
 /// This iterator is created via the `gen_ascii_chars` method on `Rng`.
-#[cfg(not(stage0))]
 pub struct AsciiGenerator<'a, R:'a> {
     rng: &'a mut R,
 }

src/librbml/lib.rs

@@ -24,7 +24,7 @@
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/master/",
        html_playground_url = "http://play.rust-lang.org/")]
-#![feature(macro_rules, phase, issue_5723_bootstrap)]
+#![feature(macro_rules, phase)]
 #![allow(missing_doc)]
 
 extern crate serialize;
@@ -662,14 +662,6 @@ pub mod writer {
     pub type EncodeResult = io::IoResult<()>;
 
     // rbml writing
-    #[cfg(stage0)]
-    pub struct Encoder<'a, W> {
-        pub writer: &'a mut W,
-        size_positions: Vec<uint>,
-    }
-
-    // rbml writing
-    #[cfg(not(stage0))]
     pub struct Encoder<'a, W:'a> {
         pub writer: &'a mut W,
         size_positions: Vec<uint>,

src/librlibc/lib.rs

@@ -35,9 +35,6 @@
 // LLVM to optimize these function calls to themselves!
 #![no_builtins]
 
-// NOTE(stage0, pcwalton): Remove after snapshot.
-#![allow(unknown_features)]
-
 #[cfg(test)] extern crate native;
 #[cfg(test)] extern crate test;
 #[cfg(test)] extern crate debug;

src/librustc/lib.rs

@@ -31,7 +31,6 @@ This API is completely unstable and subject to change.
 #![allow(deprecated)]
 #![feature(macro_rules, globs, struct_variant, managed_boxes, quote)]
 #![feature(default_type_params, phase, unsafe_destructor)]
-#![feature(issue_5723_bootstrap)]
 
 #![allow(unknown_features)] // NOTE: Remove after next snapshot
 #![feature(rustc_diagnostic_macros)]

src/librustc/middle/dataflow.rs

@@ -80,13 +80,6 @@ pub trait DataFlowOperator : BitwiseOperator {
     fn initial_value(&self) -> bool;
 }
 
-#[cfg(stage0)]
-struct PropagationContext<'a, 'b, O> {
-    dfcx: &'a mut DataFlowContext<'b, O>,
-    changed: bool
-}
-
-#[cfg(not(stage0))]
 struct PropagationContext<'a, 'b:'a, O:'a> {
     dfcx: &'a mut DataFlowContext<'b, O>,
     changed: bool

src/librustc/middle/expr_use_visitor.rs

@@ -192,14 +192,6 @@ impl OverloadedCallType {
 // supplies types from the tree. After type checking is complete, you
 // can just use the tcx as the typer.
 
-#[cfg(stage0)]
-pub struct ExprUseVisitor<'d,'t,TYPER> {
-    typer: &'t TYPER,
-    mc: mc::MemCategorizationContext<'t,TYPER>,
-    delegate: &'d mut Delegate+'d,
-}
-
-#[cfg(not(stage0))]
 pub struct ExprUseVisitor<'d,'t,TYPER:'t> {
     typer: &'t TYPER,
     mc: mc::MemCategorizationContext<'t,TYPER>,

src/librustc/middle/mem_categorization.rs

@@ -240,12 +240,6 @@ impl ast_node for ast::Pat {
     fn span(&self) -> Span { self.span }
 }
 
-#[cfg(stage0)]
-pub struct MemCategorizationContext<'t,TYPER> {
-    typer: &'t TYPER
-}
-
-#[cfg(not(stage0))]
 pub struct MemCategorizationContext<'t,TYPER:'t> {
     typer: &'t TYPER
 }

src/librustc/middle/trans/_match.rs

@@ -340,21 +340,12 @@ struct ArmData<'a, 'b> {
  * As we proceed `bound_ptrs` are filled with pointers to values to be bound,
  * these pointers are stored in llmatch variables just before executing `data` arm.
  */
-#[cfg(not(stage0))]
 struct Match<'a, 'b:'a> {
     pats: Vec<Gc<ast::Pat>>,
     data: &'a ArmData<'a, 'b>,
     bound_ptrs: Vec<(Ident, ValueRef)>
 }
 
-///Dox
-#[cfg(stage0)]
-struct Match<'a, 'b> {
-    pats: Vec<Gc<ast::Pat>>,
-    data: &'a ArmData<'a, 'b>,
-    bound_ptrs: Vec<(Ident, ValueRef)>
-}
-
 impl<'a, 'b> Repr for Match<'a, 'b> {
     fn repr(&self, tcx: &ty::ctxt) -> String {
         if tcx.sess.verbose() {

src/librustrt/exclusive.rs

@@ -26,17 +26,7 @@ pub struct Exclusive<T> {
     data: UnsafeCell<T>,
 }
 
-/// stage0 only
-#[cfg(stage0)]
-pub struct ExclusiveGuard<'a, T> {
-    // FIXME #12808: strange name to try to avoid interfering with
-    // field accesses of the contained type via Deref
-    _data: &'a mut T,
-    _guard: mutex::LockGuard<'a>,
-}
-
 /// An RAII guard returned via `lock`
-#[cfg(not(stage0))]
 pub struct ExclusiveGuard<'a, T:'a> {
     // FIXME #12808: strange name to try to avoid interfering with
     // field accesses of the contained type via Deref

src/librustrt/lib.rs

@@ -19,13 +19,9 @@
 #![feature(macro_rules, phase, globs, thread_local, managed_boxes, asm)]
 #![feature(linkage, lang_items, unsafe_destructor, default_type_params)]
 #![feature(import_shadowing)]
-#![feature(issue_5723_bootstrap)]
 #![no_std]
 #![experimental]
 
-// NOTE(stage0, pcwalton): Remove after snapshot.
-#![allow(unknown_features)]
-
 #[phase(plugin, link)] extern crate core;
 extern crate alloc;
 extern crate libc;

src/librustrt/local_data.rs

@@ -144,7 +144,6 @@ unsafe fn get_local_map<'a>() -> Option<&'a mut Map> {
 ///
 /// The task-local data can be accessed through this value, and when this
 /// structure is dropped it will return the borrow on the data.
-#[cfg(not(stage0))]
 pub struct Ref<T:'static> {
     // FIXME #12808: strange names to try to avoid interfering with
     // field accesses of the contained type via Deref
@@ -152,15 +151,6 @@ pub struct Ref<T:'static> {
     _marker: marker::NoSend
 }
 
-/// stage0 only
-#[cfg(stage0)]
-pub struct Ref<T> {
-    // FIXME #12808: strange names to try to avoid interfering with
-    // field accesses of the contained type via Deref
-    _inner: &'static TLDValueBox<T>,
-    _marker: marker::NoSend
-}
-
 fn key_to_key_value<T: 'static>(key: Key<T>) -> uint {
     key as *const _ as uint
 }

src/librustuv/access.rs

@@ -26,13 +26,6 @@ pub struct Access<T> {
     inner: Arc<UnsafeCell<Inner<T>>>,
 }
 
-#[cfg(stage0)]
-pub struct Guard<'a, T> {
-    access: &'a mut Access<T>,
-    missile: Option<HomingMissile>,
-}
-
-#[cfg(not(stage0))]
 pub struct Guard<'a, T:'static> {
     access: &'a mut Access<T>,
     missile: Option<HomingMissile>,

src/librustuv/timeout.rs

@@ -28,14 +28,6 @@ pub struct AccessTimeout<T> {
     pub access: access::Access<T>,
 }
 
-#[cfg(stage0)]
-pub struct Guard<'a, T> {
-    state: &'a mut TimeoutState,
-    pub access: access::Guard<'a, T>,
-    pub can_timeout: bool,
-}
-
-#[cfg(not(stage0))]
 pub struct Guard<'a, T:'static> {
     state: &'a mut TimeoutState,
     pub access: access::Guard<'a, T>,

src/libserialize/lib.rs

@@ -24,7 +24,6 @@ Core encoding and decoding interfaces.
        html_root_url = "http://doc.rust-lang.org/master/",
        html_playground_url = "http://play.rust-lang.org/")]
 #![feature(macro_rules, managed_boxes, default_type_params, phase)]
-#![feature(issue_5723_bootstrap)]
 
 // test harness access
 #[cfg(test)]

src/libstd/collections/hashmap.rs

@@ -409,32 +409,14 @@ mod table {
         assert_eq!(size_of::<SafeHash>(), size_of::<u64>())
     }
 
-    /// Note: stage0-specific version that lacks bound.
-    #[cfg(stage0)]
-    pub struct Entries<'a, K, V> {
-        table: &'a RawTable<K, V>,
-        idx: uint,
-        elems_seen: uint,
-    }
-
     /// Iterator over shared references to entries in a table.
-    #[cfg(not(stage0))]
     pub struct Entries<'a, K:'a, V:'a> {
         table: &'a RawTable<K, V>,
         idx: uint,
         elems_seen: uint,
     }
 
-    /// Note: stage0-specific version that lacks bound.
-    #[cfg(stage0)]
-    pub struct MutEntries<'a, K, V> {
-        table: &'a mut RawTable<K, V>,
-        idx: uint,
-        elems_seen: uint,
-    }
-
     /// Iterator over mutable references to entries in a table.
-    #[cfg(not(stage0))]
     pub struct MutEntries<'a, K:'a, V:'a> {
         table: &'a mut RawTable<K, V>,
         idx: uint,

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,
 }

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,
 }

src/libstd/lib.rs

@@ -108,14 +108,10 @@
 #![feature(macro_rules, globs, managed_boxes, linkage)]
 #![feature(default_type_params, phase, lang_items, unsafe_destructor)]
 #![feature(import_shadowing)]
-#![feature(issue_5723_bootstrap)]
 
 // Don't link to std. We are std.
 #![no_std]
 
-// NOTE(stage0, pcwalton): Remove after snapshot.
-#![allow(unknown_features)]
-
 #![allow(deprecated)]
 #![deny(missing_doc)]
 

src/libstd/path/mod.rs

@@ -825,15 +825,7 @@ pub trait GenericPathUnsafe {
     unsafe fn push_unchecked<T: BytesContainer>(&mut self, path: T);
 }
 
-/// Note: stage0-specific version that lacks bound.
-#[cfg(stage0)]
-pub struct Display<'a, P> {
-    path: &'a P,
-    filename: bool
-}
-
 /// Helper struct for printing paths with format!()
-#[cfg(not(stage0))]
 pub struct Display<'a, P:'a> {
     path: &'a P,
     filename: bool

src/libstd/rt/backtrace.rs

@@ -701,30 +701,6 @@ mod imp {
     static IMAGE_FILE_MACHINE_IA64: libc::DWORD = 0x0200;
     static IMAGE_FILE_MACHINE_AMD64: libc::DWORD = 0x8664;
 
-    #[cfg(stage0)]
-    #[packed]
-    struct SYMBOL_INFO {
-        SizeOfStruct: libc::c_ulong,
-        TypeIndex: libc::c_ulong,
-        Reserved: [u64, ..2],
-        Index: libc::c_ulong,
-        Size: libc::c_ulong,
-        ModBase: u64,
-        Flags: libc::c_ulong,
-        Value: u64,
-        Address: u64,
-        Register: libc::c_ulong,
-        Scope: libc::c_ulong,
-        Tag: libc::c_ulong,
-        NameLen: libc::c_ulong,
-        MaxNameLen: libc::c_ulong,
-        // note that windows has this as 1, but it basically just means that
-        // the name is inline at the end of the struct. For us, we just bump
-        // the struct size up to MAX_SYM_NAME.
-        Name: [libc::c_char, ..MAX_SYM_NAME],
-    }
-
-    #[cfg(not(stage0))]
     #[repr(C, packed)]
     struct SYMBOL_INFO {
         SizeOfStruct: libc::c_ulong,

src/libsync/comm/mod.rs

@@ -386,18 +386,10 @@ pub struct Receiver<T> {
 /// whenever `next` is called, waiting for a new message, and `None` will be
 /// returned when the corresponding channel has hung up.
 #[unstable]
-#[cfg(not(stage0))]
 pub struct Messages<'a, T:'a> {
     rx: &'a Receiver<T>
 }
 
-/// Stage0 only
-#[cfg(stage0)]
-#[unstable]
-pub struct Messages<'a, T> {
-    rx: &'a Receiver<T>
-}
-
 /// The sending-half of Rust's asynchronous channel type. This half can only be
 /// owned by one task, but it can be cloned to send to other tasks.
 #[unstable]

src/libsync/comm/select.rs

@@ -76,7 +76,6 @@ pub struct Select {
 /// A handle to a receiver which is currently a member of a `Select` set of
 /// receivers.  This handle is used to keep the receiver in the set as well as
 /// interact with the underlying receiver.
-#[cfg(not(stage0))]
 pub struct Handle<'rx, T:'rx> {
     /// The ID of this handle, used to compare against the return value of
     /// `Select::wait()`
@@ -92,23 +91,6 @@ pub struct Handle<'rx, T:'rx> {
     rx: &'rx Receiver<T>,
 }
 
-/// Stage0 only
-#[cfg(stage0)]
-pub struct Handle<'rx, T> {
-    /// The ID of this handle, used to compare against the return value of
-    /// `Select::wait()`
-    id: uint,
-    selector: &'rx Select,
-    next: *mut Handle<'static, ()>,
-    prev: *mut Handle<'static, ()>,
-    added: bool,
-    packet: &'rx Packet+'rx,
-
-    // due to our fun transmutes, we be sure to place this at the end. (nothing
-    // previous relies on T)
-    rx: &'rx Receiver<T>,
-}
-
 struct Packets { cur: *mut Handle<'static, ()> }
 
 #[doc(hidden)]

src/libsync/lib.rs

@@ -29,13 +29,9 @@
 
 #![feature(phase, globs, macro_rules, unsafe_destructor)]
 #![feature(import_shadowing)]
-#![feature(issue_5723_bootstrap)]
 #![deny(missing_doc)]
 #![no_std]
 
-// NOTE(stage0, pcwalton): Remove after snapshot.
-#![allow(unknown_features)]
-
 #[phase(plugin, link)] extern crate core;
 extern crate alloc;
 extern crate collections;

src/libsync/lock.rs

@@ -180,7 +180,6 @@ pub struct Mutex<T> {
 
 /// An guard which is created by locking a mutex. Through this guard the
 /// underlying data can be accessed.
-#[cfg(not(stage0))]
 pub struct MutexGuard<'a, T:'a> {
     // FIXME #12808: strange name to try to avoid interfering with
     // field accesses of the contained type via Deref
@@ -190,17 +189,6 @@ pub struct MutexGuard<'a, T:'a> {
     pub cond: Condvar<'a>,
 }
 
-/// stage0 only
-#[cfg(stage0)]
-pub struct MutexGuard<'a, T> {
-    // FIXME #12808: strange name to try to avoid interfering with
-    // field accesses of the contained type via Deref
-    _data: &'a mut T,
-    /// Inner condition variable connected to the locked mutex that this guard
-    /// was created from. This can be used for atomic-unlock-and-deschedule.
-    pub cond: Condvar<'a>,
-}
-
 impl<T: Send> Mutex<T> {
     /// Creates a new mutex to protect the user-supplied data.
     pub fn new(user_data: T) -> Mutex<T> {
@@ -292,7 +280,6 @@ pub struct RWLock<T> {
 
 /// A guard which is created by locking an rwlock in write mode. Through this
 /// guard the underlying data can be accessed.
-#[cfg(not(stage0))]
 pub struct RWLockWriteGuard<'a, T:'a> {
     // FIXME #12808: strange name to try to avoid interfering with
     // field accesses of the contained type via Deref
@@ -302,20 +289,8 @@ pub struct RWLockWriteGuard<'a, T:'a> {
     pub cond: Condvar<'a>,
 }
 
-/// stage0 only
-#[cfg(stage0)]
-pub struct RWLockWriteGuard<'a, T> {
-    // FIXME #12808: strange name to try to avoid interfering with
-    // field accesses of the contained type via Deref
-    _data: &'a mut T,
-    /// Inner condition variable that can be used to sleep on the write mode of
-    /// this rwlock.
-    pub cond: Condvar<'a>,
-}
-
 /// A guard which is created by locking an rwlock in read mode. Through this
 /// guard the underlying data can be accessed.
-#[cfg(not(stage0))]
 pub struct RWLockReadGuard<'a, T:'a> {
     // FIXME #12808: strange names to try to avoid interfering with
     // field accesses of the contained type via Deref
@@ -323,15 +298,6 @@ pub struct RWLockReadGuard<'a, T:'a> {
     _guard: raw::RWLockReadGuard<'a>,
 }
 
-/// Stage0 only
-#[cfg(stage0)]
-pub struct RWLockReadGuard<'a, T> {
-    // FIXME #12808: strange names to try to avoid interfering with
-    // field accesses of the contained type via Deref
-    _data: &'a T,
-    _guard: raw::RWLockReadGuard<'a>,
-}
-
 impl<T: Send + Sync> RWLock<T> {
     /// Create a reader/writer lock with the supplied data.
     pub fn new(user_data: T) -> RWLock<T> {

src/libsync/raw.rs

@@ -103,13 +103,6 @@ struct SemInner<Q> {
 }
 
 #[must_use]
-#[cfg(stage0)]
-struct SemGuard<'a, Q> {
-    sem: &'a Sem<Q>,
-}
-
-#[must_use]
-#[cfg(not(stage0))]
 struct SemGuard<'a, Q:'a> {
     sem: &'a Sem<Q>,
 }

src/libsyntax/ast_map/mod.rs

@@ -68,12 +68,7 @@ impl<'a> Iterator<PathElem> for LinkedPath<'a> {
     }
 }
 
-#[cfg(stage0)]
-#[deriving(Clone)]
-pub struct Values<'a, T>(pub slice::Items<'a, T>);
-
 // HACK(eddyb) move this into libstd (value wrapper for slice::Items).
-#[cfg(not(stage0))]
 #[deriving(Clone)]
 pub struct Values<'a, T:'a>(pub slice::Items<'a, T>);
 
@@ -483,15 +478,6 @@ impl Map {
     }
 }
 
-#[cfg(stage0)]
-pub struct NodesMatchingSuffix<'a, S> {
-    map: &'a Map,
-    item_name: &'a S,
-    in_which: &'a [S],
-    idx: NodeId,
-}
-
-#[cfg(not(stage0))]
 pub struct NodesMatchingSuffix<'a, S:'a> {
     map: &'a Map,
     item_name: &'a S,

src/libsyntax/ast_util.rs

@@ -349,14 +349,6 @@ pub trait IdVisitingOperation {
 /// A visitor that applies its operation to all of the node IDs
 /// in a visitable thing.
 
-#[cfg(stage0)]
-pub struct IdVisitor<'a, O> {
-    pub operation: &'a O,
-    pub pass_through_items: bool,
-    pub visited_outermost: bool,
-}
-
-#[cfg(not(stage0))]
 pub struct IdVisitor<'a, O:'a> {
     pub operation: &'a O,
     pub pass_through_items: bool,

src/libsyntax/lib.rs

@@ -25,12 +25,8 @@
 
 #![feature(macro_rules, globs, managed_boxes, default_type_params, phase)]
 #![feature(quote, struct_variant, unsafe_destructor, import_shadowing)]
-#![feature(issue_5723_bootstrap)]
 #![allow(deprecated)]
 
-// NOTE(stage0, pcwalton): Remove after snapshot.
-#![allow(unknown_features)]
-
 extern crate fmt_macros;
 extern crate debug;
 #[phase(plugin, link)] extern crate log;

src/snapshots.txt

@@ -1,3 +1,11 @@
+S 2014-08-29 6025926
+  freebsd-x86_64 285330b798eefcc929fc94c9d0604b6172ce3309
+  linux-i386 5b57ab2dc32952dc78551a955f3c1746b2d915a3
+  linux-x86_64 2624aeac3fe1b2359b61c1109e4708680e237ca5
+  macos-i386 deffce32408b023bcda84f6ce338ca3de02f406b
+  macos-x86_64 8ef7351e34fc1583570d752d223ddc6eb68ef27b
+  winnt-i386 c2dfa9a358de8cc554007addbc09e3e43d49aec6
+
 S 2014-08-17 a86d9ad
   freebsd-x86_64 f49e0c8e64c8a60dc47df9965974d2a98ef70b34
   linux-i386 8f2c5f6a1b6504ee63de73c7a53aee1e4b07bca5

src/test/run-pass/reflect-visit-type.rs

@@ -61,11 +61,6 @@ impl TyVisitor for MyVisitor {
     fn visit_char(&mut self) -> bool { true }
 
     fn visit_estr_slice(&mut self) -> bool { true }
-    // NOTE: remove after snapshot
-    #[cfg(stage0)]
-    fn visit_estr_fixed(&mut self,
-                        _sz: uint, _sz2: uint,
-                        _align: uint) -> bool { true }
 
     fn visit_box(&mut self, _mtbl: uint, _inner: *const TyDesc) -> bool { true }
     fn visit_uniq(&mut self, _mtbl: uint, _inner: *const TyDesc) -> bool { true }