Remove #[cfg(stage0)] items.

3 files changed, 2 insertions, 145 deletions

diff --git a/src/libcollections/borrow.rs b/src/libcollections/borrow.rs
index 08bd88cd861..8e8fc0bedec 100644
--- a/src/libcollections/borrow.rs
+++ b/src/libcollections/borrow.rs
@@ -116,17 +116,11 @@ impl<'a, T: ?Sized> BorrowMut<T> for &'a mut T {
     fn borrow_mut(&mut self) -> &mut T { &mut **self }
 }
 
-#[cfg(stage0)]
-impl<T> Borrow<T> for rc::Rc<T> {
-    fn borrow(&self) -> &T { &**self }
-}
-
-#[cfg(not(stage0))]
 impl<T: ?Sized> Borrow<T> for rc::Rc<T> {
     fn borrow(&self) -> &T { &**self }
 }
 
-impl<T> Borrow<T> for arc::Arc<T> {
+impl<T: ?Sized> Borrow<T> for arc::Arc<T> {
     fn borrow(&self) -> &T { &**self }
 }
 
diff --git a/src/libcollections/btree/node.rs b/src/libcollections/btree/node.rs
index 4f3c3b08263..2d8335d3734 100644
--- a/src/libcollections/btree/node.rs
+++ b/src/libcollections/btree/node.rs
@@ -19,7 +19,6 @@ pub use self::TraversalItem::*;
 use core::prelude::*;
 
 use core::cmp::Ordering::{Greater, Less, Equal};
-#[cfg(not(stage0))]
 use core::intrinsics::arith_offset;
 use core::iter::Zip;
 use core::marker::PhantomData;
@@ -207,22 +206,6 @@ impl<T> RawItems<T> {
         RawItems::from_parts(slice.as_ptr(), slice.len())
     }
 
-    #[cfg(stage0)]
-    unsafe fn from_parts(ptr: *const T, len: usize) -> RawItems<T> {
-        if mem::size_of::<T>() == 0 {
-            RawItems {
-                head: ptr,
-                tail: (ptr as usize + len) as *const T,
-            }
-        } else {
-            RawItems {
-                head: ptr,
-                tail: ptr.offset(len as isize),
-            }
-        }
-    }
-
-    #[cfg(not(stage0))]
     unsafe fn from_parts(ptr: *const T, len: usize) -> RawItems<T> {
         if mem::size_of::<T>() == 0 {
             RawItems {
@@ -237,18 +220,6 @@ impl<T> RawItems<T> {
         }
     }
 
-    #[cfg(stage0)]
-    unsafe fn push(&mut self, val: T) {
-        ptr::write(self.tail as *mut T, val);
-
-        if mem::size_of::<T>() == 0 {
-            self.tail = (self.tail as usize + 1) as *const T;
-        } else {
-            self.tail = self.tail.offset(1);
-        }
-    }
-
-    #[cfg(not(stage0))]
     unsafe fn push(&mut self, val: T) {
         ptr::write(self.tail as *mut T, val);
 
@@ -263,26 +234,6 @@ impl<T> RawItems<T> {
 impl<T> Iterator for RawItems<T> {
     type Item = T;
 
-    #[cfg(stage0)]
-    fn next(&mut self) -> Option<T> {
-        if self.head == self.tail {
-            None
-        } else {
-            unsafe {
-                let ret = Some(ptr::read(self.head));
-
-                if mem::size_of::<T>() == 0 {
-                    self.head = (self.head as usize + 1) as *const T;
-                } else {
-                    self.head = self.head.offset(1);
-                }
-
-                ret
-            }
-        }
-    }
-
-    #[cfg(not(stage0))]
     fn next(&mut self) -> Option<T> {
         if self.head == self.tail {
             None
@@ -303,24 +254,6 @@ impl<T> Iterator for RawItems<T> {
 }
 
 impl<T> DoubleEndedIterator for RawItems<T> {
-    #[cfg(stage0)]
-    fn next_back(&mut self) -> Option<T> {
-        if self.head == self.tail {
-            None
-        } else {
-            unsafe {
-                if mem::size_of::<T>() == 0 {
-                    self.tail = (self.tail as usize - 1) as *const T;
-                } else {
-                    self.tail = self.tail.offset(-1);
-                }
-
-                Some(ptr::read(self.tail))
-            }
-        }
-    }
-
-    #[cfg(not(stage0))]
     fn next_back(&mut self) -> Option<T> {
         if self.head == self.tail {
             None
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index 84fe5ba1fbf..4d52eb8e8ae 100644
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -66,9 +66,7 @@ use core::cmp::max;
 use core::cmp::Ordering;
 use core::fmt;
 use core::hash::{self, Hash};
-use core::intrinsics::assume;
-#[cfg(not(stage0))]
-use core::intrinsics::arith_offset;
+use core::intrinsics::{arith_offset, assume};
 use core::iter::{repeat, FromIterator};
 use core::marker::PhantomData;
 use core::mem;
@@ -1526,25 +1524,6 @@ impl<T> IntoIterator for Vec<T> {
     /// }
     /// ```
     #[inline]
-    #[cfg(stage0)]
-    fn into_iter(self) -> IntoIter<T> {
-        unsafe {
-            let ptr = *self.ptr;
-            assume(!ptr.is_null());
-            let cap = self.cap;
-            let begin = ptr as *const T;
-            let end = if mem::size_of::<T>() == 0 {
-                (ptr as usize + self.len()) as *const T
-            } else {
-                ptr.offset(self.len() as isize) as *const T
-            };
-            mem::forget(self);
-            IntoIter { allocation: ptr, cap: cap, ptr: begin, end: end }
-        }
-    }
-
-    #[inline]
-    #[cfg(not(stage0))]
     fn into_iter(self) -> IntoIter<T> {
         unsafe {
             let ptr = *self.ptr;
@@ -1764,32 +1743,6 @@ impl<T> Iterator for IntoIter<T> {
     type Item = T;
 
     #[inline]
-    #[cfg(stage0)]
-    fn next(&mut self) -> Option<T> {
-        unsafe {
-            if self.ptr == self.end {
-                None
-            } else {
-                if mem::size_of::<T>() == 0 {
-                    // purposefully don't use 'ptr.offset' because for
-                    // vectors with 0-size elements this would return the
-                    // same pointer.
-                    self.ptr = mem::transmute(self.ptr as usize + 1);
-
-                    // Use a non-null pointer value
-                    Some(ptr::read(EMPTY as *mut T))
-                } else {
-                    let old = self.ptr;
-                    self.ptr = self.ptr.offset(1);
-
-                    Some(ptr::read(old))
-                }
-            }
-        }
-    }
-
-    #[inline]
-    #[cfg(not(stage0))]
     fn next(&mut self) -> Option<T> {
         unsafe {
             if self.ptr == self.end {
@@ -1830,29 +1783,6 @@ impl<T> Iterator for IntoIter<T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> DoubleEndedIterator for IntoIter<T> {
     #[inline]
-    #[cfg(stage0)]
-    fn next_back(&mut self) -> Option<T> {
-        unsafe {
-            if self.end == self.ptr {
-                None
-            } else {
-                if mem::size_of::<T>() == 0 {
-                    // See above for why 'ptr.offset' isn't used
-                    self.end = mem::transmute(self.end as usize - 1);
-
-                    // Use a non-null pointer value
-                    Some(ptr::read(EMPTY as *mut T))
-                } else {
-                    self.end = self.end.offset(-1);
-
-                    Some(ptr::read(mem::transmute(self.end)))
-                }
-            }
-        }
-    }
-
-    #[inline]
-    #[cfg(not(stage0))]
     fn next_back(&mut self) -> Option<T> {
         unsafe {
             if self.end == self.ptr {