auto merge of #21288 : brson/rust/snaps, r=alexcrichton

This fixes the issues mentioned in https://github.com/rust-lang/rust/pull/21236, as well as the one https://github.com/rust-lang/rust/issues/21230 where `CFG_BOOTSTRAP_KEY` was being set to simply 'N'. It changes the build such that `RUSTC_BOOTSTRAP_KEY` is only exported on -beta and -stable, so that the behavior of the -dev, -nightly, and snapshot compilers is the same everywhere.

Haven't run it completely through 'make check' yet, but the I have verified that the aforementioned issues are fixed.

r? @alexcrichton cc @eddyb

73 files changed, 215 insertions, 476 deletions

diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs
index 802fb05796d..f3514c6e7bc 100644
--- a/src/compiletest/compiletest.rs
+++ b/src/compiletest/compiletest.rs
@@ -13,6 +13,7 @@
 #![feature(slicing_syntax, unboxed_closures)]
 #![feature(box_syntax)]
 #![feature(int_uint)]
+#![allow(unstable)]
 
 #![deny(warnings)]
 
diff --git a/src/driver/driver.rs b/src/driver/driver.rs
index 5c29cb4ec72..5f086280a65 100644
--- a/src/driver/driver.rs
+++ b/src/driver/driver.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unstable)]
+
 #[cfg(rustdoc)]
 extern crate "rustdoc" as this;
 
diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs
index 458eb3dce57..8ad0c152dc8 100644
--- a/src/liballoc/boxed.rs
+++ b/src/liballoc/boxed.rs
@@ -117,14 +117,6 @@ impl<T: ?Sized + Ord> Ord for Box<T> {
 #[stable]
 impl<T: ?Sized + Eq> Eq for Box<T> {}
 
-#[cfg(stage0)]
-impl<S: hash::Writer, T: ?Sized + Hash<S>> Hash<S> for Box<T> {
-    #[inline]
-    fn hash(&self, state: &mut S) {
-        (**self).hash(state);
-    }
-}
-#[cfg(not(stage0))]
 impl<S: hash::Hasher, T: ?Sized + Hash<S>> Hash<S> for Box<T> {
     #[inline]
     fn hash(&self, state: &mut S) {
diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs
index 6c853306035..811e32e747d 100644
--- a/src/liballoc/lib.rs
+++ b/src/liballoc/lib.rs
@@ -66,6 +66,7 @@
 
 #![no_std]
 #![allow(unknown_features)]
+#![allow(unstable)]
 #![feature(lang_items, unsafe_destructor)]
 #![feature(box_syntax)]
 #![feature(optin_builtin_traits)]
diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs
index 0e18cdda8dd..7191a7af346 100644
--- a/src/liballoc/rc.rs
+++ b/src/liballoc/rc.rs
@@ -686,14 +686,6 @@ impl<T: Ord> Ord for Rc<T> {
 }
 
 // FIXME (#18248) Make `T` `Sized?`
-#[cfg(stage0)]
-impl<S: hash::Writer, T: Hash<S>> Hash<S> for Rc<T> {
-    #[inline]
-    fn hash(&self, state: &mut S) {
-        (**self).hash(state);
-    }
-}
-#[cfg(not(stage0))]
 impl<S: hash::Hasher, T: Hash<S>> Hash<S> for Rc<T> {
     #[inline]
     fn hash(&self, state: &mut S) {
diff --git a/src/libarena/lib.rs b/src/libarena/lib.rs
index e3d075c0f39..7458cc60c15 100644
--- a/src/libarena/lib.rs
+++ b/src/libarena/lib.rs
@@ -34,6 +34,7 @@
 #![feature(box_syntax)]
 #![allow(unknown_features)] #![feature(int_uint)]
 #![allow(missing_docs)]
+#![allow(unstable)]
 
 extern crate alloc;
 
diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs
index 6c3767b0111..3ac6b2775bf 100644
--- a/src/libcollections/btree/map.rs
+++ b/src/libcollections/btree/map.rs
@@ -24,8 +24,6 @@ use core::cmp::Ordering;
 use core::default::Default;
 use core::fmt::Show;
 use core::hash::{Hash, Hasher};
-#[cfg(stage0)]
-use core::hash::Writer;
 use core::iter::{Map, FromIterator};
 use core::ops::{Index, IndexMut};
 use core::{iter, fmt, mem};
@@ -822,16 +820,6 @@ impl<K: Ord, V> Extend<(K, V)> for BTreeMap<K, V> {
 }
 
 #[stable]
-#[cfg(stage0)]
-impl<S: Writer, K: Hash<S>, V: Hash<S>> Hash<S> for BTreeMap<K, V> {
-    fn hash(&self, state: &mut S) {
-        for elt in self.iter() {
-            elt.hash(state);
-        }
-    }
-}
-#[stable]
-#[cfg(not(stage0))]
 impl<S: Hasher, K: Hash<S>, V: Hash<S>> Hash<S> for BTreeMap<K, V> {
     fn hash(&self, state: &mut S) {
         for elt in self.iter() {
diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs
index e222373ff59..797042c3216 100644
--- a/src/libcollections/lib.rs
+++ b/src/libcollections/lib.rs
@@ -28,6 +28,7 @@
 #![feature(unboxed_closures)]
 #![feature(old_impl_check)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 #![no_std]
 
 #[macro_use]
diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
index c845d86ca0f..5d35d8a8679 100644
--- a/src/libcollections/string.rs
+++ b/src/libcollections/string.rs
@@ -830,15 +830,6 @@ impl fmt::Show for String {
 }
 
 #[unstable = "waiting on Hash stabilization"]
-#[cfg(stage0)]
-impl<H: hash::Writer> hash::Hash<H> for String {
-    #[inline]
-    fn hash(&self, hasher: &mut H) {
-        (**self).hash(hasher)
-    }
-}
-#[unstable = "waiting on Hash stabilization"]
-#[cfg(not(stage0))]
 impl<H: hash::Writer + hash::Hasher> hash::Hash<H> for String {
     #[inline]
     fn hash(&self, hasher: &mut H) {
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index f5d7a34536a..689d96b4b29 100644
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -1222,14 +1222,6 @@ impl<T:Clone> Clone for Vec<T> {
     }
 }
 
-#[cfg(stage0)]
-impl<S: hash::Writer, T: Hash<S>> Hash<S> for Vec<T> {
-    #[inline]
-    fn hash(&self, state: &mut S) {
-        self.as_slice().hash(state);
-    }
-}
-#[cfg(not(stage0))]
 impl<S: hash::Writer + hash::Hasher, T: Hash<S>> Hash<S> for Vec<T> {
     #[inline]
     fn hash(&self, state: &mut S) {
diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 20ac3e28c97..535722f93bf 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -180,25 +180,6 @@ impl<'a> Arguments<'a> {
     /// unsafety, but will ignore invalid .
     #[doc(hidden)] #[inline]
     #[unstable = "implementation detail of the `format_args!` macro"]
-    #[cfg(stage0)] // SNAP 9e4e524
-    pub fn with_placeholders(pieces: &'a [&'a str],
-                             fmt: &'a [rt::Argument<'a>],
-                             args: &'a [Argument<'a>]) -> Arguments<'a> {
-        Arguments {
-            pieces: pieces,
-            fmt: Some(fmt),
-            args: args
-        }
-    }
-    /// This function is used to specify nonstandard formatting parameters.
-    /// The `pieces` array must be at least as long as `fmt` to construct
-    /// a valid Arguments structure. Also, any `Count` within `fmt` that is
-    /// `CountIsParam` or `CountIsNextParam` has to point to an argument
-    /// created with `argumentuint`. However, failing to do so doesn't cause
-    /// unsafety, but will ignore invalid .
-    #[doc(hidden)] #[inline]
-    #[unstable = "implementation detail of the `format_args!` macro"]
-    #[cfg(not(stage0))]
     pub fn with_placeholders(pieces: &'a [&'a str],
                              fmt: &'a [rt::Argument],
                              args: &'a [Argument<'a>]) -> Arguments<'a> {
@@ -226,10 +207,6 @@ pub struct Arguments<'a> {
     pieces: &'a [&'a str],
 
     // Placeholder specs, or `None` if all specs are default (as in "{}{}").
-    // SNAP 9e4e524
-    #[cfg(stage0)]
-    fmt: Option<&'a [rt::Argument<'a>]>,
-    #[cfg(not(stage0))]
     fmt: Option<&'a [rt::Argument]>,
 
     // Dynamic arguments for interpolation, to be interleaved with string
diff --git a/src/libcore/fmt/rt.rs b/src/libcore/fmt/rt.rs
index 2abf921eaf2..bea32219155 100644
--- a/src/libcore/fmt/rt.rs
+++ b/src/libcore/fmt/rt.rs
@@ -21,21 +21,12 @@ pub use self::Count::*;
 pub use self::Position::*;
 pub use self::Flag::*;
 
-// SNAP 9e4e524
 #[doc(hidden)]
 #[derive(Copy)]
-#[cfg(not(stage0))]
 pub struct Argument {
     pub position: Position,
     pub format: FormatSpec,
 }
-#[doc(hidden)]
-#[derive(Copy)]
-#[cfg(stage0)]
-pub struct Argument<'a> {
-    pub position: Position,
-    pub format: FormatSpec,
-}
 
 #[doc(hidden)]
 #[derive(Copy)]
diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs
index a82ea009e13..37e4a105a30 100644
--- a/src/libcore/hash/mod.rs
+++ b/src/libcore/hash/mod.rs
@@ -58,7 +58,13 @@
 
 #![unstable = "module was recently redesigned"]
 
+use prelude::*;
+
+use borrow::{Cow, ToOwned};
 use default::Default;
+use intrinsics::TypeId;
+use mem;
+use num::Int;
 
 pub use self::sip::SipHasher;
 
@@ -70,19 +76,6 @@ mod sip;
 /// to compute the hash. Specific implementations of this trait may specialize
 /// for particular instances of `H` in order to be able to optimize the hashing
 /// behavior.
-#[cfg(stage0)]
-pub trait Hash<H> {
-    /// Feeds this value into the state given, updating the hasher as necessary.
-    fn hash(&self, state: &mut H);
-}
-
-/// A hashable type.
-///
-/// The `H` type parameter is an abstract hash state that is used by the `Hash`
-/// to compute the hash. Specific implementations of this trait may specialize
-/// for particular instances of `H` in order to be able to optimize the hashing
-/// behavior.
-#[cfg(not(stage0))]
 pub trait Hash<H: Hasher> {
     /// Feeds this value into the state given, updating the hasher as necessary.
     fn hash(&self, state: &mut H);
@@ -121,314 +114,147 @@ pub fn hash<T: Hash<H>, H: Hasher + Default>(value: &T) -> H::Output {
 
 //////////////////////////////////////////////////////////////////////////////
 
-#[cfg(stage0)]
-mod impls {
-    use prelude::*;
-
-    use borrow::{Cow, ToOwned};
-    use intrinsics::TypeId;
-    use mem;
-    use super::{Hash, Writer};
-    use num::Int;
-
-    macro_rules! impl_hash {
-        ($ty:ident, $uty:ident) => {
-            impl<S: Writer> Hash<S> for $ty {
-                #[inline]
-                fn hash(&self, state: &mut S) {
-                    let a: [u8; ::$ty::BYTES] = unsafe {
-                        mem::transmute((*self as $uty).to_le() as $ty)
-                    };
-                    state.write(a.as_slice())
-                }
-            }
-        }
-    }
-
-    impl_hash! { u8, u8 }
-    impl_hash! { u16, u16 }
-    impl_hash! { u32, u32 }
-    impl_hash! { u64, u64 }
-    impl_hash! { uint, uint }
-    impl_hash! { i8, u8 }
-    impl_hash! { i16, u16 }
-    impl_hash! { i32, u32 }
-    impl_hash! { i64, u64 }
-    impl_hash! { int, uint }
-
-    impl<S: Writer> Hash<S> for bool {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            (*self as u8).hash(state);
-        }
-    }
-
-    impl<S: Writer> Hash<S> for char {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            (*self as u32).hash(state);
-        }
-    }
-
-    impl<S: Writer> Hash<S> for str {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            state.write(self.as_bytes());
-            0xffu8.hash(state)
-        }
-    }
-
-    macro_rules! impl_hash_tuple {
-        () => (
-            impl<S> Hash<S> for () {
-                #[inline]
-                fn hash(&self, _state: &mut S) {}
-            }
-        );
-
-        ( $($name:ident)+) => (
-            impl<S, $($name: Hash<S>),*> Hash<S> for ($($name,)*) {
-                #[inline]
-                #[allow(non_snake_case)]
-                fn hash(&self, state: &mut S) {
-                    match *self {
-                        ($(ref $name,)*) => {
-                            $(
-                                $name.hash(state);
-                            )*
-                        }
-                    }
-                }
-            }
-        );
-    }
-
-    impl_hash_tuple! {}
-    impl_hash_tuple! { A }
-    impl_hash_tuple! { A B }
-    impl_hash_tuple! { A B C }
-    impl_hash_tuple! { A B C D }
-    impl_hash_tuple! { A B C D E }
-    impl_hash_tuple! { A B C D E F }
-    impl_hash_tuple! { A B C D E F G }
-    impl_hash_tuple! { A B C D E F G H }
-    impl_hash_tuple! { A B C D E F G H I }
-    impl_hash_tuple! { A B C D E F G H I J }
-    impl_hash_tuple! { A B C D E F G H I J K }
-    impl_hash_tuple! { A B C D E F G H I J K L }
-
-    impl<S: Writer, T: Hash<S>> Hash<S> for [T] {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            self.len().hash(state);
-            for elt in self.iter() {
-                elt.hash(state);
+macro_rules! impl_hash {
+    ($ty:ident, $uty:ident) => {
+        impl<S: Writer + Hasher> Hash<S> for $ty {
+            #[inline]
+            fn hash(&self, state: &mut S) {
+                let a: [u8; ::$ty::BYTES] = unsafe {
+                    mem::transmute((*self as $uty).to_le() as $ty)
+                };
+                state.write(a.as_slice())
             }
         }
     }
-
-
-    impl<'a, S, T: ?Sized + Hash<S>> Hash<S> for &'a T {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            (**self).hash(state);
-        }
-    }
-
-    impl<'a, S, T: ?Sized + Hash<S>> Hash<S> for &'a mut T {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            (**self).hash(state);
-        }
-    }
-
-    impl<S: Writer, T> Hash<S> for *const T {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            // NB: raw-pointer Hash does _not_ dereference
-            // to the target; it just gives you the pointer-bytes.
-            (*self as uint).hash(state);
-        }
-    }
-
-    impl<S: Writer, T> Hash<S> for *mut T {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            // NB: raw-pointer Hash does _not_ dereference
-            // to the target; it just gives you the pointer-bytes.
-            (*self as uint).hash(state);
-        }
-    }
-
-    impl<S: Writer> Hash<S> for TypeId {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            self.hash().hash(state)
-        }
-    }
-
-    impl<'a, T, B: ?Sized, S> Hash<S> for Cow<'a, T, B>
-        where B: Hash<S> + ToOwned<T>
-    {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            Hash::hash(&**self, state)
-        }
-    }
 }
 
-#[cfg(not(stage0))]
-mod impls {
-    use prelude::*;
-
-    use borrow::{Cow, ToOwned};
-    use intrinsics::TypeId;
-    use mem;
-    use super::{Hash, Writer, Hasher};
-    use num::Int;
-
-    macro_rules! impl_hash {
-        ($ty:ident, $uty:ident) => {
-            impl<S: Writer + Hasher> Hash<S> for $ty {
-                #[inline]
-                fn hash(&self, state: &mut S) {
-                    let a: [u8; ::$ty::BYTES] = unsafe {
-                        mem::transmute((*self as $uty).to_le() as $ty)
-                    };
-                    state.write(a.as_slice())
-                }
-            }
-        }
+impl_hash! { u8, u8 }
+impl_hash! { u16, u16 }
+impl_hash! { u32, u32 }
+impl_hash! { u64, u64 }
+impl_hash! { uint, uint }
+impl_hash! { i8, u8 }
+impl_hash! { i16, u16 }
+impl_hash! { i32, u32 }
+impl_hash! { i64, u64 }
+impl_hash! { int, uint }
+
+impl<S: Writer + Hasher> Hash<S> for bool {
+    #[inline]
+    fn hash(&self, state: &mut S) {
+        (*self as u8).hash(state);
     }
+}
 
-    impl_hash! { u8, u8 }
-    impl_hash! { u16, u16 }
-    impl_hash! { u32, u32 }
-    impl_hash! { u64, u64 }
-    impl_hash! { uint, uint }
-    impl_hash! { i8, u8 }
-    impl_hash! { i16, u16 }
-    impl_hash! { i32, u32 }
-    impl_hash! { i64, u64 }
-    impl_hash! { int, uint }
-
-    impl<S: Writer + Hasher> Hash<S> for bool {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            (*self as u8).hash(state);
-        }
+impl<S: Writer + Hasher> Hash<S> for char {
+    #[inline]
+    fn hash(&self, state: &mut S) {
+        (*self as u32).hash(state);
     }
+}
 
-    impl<S: Writer + Hasher> Hash<S> for char {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            (*self as u32).hash(state);
-        }
+impl<S: Writer + Hasher> Hash<S> for str {
+    #[inline]
+    fn hash(&self, state: &mut S) {
+        state.write(self.as_bytes());
+        0xffu8.hash(state)
     }
+}
 
-    impl<S: Writer + Hasher> Hash<S> for str {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            state.write(self.as_bytes());
-            0xffu8.hash(state)
+macro_rules! impl_hash_tuple {
+    () => (
+        impl<S: Hasher> Hash<S> for () {
+            #[inline]
+            fn hash(&self, _state: &mut S) {}
         }
-    }
-
-    macro_rules! impl_hash_tuple {
-        () => (
-            impl<S: Hasher> Hash<S> for () {
-                #[inline]
-                fn hash(&self, _state: &mut S) {}
-            }
-        );
-
-        ( $($name:ident)+) => (
-            impl<S: Hasher, $($name: Hash<S>),*> Hash<S> for ($($name,)*) {
-                #[inline]
-                #[allow(non_snake_case)]
-                fn hash(&self, state: &mut S) {
-                    match *self {
-                        ($(ref $name,)*) => {
-                            $(
-                                $name.hash(state);
-                            )*
-                        }
+    );
+
+    ( $($name:ident)+) => (
+        impl<S: Hasher, $($name: Hash<S>),*> Hash<S> for ($($name,)*) {
+            #[inline]
+            #[allow(non_snake_case)]
+            fn hash(&self, state: &mut S) {
+                match *self {
+                    ($(ref $name,)*) => {
+                        $(
+                            $name.hash(state);
+                        )*
                     }
                 }
             }
-        );
-    }
-
-    impl_hash_tuple! {}
-    impl_hash_tuple! { A }
-    impl_hash_tuple! { A B }
-    impl_hash_tuple! { A B C }
-    impl_hash_tuple! { A B C D }
-    impl_hash_tuple! { A B C D E }
-    impl_hash_tuple! { A B C D E F }
-    impl_hash_tuple! { A B C D E F G }
-    impl_hash_tuple! { A B C D E F G H }
-    impl_hash_tuple! { A B C D E F G H I }
-    impl_hash_tuple! { A B C D E F G H I J }
-    impl_hash_tuple! { A B C D E F G H I J K }
-    impl_hash_tuple! { A B C D E F G H I J K L }
+        }
+    );
+}
 
-    impl<S: Writer + Hasher, T: Hash<S>> Hash<S> for [T] {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            self.len().hash(state);
-            for elt in self.iter() {
-                elt.hash(state);
-            }
+impl_hash_tuple! {}
+impl_hash_tuple! { A }
+impl_hash_tuple! { A B }
+impl_hash_tuple! { A B C }
+impl_hash_tuple! { A B C D }
+impl_hash_tuple! { A B C D E }
+impl_hash_tuple! { A B C D E F }
+impl_hash_tuple! { A B C D E F G }
+impl_hash_tuple! { A B C D E F G H }
+impl_hash_tuple! { A B C D E F G H I }
+impl_hash_tuple! { A B C D E F G H I J }
+impl_hash_tuple! { A B C D E F G H I J K }
+impl_hash_tuple! { A B C D E F G H I J K L }
+
+impl<S: Writer + Hasher, T: Hash<S>> Hash<S> for [T] {
+    #[inline]
+    fn hash(&self, state: &mut S) {
+        self.len().hash(state);
+        for elt in self.iter() {
+            elt.hash(state);
         }
     }
+}
 
 
-    impl<'a, S: Hasher, T: ?Sized + Hash<S>> Hash<S> for &'a T {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            (**self).hash(state);
-        }
+impl<'a, S: Hasher, T: ?Sized + Hash<S>> Hash<S> for &'a T {
+    #[inline]
+    fn hash(&self, state: &mut S) {
+        (**self).hash(state);
     }
+}
 
-    impl<'a, S: Hasher, T: ?Sized + Hash<S>> Hash<S> for &'a mut T {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            (**self).hash(state);
-        }
+impl<'a, S: Hasher, T: ?Sized + Hash<S>> Hash<S> for &'a mut T {
+    #[inline]
+    fn hash(&self, state: &mut S) {
+        (**self).hash(state);
     }
+}
 
-    impl<S: Writer + Hasher, T> Hash<S> for *const T {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            // NB: raw-pointer Hash does _not_ dereference
-            // to the target; it just gives you the pointer-bytes.
-            (*self as uint).hash(state);
-        }
+impl<S: Writer + Hasher, T> Hash<S> for *const T {
+    #[inline]
+    fn hash(&self, state: &mut S) {
+        // NB: raw-pointer Hash does _not_ dereference
+        // to the target; it just gives you the pointer-bytes.
+        (*self as uint).hash(state);
     }
+}
 
-    impl<S: Writer + Hasher, T> Hash<S> for *mut T {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            // NB: raw-pointer Hash does _not_ dereference
-            // to the target; it just gives you the pointer-bytes.
-            (*self as uint).hash(state);
-        }
+impl<S: Writer + Hasher, T> Hash<S> for *mut T {
+    #[inline]
+    fn hash(&self, state: &mut S) {
+        // NB: raw-pointer Hash does _not_ dereference
+        // to the target; it just gives you the pointer-bytes.
+        (*self as uint).hash(state);
     }
+}
 
-    impl<S: Writer + Hasher> Hash<S> for TypeId {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            self.hash().hash(state)
-        }
+impl<S: Writer + Hasher> Hash<S> for TypeId {
+    #[inline]
+    fn hash(&self, state: &mut S) {
+        self.hash().hash(state)
     }
+}
 
-    impl<'a, T, B: ?Sized, S: Hasher> Hash<S> for Cow<'a, T, B>
-        where B: Hash<S> + ToOwned<T>
-    {
-        #[inline]
-        fn hash(&self, state: &mut S) {
-            Hash::hash(&**self, state)
-        }
+impl<'a, T, B: ?Sized, S: Hasher> Hash<S> for Cow<'a, T, B>
+    where B: Hash<S> + ToOwned<T>
+{
+    #[inline]
+    fn hash(&self, state: &mut S) {
+        Hash::hash(&**self, state)
     }
 }
diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs
index 978e8a19737..40db0def626 100644
--- a/src/libcore/intrinsics.rs
+++ b/src/libcore/intrinsics.rs
@@ -42,7 +42,6 @@
 #![unstable]
 #![allow(missing_docs)]
 
-#[cfg(not(stage0))]
 use marker::Sized;
 
 pub type GlueFn = extern "Rust" fn(*const i8);
@@ -207,12 +206,8 @@ extern "rust-intrinsic" {
     /// Gets an identifier which is globally unique to the specified type. This
     /// function will return the same value for a type regardless of whichever
     /// crate it is invoked in.
-    #[cfg(not(stage0))]
     pub fn type_id<T: ?Sized + 'static>() -> TypeId;
 
-    #[cfg(stage0)]
-    pub fn type_id<T: 'static>() -> TypeId;
-
     /// Create a value initialized to zero.
     ///
     /// `init` is unsafe because it returns a zeroed-out datum,
@@ -562,15 +557,9 @@ pub struct TypeId {
 
 impl TypeId {
     /// Returns the `TypeId` of the type this generic function has been instantiated with
-    #[cfg(not(stage0))]
     pub fn of<T: ?Sized + 'static>() -> TypeId {
         unsafe { type_id::<T>() }
     }
 
-    #[cfg(stage0)]
-    pub fn of<T: 'static>() -> TypeId {
-        unsafe { type_id::<T>() }
-    }
-
     pub fn hash(&self) -> u64 { self.t }
 }
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index 5ed77852ad0..0005db36c27 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -2753,9 +2753,9 @@ macro_rules! step_impl_no_between {
 }
 
 step_impl!(uint u8 u16 u32 int i8 i16 i32);
-#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
+#[cfg(target_pointer_width = "64")]
 step_impl!(u64 i64);
-#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
+#[cfg(target_pointer_width = "32")]
 step_impl_no_between!(u64 i64);
 
 
diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs
index 78e8a2a9e91..0b150d1ecf9 100644
--- a/src/libcore/lib.rs
+++ b/src/libcore/lib.rs
@@ -58,7 +58,6 @@
 
 #![no_std]
 #![allow(unknown_features, raw_pointer_derive)]
-#![cfg_attr(stage0, allow(unused_attributes))]
 #![allow(unknown_features)] #![feature(intrinsics, lang_items)]
 #![feature(simd, unsafe_destructor, slicing_syntax)]
 #![feature(unboxed_closures)]
diff --git a/src/libcore/num/int.rs b/src/libcore/num/int.rs
index 065763a0d8e..83011db35ce 100644
--- a/src/libcore/num/int.rs
+++ b/src/libcore/num/int.rs
@@ -16,8 +16,5 @@
 
 #![deprecated = "replaced by isize"]
 
-#[cfg(stage0)] #[cfg(target_word_size = "32")] int_module! { int, 32 }
-#[cfg(stage0)] #[cfg(target_word_size = "64")] int_module! { int, 64 }
-
-#[cfg(not(stage0))] #[cfg(target_pointer_width = "32")] int_module! { int, 32 }
-#[cfg(not(stage0))] #[cfg(target_pointer_width = "64")] int_module! { int, 64 }
+#[cfg(target_pointer_width = "32")] int_module! { int, 32 }
+#[cfg(target_pointer_width = "64")] int_module! { int, 64 }
diff --git a/src/libcore/num/isize.rs b/src/libcore/num/isize.rs
index c1cf3c62131..e4711c92c59 100644
--- a/src/libcore/num/isize.rs
+++ b/src/libcore/num/isize.rs
@@ -17,9 +17,7 @@
 #![stable]
 #![doc(primitive = "isize")]
 
-#[cfg(any(all(stage0, target_word_size = "32"),
-          all(not(stage0), target_pointer_width = "32")))]
+#[cfg(target_pointer_width = "32")]
 int_module! { isize, 32 }
-#[cfg(any(all(stage0, target_word_size = "64"),
-          all(not(stage0), target_pointer_width = "64")))]
+#[cfg(target_pointer_width = "64")]
 int_module! { isize, 64 }
diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
index 57415f4331d..599a5515e3b 100644
--- a/src/libcore/num/mod.rs
+++ b/src/libcore/num/mod.rs
@@ -496,7 +496,7 @@ uint_impl! { u64 = u64, 64,
     intrinsics::u64_sub_with_overflow,
     intrinsics::u64_mul_with_overflow }
 
-#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
+#[cfg(target_pointer_width = "32")]
 uint_impl! { uint = u32, 32,
     intrinsics::ctpop32,
     intrinsics::ctlz32,
@@ -506,7 +506,7 @@ uint_impl! { uint = u32, 32,
     intrinsics::u32_sub_with_overflow,
     intrinsics::u32_mul_with_overflow }
 
-#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
+#[cfg(target_pointer_width = "64")]
 uint_impl! { uint = u64, 64,
     intrinsics::ctpop64,
     intrinsics::ctlz64,
@@ -601,13 +601,13 @@ int_impl! { i64 = i64, u64, 64,
     intrinsics::i64_sub_with_overflow,
     intrinsics::i64_mul_with_overflow }
 
-#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
+#[cfg(target_pointer_width = "32")]
 int_impl! { int = i32, u32, 32,
     intrinsics::i32_add_with_overflow,
     intrinsics::i32_sub_with_overflow,
     intrinsics::i32_mul_with_overflow }
 
-#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
+#[cfg(target_pointer_width = "64")]
 int_impl! { int = i64, u64, 64,
     intrinsics::i64_add_with_overflow,
     intrinsics::i64_sub_with_overflow,
diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs
index 7d41c3fc5a5..db7177e26fa 100644
--- a/src/libcore/ops.rs
+++ b/src/libcore/ops.rs
@@ -719,8 +719,6 @@ macro_rules! shl_impl {
     )
 }
 
-// SNAP 9e4e524e0
-#[cfg(not(stage0))]
 macro_rules! shl_impl_all {
     ($($t:ty)*) => ($(
         shl_impl! { $t, u8 }
@@ -737,13 +735,6 @@ macro_rules! shl_impl_all {
     )*)
 }
 
-#[cfg(stage0)]
-macro_rules! shl_impl_all {
-    ($($t:ty)*) => ($(
-        shl_impl! { $t, usize }
-    )*)
-}
-
 shl_impl_all! { u8 u16 u32 u64 usize i8 i16 i32 i64 isize }
 
 /// The `Shr` trait is used to specify the functionality of `>>`.
@@ -798,8 +789,6 @@ macro_rules! shr_impl {
     )
 }
 
-// SNAP 9e4e524e0
-#[cfg(not(stage0))]
 macro_rules! shr_impl_all {
     ($($t:ty)*) => ($(
         shr_impl! { $t, u8 }
@@ -816,13 +805,6 @@ macro_rules! shr_impl_all {
     )*)
 }
 
-#[cfg(stage0)]
-macro_rules! shr_impl_all {
-    ($($t:ty)*) => ($(
-        shr_impl! { $t, usize }
-    )*)
-}
-
 shr_impl_all! { u8 u16 u32 u64 usize i8 i16 i32 i64 isize }
 
 /// The `Index` trait is used to specify the functionality of indexing operations
diff --git a/src/libcoretest/lib.rs b/src/libcoretest/lib.rs
index 0d371dbe153..0c7b72612fa 100644
--- a/src/libcoretest/lib.rs
+++ b/src/libcoretest/lib.rs
@@ -12,6 +12,7 @@
 #![feature(unboxed_closures)]
 #![feature(box_syntax)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 
 extern crate core;
 extern crate test;
diff --git a/src/libflate/lib.rs b/src/libflate/lib.rs
index fb6c98515f7..f0a2ab3d1d6 100644
--- a/src/libflate/lib.rs
+++ b/src/libflate/lib.rs
@@ -18,6 +18,7 @@
 #![unstable]
 #![staged_api]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs
index 85944ccc551..0ff15327441 100644
--- a/src/libfmt_macros/lib.rs
+++ b/src/libfmt_macros/lib.rs
@@ -26,6 +26,7 @@
 
 #![feature(slicing_syntax)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 
 pub use self::Piece::*;
 pub use self::Position::*;
diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs
index 470ef6e7e57..c2114d4c6df 100644
--- a/src/libgetopts/lib.rs
+++ b/src/libgetopts/lib.rs
@@ -88,6 +88,7 @@
        html_playground_url = "http://play.rust-lang.org/")]
 #![feature(slicing_syntax)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 #![deny(missing_docs)]
 
 #[cfg(test)] #[macro_use] extern crate log;
diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs
index b48fe2e4278..2d7d88f0f35 100644
--- a/src/libgraphviz/lib.rs
+++ b/src/libgraphviz/lib.rs
@@ -274,6 +274,7 @@
        html_root_url = "http://doc.rust-lang.org/nightly/")]
 #![feature(slicing_syntax)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 
 use self::LabelText::*;
 
diff --git a/src/liblibc/lib.rs b/src/liblibc/lib.rs
index 7fb609b4c94..0ad18e25329 100644
--- a/src/liblibc/lib.rs
+++ b/src/liblibc/lib.rs
@@ -13,6 +13,7 @@
 #![cfg_attr(not(feature = "cargo-build"), unstable)]
 #![cfg_attr(not(feature = "cargo-build"), staged_api)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 #![no_std]
 #![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",
diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs
index a166dc369cb..dbd88434127 100644
--- a/src/liblog/lib.rs
+++ b/src/liblog/lib.rs
@@ -169,6 +169,7 @@
 #![feature(slicing_syntax)]
 #![feature(box_syntax)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 #![deny(missing_docs)]
 
 extern crate regex;
diff --git a/src/librand/lib.rs b/src/librand/lib.rs
index 8430ee81c32..853eb41d011 100644
--- a/src/librand/lib.rs
+++ b/src/librand/lib.rs
@@ -23,6 +23,7 @@
        html_root_url = "http://doc.rust-lang.org/nightly/",
        html_playground_url = "http://play.rust-lang.org/")]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 #![no_std]
 #![unstable]
 #![staged_api]
diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs
index 6a7062a419e..f28600e5e69 100644
--- a/src/librbml/lib.rs
+++ b/src/librbml/lib.rs
@@ -27,6 +27,7 @@
 #![allow(unknown_features)]
 #![feature(slicing_syntax)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 
 extern crate serialize;
 #[macro_use] extern crate log;
diff --git a/src/libregex/lib.rs b/src/libregex/lib.rs
index 45f42336ceb..002b74cf1ef 100644
--- a/src/libregex/lib.rs
+++ b/src/libregex/lib.rs
@@ -24,6 +24,7 @@
        html_playground_url = "http://play.rust-lang.org/")]
 
 #![allow(unknown_features)]
+#![allow(unstable)]
 #![feature(slicing_syntax)]
 #![feature(box_syntax)]
 #![allow(unknown_features)] #![feature(int_uint)]
diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs
index a283fdf36a9..62869064551 100644
--- a/src/librustc/lib.rs
+++ b/src/librustc/lib.rs
@@ -29,6 +29,7 @@
 #![feature(box_syntax)]
 #![allow(unknown_features)] #![feature(int_uint)]
 #![feature(rustc_diagnostic_macros)]
+#![allow(unstable)]
 
 extern crate arena;
 extern crate flate;
diff --git a/src/librustc/metadata/filesearch.rs b/src/librustc/metadata/filesearch.rs
index 55a23aa516e..ddee1f79d6a 100644
--- a/src/librustc/metadata/filesearch.rs
+++ b/src/librustc/metadata/filesearch.rs
@@ -274,12 +274,12 @@ fn find_libdir(sysroot: &Path) -> String {
         }
     }
 
-    #[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
+    #[cfg(target_pointer_width = "64")]
     fn primary_libdir_name() -> String {
         "lib64".to_string()
     }
 
-    #[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
+    #[cfg(target_pointer_width = "32")]
     fn primary_libdir_name() -> String {
         "lib32".to_string()
     }
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index c72fbc74565..34e4993c54d 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -947,13 +947,6 @@ impl<'tcx> PartialEq for TyS<'tcx> {
 }
 impl<'tcx> Eq for TyS<'tcx> {}
 
-#[cfg(stage0)]
-impl<'tcx, S: Writer> Hash<S> for TyS<'tcx> {
-    fn hash(&self, s: &mut S) {
-        (self as *const _).hash(s)
-    }
-}
-#[cfg(not(stage0))]
 impl<'tcx, S: Writer + Hasher> Hash<S> for TyS<'tcx> {
     fn hash(&self, s: &mut S) {
         (self as *const _).hash(s)
diff --git a/src/librustc_back/lib.rs b/src/librustc_back/lib.rs
index d29a47b65b0..d778b916b67 100644
--- a/src/librustc_back/lib.rs
+++ b/src/librustc_back/lib.rs
@@ -32,6 +32,7 @@
 #![allow(unknown_features)]
 #![feature(slicing_syntax, box_syntax)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 
 extern crate syntax;
 extern crate serialize;
diff --git a/src/librustc_borrowck/lib.rs b/src/librustc_borrowck/lib.rs
index eedad75c89f..4dd9b3ad2ef 100644
--- a/src/librustc_borrowck/lib.rs
+++ b/src/librustc_borrowck/lib.rs
@@ -23,6 +23,7 @@
 #![feature(rustc_diagnostic_macros)]
 #![allow(unknown_features)] #![feature(int_uint)]
 #![allow(non_camel_case_types)]
+#![allow(unstable)]
 
 #[macro_use] extern crate log;
 #[macro_use] extern crate syntax;
diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs
index 5b6c64c1bee..50ff4546c37 100644
--- a/src/librustc_driver/lib.rs
+++ b/src/librustc_driver/lib.rs
@@ -29,6 +29,7 @@
 #![feature(box_syntax)]
 #![feature(rustc_diagnostic_macros)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 
 extern crate arena;
 extern crate flate;
diff --git a/src/librustc_llvm/lib.rs b/src/librustc_llvm/lib.rs
index 59676fa3504..4c9a25f42fb 100644
--- a/src/librustc_llvm/lib.rs
+++ b/src/librustc_llvm/lib.rs
@@ -26,6 +26,7 @@
 #![feature(link_args)]
 #![feature(box_syntax)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 
 extern crate libc;
 #[macro_use] #[no_link] extern crate rustc_bitflags;
diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
index 8e5f7c57690..9b5913c659b 100644
--- a/src/librustc_privacy/lib.rs
+++ b/src/librustc_privacy/lib.rs
@@ -19,6 +19,7 @@
 
 #![feature(rustc_diagnostic_macros)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 
 #[macro_use] extern crate log;
 #[macro_use] extern crate syntax;
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index 22064a35058..8c1e847748c 100644
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -20,6 +20,7 @@
 #![feature(slicing_syntax)]
 #![feature(rustc_diagnostic_macros)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 
 #[macro_use] extern crate log;
 #[macro_use] extern crate syntax;
diff --git a/src/librustc_trans/lib.rs b/src/librustc_trans/lib.rs
index 4859598e63c..c3e88e65b2f 100644
--- a/src/librustc_trans/lib.rs
+++ b/src/librustc_trans/lib.rs
@@ -29,6 +29,7 @@
 #![feature(box_syntax)]
 #![feature(rustc_diagnostic_macros)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 
 extern crate arena;
 extern crate flate;
diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs
index 88fe88bf265..47b5cd4b11e 100644
--- a/src/librustc_typeck/lib.rs
+++ b/src/librustc_typeck/lib.rs
@@ -79,6 +79,7 @@ This API is completely unstable and subject to change.
 #![feature(rustc_diagnostic_macros)]
 #![allow(unknown_features)] #![feature(int_uint)]
 #![allow(non_camel_case_types)]
+#![allow(unstable)]
 
 #[macro_use] extern crate log;
 #[macro_use] extern crate syntax;
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index e6eed480633..71bd53009af 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -20,6 +20,7 @@
 #![feature(slicing_syntax)]
 #![feature(box_syntax)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 
 extern crate arena;
 extern crate getopts;
diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs
index 942a8cfa2c5..b24e1bd685f 100644
--- a/src/libserialize/lib.rs
+++ b/src/libserialize/lib.rs
@@ -24,11 +24,11 @@ Core encoding and decoding interfaces.
        html_root_url = "http://doc.rust-lang.org/nightly/",
        html_playground_url = "http://play.rust-lang.org/")]
 #![allow(unknown_features)]
-#![cfg_attr(stage0, allow(unused_attributes))]
 #![feature(box_syntax)]
 #![feature(old_impl_check)]
 #![feature(slicing_syntax)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 
 // test harness access
 #[cfg(test)] extern crate test;
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index 2553bbdf523..ddb8129630f 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -112,6 +112,8 @@
 #![feature(old_impl_check)]
 #![feature(optin_builtin_traits)]
 #![feature(int_uint)]
+#![feature(int_uint)]
+#![allow(unstable)]
 
 // Don't link to std. We are std.
 #![no_std]
diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs
index e804408b4d0..3432767d6cd 100644
--- a/src/libstd/num/mod.rs
+++ b/src/libstd/num/mod.rs
@@ -424,14 +424,12 @@ mod tests {
         assert_eq!(int::MIN.to_u32(),  None);
         assert_eq!(int::MIN.to_u64(),  None);
 
-        #[cfg(any(all(stage0, target_word_size = "32"),
-                  all(not(stage0), target_pointer_width = "32")))]
+        #[cfg(target_pointer_width = "32")]
         fn check_word_size() {
             assert_eq!(int::MIN.to_i32(), Some(int::MIN as i32));
         }
 
-        #[cfg(any(all(stage0, target_word_size = "64"),
-                  all(not(stage0), target_pointer_width = "64")))]
+        #[cfg(target_pointer_width = "64")]
         fn check_word_size() {
             assert_eq!(int::MIN.to_i32(), None);
         }
@@ -494,14 +492,12 @@ mod tests {
         assert_eq!(i64::MIN.to_u32(),  None);
         assert_eq!(i64::MIN.to_u64(),  None);
 
-        #[cfg(any(all(stage0, target_word_size = "32"),
-                  all(not(stage0), target_pointer_width = "32")))]
+        #[cfg(target_pointer_width = "32")]
         fn check_word_size() {
             assert_eq!(i64::MIN.to_int(), None);
         }
 
-        #[cfg(any(all(stage0, target_word_size = "64"),
-                  all(not(stage0), target_pointer_width = "64")))]
+        #[cfg(target_pointer_width = "64")]
         fn check_word_size() {
             assert_eq!(i64::MIN.to_int(), Some(i64::MIN as int));
         }
@@ -521,15 +517,13 @@ mod tests {
         // int::MAX.to_u32() is word-size specific
         assert_eq!(int::MAX.to_u64(),  Some(int::MAX as u64));
 
-        #[cfg(any(all(stage0, target_word_size = "32"),
-                  all(not(stage0), target_pointer_width = "32")))]
+        #[cfg(target_pointer_width = "32")]
         fn check_word_size() {
             assert_eq!(int::MAX.to_i32(), Some(int::MAX as i32));
             assert_eq!(int::MAX.to_u32(), Some(int::MAX as u32));
         }
 
-        #[cfg(any(all(stage0, target_word_size = "64"),
-                  all(not(stage0), target_pointer_width = "64")))]
+        #[cfg(target_pointer_width = "64")]
         fn check_word_size() {
             assert_eq!(int::MAX.to_i32(), None);
             assert_eq!(int::MAX.to_u32(), None);
@@ -593,15 +587,13 @@ mod tests {
         assert_eq!(i64::MAX.to_u32(),  None);
         assert_eq!(i64::MAX.to_u64(),  Some(i64::MAX as u64));
 
-        #[cfg(any(all(stage0, target_word_size = "32"),
-                  all(not(stage0), target_pointer_width = "32")))]
+        #[cfg(target_pointer_width = "32")]
         fn check_word_size() {
             assert_eq!(i64::MAX.to_int(),  None);
             assert_eq!(i64::MAX.to_uint(), None);
         }
 
-        #[cfg(any(all(stage0, target_word_size = "64"),
-                  all(not(stage0), target_pointer_width = "64")))]
+        #[cfg(target_pointer_width = "64")]
         fn check_word_size() {
             assert_eq!(i64::MAX.to_int(),  Some(i64::MAX as int));
             assert_eq!(i64::MAX.to_uint(), Some(i64::MAX as uint));
@@ -692,15 +684,13 @@ mod tests {
         // uint::MAX.to_u32() is word-size specific
         assert_eq!(uint::MAX.to_u64(),  Some(uint::MAX as u64));
 
-        #[cfg(any(all(stage0, target_word_size = "32"),
-                  all(not(stage0), target_pointer_width = "32")))]
+        #[cfg(target_pointer_width = "32")]
         fn check_word_size() {
             assert_eq!(uint::MAX.to_u32(), Some(uint::MAX as u32));
             assert_eq!(uint::MAX.to_i64(), Some(uint::MAX as i64));
         }
 
-        #[cfg(any(all(stage0, target_word_size = "64"),
-                  all(not(stage0), target_pointer_width = "64")))]
+        #[cfg(target_pointer_width = "64")]
         fn check_word_size() {
             assert_eq!(uint::MAX.to_u32(), None);
             assert_eq!(uint::MAX.to_i64(), None);
@@ -750,14 +740,12 @@ mod tests {
         assert_eq!(u32::MAX.to_u32(),  Some(u32::MAX as u32));
         assert_eq!(u32::MAX.to_u64(),  Some(u32::MAX as u64));
 
-        #[cfg(any(all(stage0, target_word_size = "32"),
-                  all(not(stage0), target_pointer_width = "32")))]
+        #[cfg(target_pointer_width = "32")]
         fn check_word_size() {
             assert_eq!(u32::MAX.to_int(),  None);
         }
 
-        #[cfg(any(all(stage0, target_word_size = "64"),
-                  all(not(stage0), target_pointer_width = "64")))]
+        #[cfg(target_pointer_width = "64")]
         fn check_word_size() {
             assert_eq!(u32::MAX.to_int(),  Some(u32::MAX as int));
         }
@@ -778,14 +766,12 @@ mod tests {
         assert_eq!(u64::MAX.to_u32(),  None);
         assert_eq!(u64::MAX.to_u64(),  Some(u64::MAX as u64));
 
-        #[cfg(any(all(stage0, target_word_size = "32"),
-                  all(not(stage0), target_pointer_width = "32")))]
+        #[cfg(target_pointer_width = "32")]
         fn check_word_size() {
             assert_eq!(u64::MAX.to_uint(), None);
         }
 
-        #[cfg(any(all(stage0, target_word_size = "64"),
-                  all(not(stage0), target_pointer_width = "64")))]
+        #[cfg(target_pointer_width = "64")]
         fn check_word_size() {
             assert_eq!(u64::MAX.to_uint(), Some(u64::MAX as uint));
         }
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index 8130a6c82ec..23387d29553 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -230,9 +230,9 @@ use rc::Rc;
 use result::Result::{Ok, Err};
 use vec::Vec;
 
-#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
+#[cfg(target_pointer_width = "32")]
 use core_rand::IsaacRng as IsaacWordRng;
-#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
+#[cfg(target_pointer_width = "64")]
 use core_rand::Isaac64Rng as IsaacWordRng;
 
 pub use core_rand::{Rand, Rng, SeedableRng, Open01, Closed01};
diff --git a/src/libstd/sys/common/backtrace.rs b/src/libstd/sys/common/backtrace.rs
index f6161ec193d..d8b85987236 100644
--- a/src/libstd/sys/common/backtrace.rs
+++ b/src/libstd/sys/common/backtrace.rs
@@ -12,10 +12,10 @@ use prelude::v1::*;
 
 use io::IoResult;
 
-#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
+#[cfg(target_pointer_width = "64")]
 pub const HEX_WIDTH: uint = 18;
 
-#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
+#[cfg(target_pointer_width = "32")]
 pub const HEX_WIDTH: uint = 10;
 
 // All rust symbols are in theory lists of "::"-separated identifiers. Some
diff --git a/src/libstd/sys/unix/c.rs b/src/libstd/sys/unix/c.rs
index fed700cc9d5..9016d1a2c99 100644
--- a/src/libstd/sys/unix/c.rs
+++ b/src/libstd/sys/unix/c.rs
@@ -173,13 +173,13 @@ mod signal {
     unsafe impl ::marker::Sync for sigaction { }
 
     #[repr(C)]
-    #[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
+    #[cfg(target_pointer_width = "32")]
     pub struct sigset_t {
         __val: [libc::c_ulong; 32],
     }
 
     #[repr(C)]
-    #[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
+    #[cfg(target_pointer_width = "64")]
     pub struct sigset_t {
         __val: [libc::c_ulong; 16],
     }
diff --git a/src/libstd/sys/unix/stack_overflow.rs b/src/libstd/sys/unix/stack_overflow.rs
index 45680f52e73..2b5ced5085b 100644
--- a/src/libstd/sys/unix/stack_overflow.rs
+++ b/src/libstd/sys/unix/stack_overflow.rs
@@ -183,14 +183,12 @@ mod imp {
             sa_restorer: *mut libc::c_void,
         }
 
-        #[cfg(any(all(stage0, target_word_size = "32"),
-                  all(not(stage0), target_pointer_width = "32")))]
+        #[cfg(target_pointer_width = "32")]
         #[repr(C)]
         pub struct sigset_t {
             __val: [libc::c_ulong; 32],
         }
-        #[cfg(any(all(stage0, target_word_size = "64"),
-                  all(not(stage0), target_pointer_width = "64")))]
+        #[cfg(target_pointer_width = "64")]
         #[repr(C)]
         pub struct sigset_t {
             __val: [libc::c_ulong; 16],
diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs
index 096e96b003b..fa675a9fcaa 100644
--- a/src/libsyntax/lib.rs
+++ b/src/libsyntax/lib.rs
@@ -28,6 +28,7 @@
 #![feature(box_syntax)]
 #![feature(quote, unsafe_destructor)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 
 extern crate arena;
 extern crate fmt_macros;
diff --git a/src/libsyntax/ptr.rs b/src/libsyntax/ptr.rs
index 13a14d069d7..37fa8703706 100644
--- a/src/libsyntax/ptr.rs
+++ b/src/libsyntax/ptr.rs
@@ -38,7 +38,6 @@
 
 use std::fmt::{self, Show};
 use std::hash::{Hash, Hasher};
-#[cfg(stage0)] use std::hash::Writer;
 use std::ops::Deref;
 use std::ptr;
 
@@ -107,13 +106,6 @@ impl<T: Show> Show for P<T> {
     }
 }
 
-#[cfg(stage0)]
-impl<S: Writer, T: Hash<S>> Hash<S> for P<T> {
-    fn hash(&self, state: &mut S) {
-        (**self).hash(state);
-    }
-}
-#[cfg(not(stage0))]
 impl<S: Hasher, T: Hash<S>> Hash<S> for P<T> {
     fn hash(&self, state: &mut S) {
         (**self).hash(state);
diff --git a/src/libterm/lib.rs b/src/libterm/lib.rs
index 2117b68c08e..027c5a1a708 100644
--- a/src/libterm/lib.rs
+++ b/src/libterm/lib.rs
@@ -52,6 +52,7 @@
 #![feature(slicing_syntax)]
 #![feature(box_syntax)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 #![deny(missing_docs)]
 
 #[macro_use] extern crate log;
diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs
index 30173368585..b9e37156dc7 100644
--- a/src/libtest/lib.rs
+++ b/src/libtest/lib.rs
@@ -35,6 +35,7 @@
 #![feature(asm, slicing_syntax)]
 #![feature(box_syntax)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 
 extern crate getopts;
 extern crate regex;
diff --git a/src/libunicode/lib.rs b/src/libunicode/lib.rs
index 17607383bee..fbe912ced90 100644
--- a/src/libunicode/lib.rs
+++ b/src/libunicode/lib.rs
@@ -31,6 +31,7 @@
 #![no_std]
 #![feature(slicing_syntax)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![allow(unstable)]
 
 extern crate core;
 
diff --git a/src/rustbook/main.rs b/src/rustbook/main.rs
index 85b9a7d79db..ea72c653087 100644
--- a/src/rustbook/main.rs
+++ b/src/rustbook/main.rs
@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #![feature(slicing_syntax, box_syntax)]
+#![allow(unstable)]
 
 extern crate regex;
 
diff --git a/src/snapshots.txt b/src/snapshots.txt
index aa31974c67a..16fb109bb7d 100644
--- a/src/snapshots.txt
+++ b/src/snapshots.txt
@@ -1,3 +1,12 @@
+S 2015-01-15 9ade482
+  freebsd-x86_64 eb8f52c6e8dc24a293456d5e4dc5d1072442e758
+  linux-i386 0197ad7179d74eba06a8b46432548caf226aa03d
+  linux-x86_64 03459f8b216e96ed8b9abe25a42a75859195103d
+  macos-i386 b5c004883ddff84159f11a3329cde682e0b7f75b
+  macos-x86_64 b69ea42e1c995682adf0390ed4ef8a762c001a4e
+  winnt-i386 7fa6e35d26bbffa3888d440a0d5f116414ef8c0a
+  winnt-x86_64 ac04a4f1f26e0219d91e7eae6f580ca3cfee4231
+
 S 2015-01-07 9e4e524
   freebsd-x86_64 2563d33151bce1bbe08a85d712564bddc7503fc6
   linux-i386 d8b73fc9aa3ad72ce1408a41e35d78dba10eb4d4
diff --git a/src/test/compile-fail/fail-no-dead-code-core.rs b/src/test/compile-fail/fail-no-dead-code-core.rs
index 6f75181c31c..ee86c6ca1f0 100644
--- a/src/test/compile-fail/fail-no-dead-code-core.rs
+++ b/src/test/compile-fail/fail-no-dead-code-core.rs
@@ -10,6 +10,7 @@
 
 #![deny(dead_code)]
 #![allow(unreachable_code)]
+#![allow(unstable)]
 
 #[macro_use] extern crate core;
 
diff --git a/src/test/compile-fail/huge-enum.rs b/src/test/compile-fail/huge-enum.rs
index aef1fa85e0d..6e7c05370b9 100644
--- a/src/test/compile-fail/huge-enum.rs
+++ b/src/test/compile-fail/huge-enum.rs
@@ -12,12 +12,12 @@
 
 // FIXME: work properly with higher limits
 
-#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
+#[cfg(target_pointer_width = "32")]
 fn main() {
     let big: Option<[u32; (1<<29)-1]> = None;
 }
 
-#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
+#[cfg(target_pointer_width = "64")]
 fn main() {
     let big: Option<[u32; (1<<45)-1]> = None;
 }
diff --git a/src/test/compile-fail/issue-17913.rs b/src/test/compile-fail/issue-17913.rs
index 56cd544b3c6..1f5264aef61 100644
--- a/src/test/compile-fail/issue-17913.rs
+++ b/src/test/compile-fail/issue-17913.rs
@@ -13,14 +13,14 @@
 
 #![feature(box_syntax)]
 
-#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
+#[cfg(target_pointer_width = "64")]
 fn main() {
     let n = 0us;
     let a = box [&n; 0xF000000000000000us];
     println!("{}", a[0xFFFFFFu]);
 }
 
-#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
+#[cfg(target_pointer_width = "32")]
 fn main() {
     let n = 0us;
     let a = box [&n; 0xFFFFFFFFu];
diff --git a/src/test/compile-fail/issue-17999.rs b/src/test/compile-fail/issue-17999.rs
index 5726960f66a..eaefe55e066 100644
--- a/src/test/compile-fail/issue-17999.rs
+++ b/src/test/compile-fail/issue-17999.rs
@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #![deny(unused_variables)]
+#![allow(unstable)]
 
 fn main() {
     for _ in range(1is, 101) {
diff --git a/src/test/compile-fail/lint-ctypes.rs b/src/test/compile-fail/lint-ctypes.rs
index 801f9dfd1cf..5706453a220 100644
--- a/src/test/compile-fail/lint-ctypes.rs
+++ b/src/test/compile-fail/lint-ctypes.rs
@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #![deny(improper_ctypes)]
+#![allow(unstable)]
 
 extern crate libc;
 
diff --git a/src/test/compile-fail/lint-dead-code-1.rs b/src/test/compile-fail/lint-dead-code-1.rs
index 34c79be7118..ceba33360d9 100644
--- a/src/test/compile-fail/lint-dead-code-1.rs
+++ b/src/test/compile-fail/lint-dead-code-1.rs
@@ -13,6 +13,7 @@
 #![allow(non_camel_case_types)]
 #![allow(non_upper_case_globals)]
 #![allow(missing_copy_implementations)]
+#![allow(unstable)]
 #![deny(dead_code)]
 
 #![crate_type="lib"]
diff --git a/src/test/compile-fail/lint-dead-code-3.rs b/src/test/compile-fail/lint-dead-code-3.rs
index 03b89c522ce..89ab78968d0 100644
--- a/src/test/compile-fail/lint-dead-code-3.rs
+++ b/src/test/compile-fail/lint-dead-code-3.rs
@@ -10,6 +10,7 @@
 
 #![allow(unused_variables)]
 #![allow(non_camel_case_types)]
+#![allow(unstable)]
 #![deny(dead_code)]
 
 #![crate_type="lib"]
diff --git a/src/test/compile-fail/lint-dead-code-4.rs b/src/test/compile-fail/lint-dead-code-4.rs
index ac8f158f8fb..3221be220d9 100644
--- a/src/test/compile-fail/lint-dead-code-4.rs
+++ b/src/test/compile-fail/lint-dead-code-4.rs
@@ -10,6 +10,7 @@
 
 #![allow(unused_variables)]
 #![allow(non_camel_case_types)]
+#![allow(unstable)]
 #![deny(dead_code)]
 
 extern crate libc;
diff --git a/src/test/compile-fail/lint-exceeding-bitshifts.rs b/src/test/compile-fail/lint-exceeding-bitshifts.rs
index 91a4d0fea0a..4c880eda099 100644
--- a/src/test/compile-fail/lint-exceeding-bitshifts.rs
+++ b/src/test/compile-fail/lint-exceeding-bitshifts.rs
@@ -10,6 +10,7 @@
 
 #![deny(exceeding_bitshifts)]
 #![allow(unused_variables)]
+#![allow(unstable)]
 #![allow(dead_code)]
 
 fn main() {
diff --git a/src/test/compile-fail/lint-unused-extern-crate.rs b/src/test/compile-fail/lint-unused-extern-crate.rs
index c9d34d40479..ae156356b79 100644
--- a/src/test/compile-fail/lint-unused-extern-crate.rs
+++ b/src/test/compile-fail/lint-unused-extern-crate.rs
@@ -12,6 +12,7 @@
 
 #![deny(unused_extern_crates)]
 #![allow(unused_variables)]
+#![allow(unstable)]
 
 extern crate libc; //~ ERROR: unused extern crate
 
diff --git a/src/test/compile-fail/lint-uppercase-variables.rs b/src/test/compile-fail/lint-uppercase-variables.rs
index 9317e465a7a..d9f899ede04 100644
--- a/src/test/compile-fail/lint-uppercase-variables.rs
+++ b/src/test/compile-fail/lint-uppercase-variables.rs
@@ -11,6 +11,7 @@
 // ignore-tidy-linelength
 
 #![allow(dead_code)]
+#![allow(unstable)]
 #![deny(non_snake_case)]
 
 use std::io::File;
diff --git a/src/test/compile-fail/liveness-unused.rs b/src/test/compile-fail/liveness-unused.rs
index c9f8230b6c5..f27ee376f52 100644
--- a/src/test/compile-fail/liveness-unused.rs
+++ b/src/test/compile-fail/liveness-unused.rs
@@ -10,6 +10,7 @@
 
 #![deny(unused_variables)]
 #![deny(unused_assignments)]
+#![allow(unstable)]
 #![allow(dead_code, non_camel_case_types)]
 
 fn f1(x: isize) {
diff --git a/src/test/compile-fail/unused-attr.rs b/src/test/compile-fail/unused-attr.rs
index 635ceec73a3..b04f2edd142 100644
--- a/src/test/compile-fail/unused-attr.rs
+++ b/src/test/compile-fail/unused-attr.rs
@@ -9,6 +9,7 @@
 // except according to those terms.
 #![deny(unused_attributes)]
 #![allow(dead_code, unused_imports)]
+#![allow(unstable)]
 
 #![foo] //~ ERROR unused attribute
 
diff --git a/src/test/run-pass/huge-largest-array.rs b/src/test/run-pass/huge-largest-array.rs
index e1b0c115365..5083bd23207 100644
--- a/src/test/run-pass/huge-largest-array.rs
+++ b/src/test/run-pass/huge-largest-array.rs
@@ -10,12 +10,12 @@
 
 use std::mem::size_of;
 
-#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
+#[cfg(target_pointer_width = "32")]
 pub fn main() {
     assert_eq!(size_of::<[u8; (1 << 31) - 1]>(), (1 << 31) - 1);
 }
 
-#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
+#[cfg(target_pointer_width = "64")]
 pub fn main() {
     assert_eq!(size_of::<[u8; (1 << 47) - 1]>(), (1 << 47) - 1);
 }
diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs
index dbc23a63bba..c22fb811a7b 100644
--- a/src/test/run-pass/ifmt.rs
+++ b/src/test/run-pass/ifmt.rs
@@ -14,6 +14,7 @@
 #![deny(warnings)]
 #![allow(unused_must_use)]
 #![allow(unknown_features)]
+#![allow(unstable)]
 #![feature(box_syntax)]
 
 use std::fmt;
diff --git a/src/test/run-pass/issue-11958.rs b/src/test/run-pass/issue-11958.rs
index 13177880c5a..f557f662e81 100644
--- a/src/test/run-pass/issue-11958.rs
+++ b/src/test/run-pass/issue-11958.rs
@@ -12,6 +12,7 @@
 
 // Pretty printing tests complain about `use std::predule::*`
 #![allow(unused_imports)]
+#![allow(unstable)]
 
 // We shouldn't need to rebind a moved upvar as mut if it's already
 // marked as mut
diff --git a/src/test/run-pass/issue-16671.rs b/src/test/run-pass/issue-16671.rs
index e25b3e8e89c..4c72e4fdb73 100644
--- a/src/test/run-pass/issue-16671.rs
+++ b/src/test/run-pass/issue-16671.rs
@@ -14,6 +14,7 @@
 
 // Pretty printing tests complain about `use std::predule::*`
 #![allow(unused_imports)]
+#![allow(unstable)]
 
 // A var moved into a proc, that has a mutable loan path should
 // not trigger a misleading unused_mut warning.