Remove all #[cfg(stage0)]-protected code

New snapshot means this can all go. Also removes places that have
comments that say they are workarounds for stage0 errors.

src/libextra/num/complex.rs

@@ -80,7 +80,6 @@ impl<T: Clone + Num> Cmplx<T> {
     }
 }
 
-#[cfg(not(stage0))] // Fixed by #4228
 impl<T: Clone + Algebraic + Num> Cmplx<T> {
     /// Calculate |self|
     #[inline]
@@ -89,7 +88,6 @@ impl<T: Clone + Algebraic + Num> Cmplx<T> {
     }
 }
 
-#[cfg(not(stage0))] // Fixed by #4228
 impl<T: Clone + Trigonometric + Algebraic + Num> Cmplx<T> {
     /// Calculate the principal Arg of self.
     #[inline]

src/libextra/std.rc

@@ -32,16 +32,10 @@ Rust extras are part of the standard Rust distribution.
 #[deny(non_camel_case_types)];
 #[deny(missing_doc)];
 
-// NOTE: remove these two attributes after the next snapshot
-#[no_core]; // for stage0
-#[allow(unrecognized_lint)]; // otherwise stage0 is seriously ugly
-
 #[no_std];
 
 extern mod core(name = "std", vers = "0.7-pre");
 
-#[cfg(stage0)]
-use core::{str, unstable};
 use core::str::{StrSlice, OwnedStr};
 
 pub use core::os;

src/libextra/time.rs

@@ -275,7 +275,7 @@ priv fn do_strptime(s: &str, format: &str) -> Result<Tm, ~str> {
         let mut i = 0u;
         let len = strs.len();
         while i < len {
-            match strs[i] { // can't use let due to stage0 bugs
+            match strs[i] { // can't use let due to let-pattern bugs
                 (ref needle, value) => {
                     if match_str(ss, pos, *needle) {
                         return Some((value, pos + needle.len()));

src/librustc/back/rpath.rs

@@ -174,19 +174,6 @@ pub fn get_absolute_rpath(lib: &Path) -> Path {
     os::make_absolute(lib).dir_path()
 }
 
-#[cfg(stage0)]
-pub fn get_install_prefix_rpath(target_triple: &str) -> Path {
-    let install_prefix = env!("CFG_PREFIX");
-
-    if install_prefix.is_empty() {
-        fail!("rustc compiled without CFG_PREFIX environment variable");
-    }
-
-    let tlib = filesearch::relative_target_lib_path(target_triple);
-    os::make_absolute(&Path(install_prefix).push_rel(&tlib))
-}
-
-#[cfg(not(stage0))]
 pub fn get_install_prefix_rpath(target_triple: &str) -> Path {
     let install_prefix = env!("CFG_PREFIX");
 

src/librustc/driver/driver.rs

@@ -521,25 +521,6 @@ pub fn build_target_config(sopts: @session::options,
     return target_cfg;
 }
 
-#[cfg(stage0)]
-pub fn host_triple() -> ~str {
-    // Get the host triple out of the build environment. This ensures that our
-    // idea of the host triple is the same as for the set of libraries we've
-    // actually built.  We can't just take LLVM's host triple because they
-    // normalize all ix86 architectures to i386.
-    //
-    // Instead of grabbing the host triple (for the current host), we grab (at
-    // compile time) the target triple that this rustc is built with and
-    // calling that (at runtime) the host triple.
-    let ht = env!("CFG_COMPILER_TRIPLE");
-    return if ht != ~"" {
-            ht
-        } else {
-            fail!("rustc built without CFG_COMPILER_TRIPLE")
-        };
-}
-
-#[cfg(not(stage0))]
 pub fn host_triple() -> ~str {
     // Get the host triple out of the build environment. This ensures that our
     // idea of the host triple is the same as for the set of libraries we've

src/librustc/middle/liveness.rs

@@ -749,11 +749,7 @@ impl Liveness {
             None => {
                 // Vanilla 'break' or 'loop', so use the enclosing
                 // loop scope
-                let len = { // FIXME(#5074) stage0
-                    let loop_scope = &mut *self.loop_scope;
-                    loop_scope.len()
-                };
-                if len == 0 {
+                if self.loop_scope.len() == 0 {
                     self.tcx.sess.span_bug(sp, "break outside loop");
                 } else {
                     // FIXME(#5275): this shouldn't have to be a method...

src/librustc/middle/trans/base.rs

@@ -1318,7 +1318,7 @@ pub fn cleanup_and_leave(bcx: block,
         match cur.kind {
             block_scope(inf) if !inf.empty_cleanups() => {
                 let (sub_cx, dest, inf_cleanups) = {
-                    let inf = &mut *inf; // FIXME(#5074) workaround stage0
+                    let inf = &mut *inf;
                     let mut skip = 0;
                     let mut dest = None;
                     {

src/librustc/middle/typeck/check/vtable.rs

@@ -248,16 +248,9 @@ fn lookup_vtable(vcx: &VtableContext,
                     // Nothing found. Continue.
                 }
                 Some(implementations) => {
-                    let len = { // FIXME(#5074): stage0 requires it
-                        let implementations: &mut ~[@Impl] = *implementations;
-                        implementations.len()
-                    };
-
                     // implementations is the list of all impls in scope for
                     // trait_ref. (Usually, there's just one.)
-                    for uint::range(0, len) |i| {
-                        let im = implementations[i];
-
+                    for implementations.iter().advance |im| {
                         // im is one specific impl of trait_ref.
 
                         // First, ensure we haven't processed this impl yet.

src/librustc/middle/typeck/coherence.rs

@@ -520,12 +520,8 @@ impl CoherenceChecker {
 
         match extension_methods.find(&trait_def_id) {
             Some(impls) => {
-                let len = { // FIXME(#5074) stage0 requires this
-                    let impls: &mut ~[@Impl] = *impls;
-                    impls.len()
-                };
-                for uint::range(0, len) |i| {
-                    f(impls[i]);
+                for impls.iter().advance |&im| {
+                    f(im);
                 }
             }
             None => { /* no impls? */ }

src/librustc/rustc.rc

@@ -28,16 +28,8 @@ extern mod core(name = "std");
 extern mod extra(name = "extra");
 extern mod syntax;
 
-// For deriving(Encodable) purposes...
-#[cfg(stage0)]
-extern mod std(name = "extra", vers = "0.7-pre");
-#[cfg(not(stage0))]
 extern mod std(name = "std", vers = "0.7-pre");
 
-// For bootstrapping purposes.
-#[cfg(stage0)]
-pub use core::unstable;
-
 use core::prelude::*;
 
 use driver::driver::{host_triple, optgroups, early_error};

src/libstd/cast.rs

@@ -14,21 +14,8 @@ use sys;
 use unstable::intrinsics;
 
 /// Casts the value at `src` to U. The two types must have the same length.
-#[cfg(stage0)]
-pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
-    let mut dest: U = intrinsics::uninit();
-    {
-        let dest_ptr: *mut u8 = transmute(&mut dest);
-        let src_ptr: *u8 = transmute(src);
-        intrinsics::memmove64(dest_ptr,
-                              src_ptr,
-                              sys::size_of::<U>() as u64);
-    }
-    dest
-}
-
 /// Casts the value at `src` to U. The two types must have the same length.
-#[cfg(target_word_size = "32", not(stage0))]
+#[cfg(target_word_size = "32")]
 #[inline]
 pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
     let mut dest: U = intrinsics::uninit();
@@ -39,7 +26,7 @@ pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
 }
 
 /// Casts the value at `src` to U. The two types must have the same length.
-#[cfg(target_word_size = "64", not(stage0))]
+#[cfg(target_word_size = "64")]
 #[inline]
 pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
     let mut dest: U = intrinsics::uninit();

src/libstd/core.rc

@@ -57,10 +57,6 @@ they contained the following prologue:
 #[license = "MIT/ASL2"];
 #[crate_type = "lib"];
 
-// NOTE: remove these two attributes after the next snapshot
-#[no_core]; // for stage0
-#[allow(unrecognized_lint)]; // otherwise stage0 is seriously ugly
-
 // Don't link to std. We are std.
 #[no_std];
 

src/libstd/io.rs

@@ -1654,9 +1654,7 @@ impl Writer for BytesWriter {
         vec::reserve(bytes, count);
 
         unsafe {
-            // Silly stage0 borrow check workaround...
-            let casted: &mut ~[u8] = cast::transmute_copy(&bytes);
-            vec::raw::set_len(casted, count);
+            vec::raw::set_len(bytes, count);
 
             let view = vec::mut_slice(*bytes, *self.pos, count);
             vec::bytes::copy_memory(view, v, v_len);

src/libstd/ptr.rs

@@ -75,21 +75,7 @@ pub fn is_not_null<T>(ptr: *const T) -> bool { !is_null(ptr) }
  * and destination may overlap.
  */
 #[inline]
-#[cfg(target_word_size = "32", stage0)]
-pub unsafe fn copy_memory<T>(dst: *mut T, src: *const T, count: uint) {
-    use unstable::intrinsics::memmove32;
-    let n = count * sys::size_of::<T>();
-    memmove32(dst as *mut u8, src as *u8, n as u32);
-}
-
-/**
- * Copies data from one location to another.
- *
- * Copies `count` elements (not bytes) from `src` to `dst`. The source
- * and destination may overlap.
- */
-#[inline]
-#[cfg(target_word_size = "32", not(stage0))]
+#[cfg(target_word_size = "32")]
 pub unsafe fn copy_memory<T>(dst: *mut T, src: *const T, count: uint) {
     use unstable::intrinsics::memmove32;
     memmove32(dst, src as *T, count as u32);
@@ -102,21 +88,7 @@ pub unsafe fn copy_memory<T>(dst: *mut T, src: *const T, count: uint) {
  * and destination may overlap.
  */
 #[inline]
-#[cfg(target_word_size = "64", stage0)]
-pub unsafe fn copy_memory<T>(dst: *mut T, src: *const T, count: uint) {
-    use unstable::intrinsics::memmove64;
-    let n = count * sys::size_of::<T>();
-    memmove64(dst as *mut u8, src as *u8, n as u64);
-}
-
-/**
- * Copies data from one location to another.
- *
- * Copies `count` elements (not bytes) from `src` to `dst`. The source
- * and destination may overlap.
- */
-#[inline]
-#[cfg(target_word_size = "64", not(stage0))]
+#[cfg(target_word_size = "64")]
 pub unsafe fn copy_memory<T>(dst: *mut T, src: *const T, count: uint) {
     use unstable::intrinsics::memmove64;
     memmove64(dst, src as *T, count as u64);
@@ -129,21 +101,7 @@ pub unsafe fn copy_memory<T>(dst: *mut T, src: *const T, count: uint) {
  * and destination may *not* overlap.
  */
 #[inline]
-#[cfg(target_word_size = "32", stage0)]
-pub unsafe fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: uint) {
-    use unstable::intrinsics::memmove32;
-    let n = count * sys::size_of::<T>();
-    memmove32(dst as *mut u8, src as *u8, n as u32);
-}
-
-/**
- * Copies data from one location to another.
- *
- * Copies `count` elements (not bytes) from `src` to `dst`. The source
- * and destination may *not* overlap.
- */
-#[inline]
-#[cfg(target_word_size = "32", not(stage0))]
+#[cfg(target_word_size = "32")]
 pub unsafe fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: uint) {
     use unstable::intrinsics::memcpy32;
     memcpy32(dst, src as *T, count as u32);
@@ -156,21 +114,7 @@ pub unsafe fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: u
  * and destination may *not* overlap.
  */
 #[inline]
-#[cfg(target_word_size = "64", stage0)]
-pub unsafe fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: uint) {
-    use unstable::intrinsics::memmove64;
-    let n = count * sys::size_of::<T>();
-    memmove64(dst as *mut u8, src as *u8, n as u64);
-}
-
-/**
- * Copies data from one location to another.
- *
- * Copies `count` elements (not bytes) from `src` to `dst`. The source
- * and destination may *not* overlap.
- */
-#[inline]
-#[cfg(target_word_size = "64", not(stage0))]
+#[cfg(target_word_size = "64")]
 pub unsafe fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: uint) {
     use unstable::intrinsics::memcpy64;
     memcpy64(dst, src as *T, count as u64);
@@ -181,7 +125,7 @@ pub unsafe fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: u
  * bytes of memory starting at `dst` to `c`.
  */
 #[inline]
-#[cfg(target_word_size = "32", not(stage0))]
+#[cfg(target_word_size = "32")]
 pub unsafe fn set_memory<T>(dst: *mut T, c: u8, count: uint) {
     use unstable::intrinsics::memset32;
     memset32(dst, c, count as u32);
@@ -192,7 +136,7 @@ pub unsafe fn set_memory<T>(dst: *mut T, c: u8, count: uint) {
  * bytes of memory starting at `dst` to `c`.
  */
 #[inline]
-#[cfg(target_word_size = "64", not(stage0))]
+#[cfg(target_word_size = "64")]
 pub unsafe fn set_memory<T>(dst: *mut T, c: u8, count: uint) {
     use unstable::intrinsics::memset64;
     memset64(dst, c, count as u64);
@@ -592,7 +536,6 @@ pub mod ptr_tests {
     }
 
     #[test]
-    #[cfg(not(stage0))]
     fn test_set_memory() {
         let mut xs = [0u8, ..20];
         let ptr = vec::raw::to_mut_ptr(xs);

src/libstd/unstable/intrinsics.rs

@@ -130,36 +130,23 @@ pub extern "rust-intrinsic" {
 
     /// Equivalent to the `llvm.memcpy.p0i8.0i8.i32` intrinsic, with a size of
     /// `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
-    #[cfg(not(stage0))]
     pub fn memcpy32<T>(dst: *mut T, src: *T, count: u32);
     /// Equivalent to the `llvm.memcpy.p0i8.0i8.i64` intrinsic, with a size of
     /// `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
-    #[cfg(not(stage0))]
     pub fn memcpy64<T>(dst: *mut T, src: *T, count: u64);
 
-    /// Equivalent to the `llvm.memmove.p0i8.0i8.i32` intrinsic.
-    #[cfg(stage0)]
-    pub fn memmove32(dst: *mut u8, src: *u8, size: u32);
-    /// Equivalent to the `llvm.memmove.p0i8.0i8.i64` intrinsic.
-    #[cfg(stage0)]
-    pub fn memmove64(dst: *mut u8, src: *u8, size: u64);
-
     /// Equivalent to the `llvm.memmove.p0i8.0i8.i32` intrinsic, with a size of
     /// `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
-    #[cfg(not(stage0))]
     pub fn memmove32<T>(dst: *mut T, src: *T, count: u32);
     /// Equivalent to the `llvm.memmove.p0i8.0i8.i64` intrinsic, with a size of
     /// `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
-    #[cfg(not(stage0))]
     pub fn memmove64<T>(dst: *mut T, src: *T, count: u64);
 
     /// Equivalent to the `llvm.memset.p0i8.i32` intrinsic, with a size of
     /// `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
-    #[cfg(not(stage0))]
     pub fn memset32<T>(dst: *mut T, val: u8, count: u32);
     /// Equivalent to the `llvm.memset.p0i8.i64` intrinsic, with a size of
     /// `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
-    #[cfg(not(stage0))]
     pub fn memset64<T>(dst: *mut T, val: u8, count: u64);
 
     pub fn sqrtf32(x: f32) -> f32;