From 89b80faa8ef2b52f5adc423cfcfed69b313ea1b7 Mon Sep 17 00:00:00 2001
From: Eduard Burtescu <edy.burt@gmail.com>
Date: Fri, 16 Jan 2015 17:01:02 +0200
Subject: [PATCH 1/9] Register new snapshots.

---
 mk/main.mk                              |   7 +-
 src/liballoc/boxed.rs                   |   8 -
 src/liballoc/rc.rs                      |   8 -
 src/libcollections/btree/map.rs         |  12 -
 src/libcollections/string.rs            |   9 -
 src/libcollections/vec.rs               |   8 -
 src/libcore/fmt/mod.rs                  |  23 --
 src/libcore/fmt/rt.rs                   |   9 -
 src/libcore/hash/mod.rs                 | 410 +++++++-----------------
 src/libcore/intrinsics.rs               |  11 -
 src/libcore/iter.rs                     |   4 +-
 src/libcore/lib.rs                      |   1 -
 src/libcore/num/int.rs                  |   7 +-
 src/libcore/num/isize.rs                |   6 +-
 src/libcore/num/mod.rs                  |   8 +-
 src/libcore/ops.rs                      |  18 --
 src/librustc/metadata/filesearch.rs     |   4 +-
 src/librustc/middle/ty.rs               |   7 -
 src/libserialize/lib.rs                 |   1 -
 src/libstd/num/mod.rs                   |  42 +--
 src/libstd/rand/mod.rs                  |   4 +-
 src/libstd/sys/common/backtrace.rs      |   4 +-
 src/libstd/sys/unix/c.rs                |   4 +-
 src/libstd/sys/unix/stack_overflow.rs   |   6 +-
 src/libsyntax/ptr.rs                    |   8 -
 src/snapshots.txt                       |   9 +
 src/test/compile-fail/huge-enum.rs      |   4 +-
 src/test/compile-fail/issue-17913.rs    |   4 +-
 src/test/run-pass/huge-largest-array.rs |   4 +-
 29 files changed, 173 insertions(+), 477 deletions(-)

diff --git a/mk/main.mk b/mk/main.mk
index 46cbe34904dbc..8e3b19ad70aff 100644
--- a/mk/main.mk
+++ b/mk/main.mk
@@ -333,7 +333,6 @@ export CFG_DISABLE_UNSTABLE_FEATURES
 endif
 # Subvert unstable feature lints to do the self-build
 export CFG_BOOTSTRAP_KEY
-export RUSTC_BOOTSTRAP_KEY:=$(CFG_BOOTSTRAP_KEY)
 
 ######################################################################
 # Per-stage targets and runner
@@ -404,8 +403,13 @@ CSREQ$(1)_T_$(2)_H_$(3) = \
 ifeq ($(1),0)
 # Don't run the stage0 compiler under valgrind - that ship has sailed
 CFG_VALGRIND_COMPILE$(1) =
+# FIXME(21230) HACK Extract the key from the snapshot
+CFG_BOOSTRAP_KEY_ENV$(1) = RUSTC_BOOTSTRAP_KEY=$$$$((grep -a 'save analysis[0-9]' \
+	$$(HBIN$(1)_H_$(3))/rustc$$(X_$(3)) || echo N) |\
+	sed 's/.*save analysis\([0-9]*\).*/\1/')
 else
 CFG_VALGRIND_COMPILE$(1) = $$(CFG_VALGRIND_COMPILE)
+CFG_BOOSTRAP_KEY_ENV$(1) = RUSTC_BOOTSTRAP_KEY=$$(CFG_BOOTSTRAP_KEY)
 endif
 
 # Add RUSTFLAGS_STAGEN values to the build command
@@ -478,6 +482,7 @@ STAGE$(1)_T_$(2)_H_$(3) := \
 	$$(Q)$$(RPATH_VAR$(1)_T_$(2)_H_$(3)) \
 		$$(call CFG_RUN_TARG_$(3),$(1), \
 		$$(CFG_VALGRIND_COMPILE$(1)) \
+		$$(CFG_BOOSTRAP_KEY_ENV$(1)) \
 		$$(HBIN$(1)_H_$(3))/rustc$$(X_$(3)) \
 		--cfg $$(CFGFLAG$(1)_T_$(2)_H_$(3)) \
 		$$(CFG_RUSTC_FLAGS) $$(EXTRAFLAGS_STAGE$(1)) --target=$(2)) \
diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs
index 458eb3dce57a8..8ad0c152dc8ed 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/rc.rs b/src/liballoc/rc.rs
index 0e18cdda8dd89..7191a7af346b0 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/libcollections/btree/map.rs b/src/libcollections/btree/map.rs
index 6c3767b011158..3ac6b2775bfa8 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/string.rs b/src/libcollections/string.rs
index c845d86ca0fe7..5d35d8a86795a 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 73afefc5a0331..38658a17e9b4d 100644
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -1185,14 +1185,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 20ac3e28c973e..535722f93bfd6 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 2abf921eaf2c1..bea322191552b 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 a82ea009e1361..37e4a105a30cb 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 978e8a19737b4..40db0def62667 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 5ed77852ad0a1..0005db36c278a 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 78e8a2a9e9164..0b150d1ecf90b 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 065763a0d8ed4..83011db35cec8 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 c1cf3c6213148..e4711c92c599c 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 57415f4331d6d..599a5515e3b48 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 7d41c3fc5a56f..db7177e26fa27 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/librustc/metadata/filesearch.rs b/src/librustc/metadata/filesearch.rs
index 55a23aa516eca..ddee1f79d6a68 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 c72fbc745651a..34e4993c54da3 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/libserialize/lib.rs b/src/libserialize/lib.rs
index 942a8cfa2c5b9..70aac61b6bf47 100644
--- a/src/libserialize/lib.rs
+++ b/src/libserialize/lib.rs
@@ -24,7 +24,6 @@ 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)]
diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs
index e804408b4d0e2..3432767d6cd8c 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 8130a6c82ec3e..23387d2955313 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 f6161ec193d52..d8b8598723607 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 fed700cc9d52a..9016d1a2c99ca 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 45680f52e73d1..2b5ced5085bbe 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/ptr.rs b/src/libsyntax/ptr.rs
index 13a14d069d705..37fa8703706e0 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/snapshots.txt b/src/snapshots.txt
index aa31974c67abd..16fb109bb7d2b 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/huge-enum.rs b/src/test/compile-fail/huge-enum.rs
index aef1fa85e0d94..6e7c05370b99d 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 56cd544b3c605..1f5264aef6113 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/run-pass/huge-largest-array.rs b/src/test/run-pass/huge-largest-array.rs
index e1b0c1153657e..5083bd2320730 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);
 }

From fa1d63acd3c144ffe53766686090c3fb3a551c8d Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Fri, 16 Jan 2015 22:31:31 -0800
Subject: [PATCH 2/9] mk: Revert hack to pull the bootstrap key from the
 snapshot bins

---
 mk/main.mk | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/mk/main.mk b/mk/main.mk
index 8e3b19ad70aff..46cbe34904dbc 100644
--- a/mk/main.mk
+++ b/mk/main.mk
@@ -333,6 +333,7 @@ export CFG_DISABLE_UNSTABLE_FEATURES
 endif
 # Subvert unstable feature lints to do the self-build
 export CFG_BOOTSTRAP_KEY
+export RUSTC_BOOTSTRAP_KEY:=$(CFG_BOOTSTRAP_KEY)
 
 ######################################################################
 # Per-stage targets and runner
@@ -403,13 +404,8 @@ CSREQ$(1)_T_$(2)_H_$(3) = \
 ifeq ($(1),0)
 # Don't run the stage0 compiler under valgrind - that ship has sailed
 CFG_VALGRIND_COMPILE$(1) =
-# FIXME(21230) HACK Extract the key from the snapshot
-CFG_BOOSTRAP_KEY_ENV$(1) = RUSTC_BOOTSTRAP_KEY=$$$$((grep -a 'save analysis[0-9]' \
-	$$(HBIN$(1)_H_$(3))/rustc$$(X_$(3)) || echo N) |\
-	sed 's/.*save analysis\([0-9]*\).*/\1/')
 else
 CFG_VALGRIND_COMPILE$(1) = $$(CFG_VALGRIND_COMPILE)
-CFG_BOOSTRAP_KEY_ENV$(1) = RUSTC_BOOTSTRAP_KEY=$$(CFG_BOOTSTRAP_KEY)
 endif
 
 # Add RUSTFLAGS_STAGEN values to the build command
@@ -482,7 +478,6 @@ STAGE$(1)_T_$(2)_H_$(3) := \
 	$$(Q)$$(RPATH_VAR$(1)_T_$(2)_H_$(3)) \
 		$$(call CFG_RUN_TARG_$(3),$(1), \
 		$$(CFG_VALGRIND_COMPILE$(1)) \
-		$$(CFG_BOOSTRAP_KEY_ENV$(1)) \
 		$$(HBIN$(1)_H_$(3))/rustc$$(X_$(3)) \
 		--cfg $$(CFGFLAG$(1)_T_$(2)_H_$(3)) \
 		$$(CFG_RUSTC_FLAGS) $$(EXTRAFLAGS_STAGE$(1)) --target=$(2)) \

From 056f8f02516da6e878a00549f9b2a0d68e6bcad8 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Fri, 16 Jan 2015 22:33:00 -0800
Subject: [PATCH 3/9] mk: Don't set RUSTC_BOOTSTRAP_KEY on -dev and -nightly.
 Not needed

---
 mk/main.mk | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/mk/main.mk b/mk/main.mk
index 46cbe34904dbc..8c910f4759610 100644
--- a/mk/main.mk
+++ b/mk/main.mk
@@ -330,10 +330,10 @@ ifdef CFG_DISABLE_UNSTABLE_FEATURES
 CFG_INFO := $(info cfg: disabling unstable features (CFG_DISABLE_UNSTABLE_FEATURES))
 # Turn on feature-staging
 export CFG_DISABLE_UNSTABLE_FEATURES
-endif
 # Subvert unstable feature lints to do the self-build
-export CFG_BOOTSTRAP_KEY
 export RUSTC_BOOTSTRAP_KEY:=$(CFG_BOOTSTRAP_KEY)
+endif
+export CFG_BOOTSTRAP_KEY
 
 ######################################################################
 # Per-stage targets and runner

From 6f3a80e4117af4e2c167101fb4fdba35d3e1f7eb Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Fri, 16 Jan 2015 22:33:24 -0800
Subject: [PATCH 4/9] Set allow(unstable) in crates that use unstable features

Lets them build with the -dev, -nightly, or snapshot compiler
---
 src/compiletest/compiletest.rs | 1 +
 src/liballoc/lib.rs            | 1 +
 src/libarena/lib.rs            | 1 +
 src/libcollections/lib.rs      | 1 +
 src/libcoretest/lib.rs         | 1 +
 src/libflate/lib.rs            | 1 +
 src/libfmt_macros/lib.rs       | 1 +
 src/libgetopts/lib.rs          | 1 +
 src/libgraphviz/lib.rs         | 1 +
 src/liblibc/lib.rs             | 1 +
 src/liblog/lib.rs              | 1 +
 src/librand/lib.rs             | 1 +
 src/librbml/lib.rs             | 1 +
 src/libregex/lib.rs            | 1 +
 src/librustc/lib.rs            | 1 +
 src/librustc_back/lib.rs       | 1 +
 src/librustc_borrowck/lib.rs   | 1 +
 src/librustc_driver/lib.rs     | 1 +
 src/librustc_llvm/lib.rs       | 1 +
 src/librustc_resolve/lib.rs    | 1 +
 src/librustc_trans/lib.rs      | 1 +
 src/librustc_typeck/lib.rs     | 1 +
 src/librustdoc/lib.rs          | 1 +
 src/libserialize/lib.rs        | 1 +
 src/libstd/lib.rs              | 2 ++
 src/libsyntax/lib.rs           | 1 +
 src/libterm/lib.rs             | 1 +
 src/libtest/lib.rs             | 1 +
 src/libunicode/lib.rs          | 1 +
 src/rustbook/main.rs           | 1 +
 30 files changed, 31 insertions(+)

diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs
index 802fb05796d66..f3514c6e7bc82 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/liballoc/lib.rs b/src/liballoc/lib.rs
index 6c85330603514..811e32e747dfd 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/libarena/lib.rs b/src/libarena/lib.rs
index e3d075c0f39b9..7458cc60c15c2 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/lib.rs b/src/libcollections/lib.rs
index e222373ff5980..797042c321611 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/libcoretest/lib.rs b/src/libcoretest/lib.rs
index 0d371dbe15375..0c7b72612fae1 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 fb6c98515f7f0..f0a2ab3d1d6cc 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 85944ccc5517c..0ff153274410a 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 470ef6e7e57a3..c2114d4c6df6d 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 b48fe2e42786d..2d7d88f0f35e0 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 7fb609b4c9450..0ad18e2532927 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 a166dc369cb1b..dbd8843412785 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 8430ee81c3214..853eb41d011b4 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 6a7062a419e59..f28600e5e6973 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 45f42336ceb45..002b74cf1efa4 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 a283fdf36a96b..628690645514a 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_back/lib.rs b/src/librustc_back/lib.rs
index d29a47b65b0a3..d778b916b6748 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 eedad75c89fe2..4dd9b3ad2ef97 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 5b6c64c1beea6..50ff4546c3783 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 59676fa3504a9..4c9a25f42fb77 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_resolve/lib.rs b/src/librustc_resolve/lib.rs
index 22064a35058ec..8c1e847748c3d 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 4859598e63c7a..c3e88e65b2fd0 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 88fe88bf26540..47b5cd4b11e0f 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 e6eed4806338b..71bd53009af0b 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 70aac61b6bf47..b24e1bd685f1e 100644
--- a/src/libserialize/lib.rs
+++ b/src/libserialize/lib.rs
@@ -28,6 +28,7 @@ Core encoding and decoding interfaces.
 #![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 2553bbdf52310..ddb8129630f75 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/libsyntax/lib.rs b/src/libsyntax/lib.rs
index 096e96b003bb0..fa675a9fcaaec 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/libterm/lib.rs b/src/libterm/lib.rs
index 2117b68c08e59..027c5a1a70832 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 30173368585d2..b9e37156dc7a0 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 17607383beed1..fbe912ced905b 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 85b9a7d79dbfe..ea72c653087d3 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;
 

From 3e38926ff40223031c710cc09c9a4a27d00bd813 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Fri, 16 Jan 2015 22:39:04 -0800
Subject: [PATCH 5/9] configure: Use a more portable 'date' command to create
 the bootstrap key

---
 configure | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/configure b/configure
index 86ed88c8d0631..712db849039a9 100755
--- a/configure
+++ b/configure
@@ -612,7 +612,7 @@ putvar CFG_RELEASE_CHANNEL
 # channel.
 # Basing CFG_BOOTSTRAP_KEY on CFG_BOOTSTRAP_KEY lets it get picked up
 # during a Makefile reconfig.
-CFG_BOOTSTRAP_KEY="${CFG_BOOTSTRAP_KEY-`date +%N`}"
+CFG_BOOTSTRAP_KEY="${CFG_BOOTSTRAP_KEY-`date +%H:%M:%S`}"
 putvar CFG_BOOTSTRAP_KEY
 
 step_msg "looking for build programs"

From 1f46ae285d40a79867457f49626a4fc5f11cedd5 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Fri, 16 Jan 2015 23:35:44 -0800
Subject: [PATCH 6/9] Add allow(unstable) to tests that need it

---
 src/test/compile-fail/fail-no-dead-code-core.rs   | 1 +
 src/test/compile-fail/issue-17999.rs              | 1 +
 src/test/compile-fail/lint-ctypes.rs              | 1 +
 src/test/compile-fail/lint-dead-code-1.rs         | 1 +
 src/test/compile-fail/lint-dead-code-3.rs         | 1 +
 src/test/compile-fail/lint-dead-code-4.rs         | 1 +
 src/test/compile-fail/lint-exceeding-bitshifts.rs | 1 +
 src/test/compile-fail/lint-unused-extern-crate.rs | 1 +
 src/test/compile-fail/lint-uppercase-variables.rs | 1 +
 src/test/compile-fail/liveness-unused.rs          | 1 +
 src/test/compile-fail/unused-attr.rs              | 1 +
 11 files changed, 11 insertions(+)

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 6f75181c31cbc..ee86c6ca1f06f 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/issue-17999.rs b/src/test/compile-fail/issue-17999.rs
index 5726960f66a1c..eaefe55e066b4 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 801f9dfd1cf3b..5706453a22052 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 34c79be7118ba..ceba33360d947 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 03b89c522ce8d..89ab78968d04f 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 ac8f158f8fb28..3221be220d98c 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 91a4d0fea0af4..4c880eda099ca 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 c9d34d40479cf..ae156356b79b4 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 9317e465a7a07..d9f899ede0482 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 c9f8230b6c5ae..f27ee376f5204 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 635ceec73a385..b04f2edd14240 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
 

From 9035ba5f761af969aa811278bdadb1fcd94529e9 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Sat, 17 Jan 2015 00:11:19 -0800
Subject: [PATCH 7/9] Add allow(unstable) to driver.rs

---
 src/driver/driver.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/driver/driver.rs b/src/driver/driver.rs
index 5c29cb4ec7276..5f086280a65a5 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;
 

From 5cfbecfdb41b98833edee00372303b3167c4a596 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Sat, 17 Jan 2015 00:58:06 -0800
Subject: [PATCH 8/9] Add allow(unstable) to more tests

---
 src/test/run-pass/ifmt.rs        | 1 +
 src/test/run-pass/issue-11958.rs | 1 +
 src/test/run-pass/issue-16671.rs | 1 +
 3 files changed, 3 insertions(+)

diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs
index dbc23a63bbadf..c22fb811a7b9e 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 13177880c5ab7..f557f662e8104 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 e25b3e8e89c6c..4c72e4fdb73ec 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.

From 8b2335a01d000300cca7d8b12210e605424eedb4 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Sat, 17 Jan 2015 09:13:48 -0800
Subject: [PATCH 9/9] Add allow(unstable) to librustc_privacy

---
 src/librustc_privacy/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
index 8e5f7c576906c..9b5913c659bb4 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;