auto merge of #16859 : alexcrichton/rust/snapshots, r=huonw

7 files changed, 1 insertions, 109 deletions

diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs
index 569cf98ebc8..1cad9a3f8ca 100644
--- a/src/libcore/cell.rs
+++ b/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> {
diff --git a/src/libcore/finally.rs b/src/libcore/finally.rs
index c36150eb964..9b59b410e7c 100644
--- a/src/libcore/finally.rs
+++ b/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]
diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs
index 4ecc1b8f45f..9636ce6a736 100644
--- a/src/libcore/intrinsics.rs
+++ b/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;
 
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index f8a56b3d6fc..da7f026aed4 100644
--- a/src/libcore/iter.rs
+++ b/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() }
diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs
index 050e2348111..7e2ea492d4c 100644
--- a/src/libcore/lib.rs
+++ b/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;
diff --git a/src/libcore/raw.rs b/src/libcore/raw.rs
index 5daa693c774..188ef2a3b88 100644
--- a/src/libcore/raw.rs
+++ b/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 (),
diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index 5a70cd8c847..5070a3973d1 100644
--- a/src/libcore/slice.rs
+++ b/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]