rollup merge of #20708: aturon/new-int-modules

Conflicts:
	src/libserialize/lib.rs

src/libcollections/lib.rs

@@ -102,8 +102,6 @@ mod std {
     pub use core::option;   // necessary for panic!()
     pub use core::clone;    // deriving(Clone)
     pub use core::cmp;      // deriving(Eq, Ord, etc.)
-    #[cfg(stage0)]
-    pub use core::marker as kinds;
     pub use core::marker;  // deriving(Copy)
     pub use core::hash;     // deriving(Hash)
 }

src/libcollections/string.rs

@@ -930,18 +930,6 @@ pub trait ToString {
     fn to_string(&self) -> String;
 }
 
-#[cfg(stage0)]
-impl<T: fmt::Show> ToString for T {
-    fn to_string(&self) -> String {
-        use core::fmt::Writer;
-        let mut buf = String::new();
-        let _ = buf.write_fmt(format_args!("{}", self));
-        buf.shrink_to_fit();
-        buf
-    }
-}
-
-#[cfg(not(stage0))]
 impl<T: fmt::String> ToString for T {
     fn to_string(&self) -> String {
         use core::fmt::Writer;

src/libcollections/vec.rs

@@ -1462,15 +1462,6 @@ impl<T: fmt::Show> fmt::Show for Vec<T> {
     }
 }
 
-#[cfg(stage0)]
-#[experimental = "waiting on Show stability"]
-impl<T: fmt::Show> fmt::String for Vec<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self.as_slice(), f)
-    }
-}
-
-#[cfg(not(stage0))]
 #[experimental = "waiting on Show stability"]
 impl<T: fmt::String> fmt::String for Vec<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

src/libcore/borrow.rs

@@ -133,7 +133,7 @@ impl<T> ToOwned<T> for T where T: Clone {
 ///     }
 /// }
 /// ```
-//#[deriving(Show)] NOTE(stage0): uncomment after snapshot
+#[derive(Show)]
 pub enum Cow<'a, T, B: ?Sized + 'a> where B: ToOwned<T> {
     /// Borrowed data.
     Borrowed(&'a B),
@@ -142,16 +142,6 @@ pub enum Cow<'a, T, B: ?Sized + 'a> where B: ToOwned<T> {
     Owned(T)
 }
 
-//NOTE(stage0): replace with deriving(Show) after snapshot
-impl<'a, T, B: ?Sized> fmt::Show for Cow<'a, T, B> where
-    B: fmt::String + ToOwned<T>,
-    T: fmt::String
-{
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 #[stable]
 impl<'a, T, B: ?Sized> Clone for Cow<'a, T, B> where B: ToOwned<T> {
     fn clone(&self) -> Cow<'a, T, B> {

src/libcore/fmt/mod.rs

@@ -633,16 +633,6 @@ impl String for bool {
     }
 }
 
-#[cfg(stage0)]
-//NOTE(stage0): remove impl after snapshot
-impl Show for str {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        String::fmt(self, f)
-    }
-}
-
-#[cfg(not(stage0))]
-//NOTE(stage0): remove cfg after snapshot
 impl Show for str {
     fn fmt(&self, f: &mut Formatter) -> Result {
         try!(write!(f, "\""));
@@ -659,16 +649,6 @@ impl String for str {
     }
 }
 
-#[cfg(stage0)]
-//NOTE(stage0): remove impl after snapshot
-impl Show for char {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        String::fmt(self, f)
-    }
-}
-
-#[cfg(not(stage0))]
-//NOTE(stage0): remove cfg after snapshot
 impl Show for char {
     fn fmt(&self, f: &mut Formatter) -> Result {
         use char::CharExt;
@@ -863,28 +843,6 @@ impl<T: Show> Show for [T] {
     }
 }
 
-#[cfg(stage0)]
-impl<T: Show> String for [T] {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 {
-            try!(write!(f, "["));
-        }
-        let mut is_first = true;
-        for x in self.iter() {
-            if is_first {
-                is_first = false;
-            } else {
-                try!(write!(f, ", "));
-            }
-            try!(write!(f, "{}", *x))
-        }
-        if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 {
-            try!(write!(f, "]"));
-        }
-        Ok(())
-    }
-}
-#[cfg(not(stage0))]
 impl<T: String> String for [T] {
     fn fmt(&self, f: &mut Formatter) -> Result {
         if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 {

src/libcore/fmt/num.rs

@@ -155,14 +155,6 @@ pub fn radix<T>(x: T, base: u8) -> RadixFmt<T, Radix> {
 
 macro_rules! radix_fmt {
     ($T:ty as $U:ty, $fmt:ident, $S:expr) => {
-        #[cfg(stage0)]
-        impl fmt::Show for RadixFmt<$T, Radix> {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                fmt::String::fmt(self, f)
-            }
-        }
-
-        #[cfg(not(stage0))]
         impl fmt::Show for RadixFmt<$T, Radix> {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                 try!(fmt::String::fmt(self, f));
@@ -188,14 +180,6 @@ macro_rules! int_base {
 
 macro_rules! show {
     ($T:ident with $S:expr) => {
-        #[cfg(stage0)]
-        impl fmt::Show for $T {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                fmt::String::fmt(self, f)
-            }
-        }
-
-        #[cfg(not(stage0))]
         impl fmt::Show for $T {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                 try!(fmt::String::fmt(self, f));

src/libcore/lib.rs

@@ -79,12 +79,14 @@ mod int_macros;
 mod uint_macros;
 
 #[path = "num/int.rs"]  pub mod int;
+#[path = "num/isize.rs"]  pub mod isize;
 #[path = "num/i8.rs"]   pub mod i8;
 #[path = "num/i16.rs"]  pub mod i16;
 #[path = "num/i32.rs"]  pub mod i32;
 #[path = "num/i64.rs"]  pub mod i64;
 
 #[path = "num/uint.rs"] pub mod uint;
+#[path = "num/usize.rs"] pub mod usize;
 #[path = "num/u8.rs"]   pub mod u8;
 #[path = "num/u16.rs"]  pub mod u16;
 #[path = "num/u32.rs"]  pub mod u32;
@@ -147,8 +149,6 @@ mod core {
 mod std {
     pub use clone;
     pub use cmp;
-    #[cfg(stage0)]
-    pub use marker as kinds;
     pub use marker;
     pub use option;
     pub use fmt;

src/libcore/num/int.rs

@@ -8,10 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Operations and constants for architecture-sized signed integers (`int` type)
+//! Deprecated: replaced by `isize`.
+//!
+//! The rollout of the new type will gradually take place over the
+//! alpha cycle along with the development of clearer conventions
+//! around integer types.
 
-#![stable]
-#![doc(primitive = "int")]
+#![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 }

src/libcore/num/isize.rs

@@ -0,0 +1,21 @@
+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Operations and constants for pointer-sized signed integers (`isize` type)
+//!
+//! This type was recently added to replace `int`. The rollout of the
+//! new type will gradually take place over the alpha cycle along with
+//! the development of clearer conventions around integer types.
+
+#![stable]
+#![doc(primitive = "isize")]
+
+#[cfg(target_word_size = "32")] int_module! { isize, 32 }
+#[cfg(target_word_size = "64")] int_module! { isize, 64 }

src/libcore/num/uint.rs

@@ -8,9 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Operations and constants for architecture-sized unsigned integers (`uint` type)
+//! Deprecated: replaced by `usize`.
+//!
+//! The rollout of the new type will gradually take place over the
+//! alpha cycle along with the development of clearer conventions
+//! around integer types.
 
-#![stable]
-#![doc(primitive = "uint")]
+#![deprecated = "replaced by usize"]
 
 uint_module! { uint, int, ::int::BITS }

src/libcore/num/usize.rs

@@ -0,0 +1,20 @@
+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Operations and constants for pointer-sized unsigned integers (`usize` type)
+//!
+//! This type was recently added to replace `uint`. The rollout of the
+//! new type will gradually take place over the alpha cycle along with
+//! the development of clearer conventions around integer types.
+
+#![stable]
+#![doc(primitive = "usize")]
+
+uint_module! { usize, isize, ::isize::BITS }

src/liblibc/lib.rs

@@ -5066,7 +5066,5 @@ pub fn issue_14344_workaround() {} // FIXME #14344 force linkage to happen corre
 #[doc(hidden)]
 #[cfg(not(test))]
 mod std {
-    #[cfg(stage0)]
-    pub use core::marker as kinds;
     pub use core::marker;
 }

src/librand/lib.rs

@@ -496,8 +496,6 @@ pub struct Closed01<F>(pub F);
 mod std {
     pub use core::{option, fmt}; // panic!()
     pub use core::clone; // derive Clone
-    #[cfg(stage0)]
-    pub use core::marker as kinds;
     pub use core::marker;
 }
 

src/libregex/re.rs

@@ -90,15 +90,6 @@ impl Clone for ExNative {
     }
 }
 
-#[cfg(stage0)]
-//FIXME: remove after stage0 snapshot
-impl fmt::Show for Regex {
-    /// Shows the original regular expression.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self.as_str(), f)
-    }
-}
-
 impl fmt::String for Regex {
     /// Shows the original regular expression.
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

src/librustc_back/svh.rs

@@ -119,9 +119,7 @@ impl Svh {
 
 impl fmt::Show for Svh {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        //NOTE(stage0): uncomment after snapshot
-        //write!(f, "Svh {{ {} }}", self.as_str())
-        fmt::String::fmt(self, f)
+        write!(f, "Svh {{ {} }}", self.as_str())
     }
 }
 

src/librustc_typeck/check/_match.rs

@@ -195,7 +195,7 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
         ast::PatRegion(ref inner, mutbl) => {
             let inner_ty = fcx.infcx().next_ty_var();
 
-            // SNAP 340ac04 remove this `if`-`else` entirely after next snapshot
+            // SNAP 9e4e524 remove this `if`-`else` entirely after next snapshot
             let mutbl = if mutbl == ast::MutImmutable {
                 ty::deref(fcx.infcx().shallow_resolve(expected), true)
                    .map(|mt| mt.mutbl).unwrap_or(ast::MutImmutable)

src/librustdoc/html/escape.rs

@@ -19,14 +19,6 @@ use std::fmt;
 /// string when passed to a format string.
 pub struct Escape<'a>(pub &'a str);
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for Escape<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for Escape<'a> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         // Because the internet is always right, turns out there's not that many

src/librustdoc/html/format.rs

@@ -64,14 +64,6 @@ impl UnsafetySpace {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for TyParamBounds<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for TyParamBounds<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let &TyParamBounds(bounds) = self;
@@ -85,14 +77,6 @@ impl<'a> fmt::String for TyParamBounds<'a> {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::Generic {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::Generics {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if self.lifetimes.len() == 0 && self.type_params.len() == 0 { return Ok(()) }
@@ -130,14 +114,6 @@ impl fmt::String for clean::Generics {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for WhereClause<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for WhereClause<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let &WhereClause(gens) = self;
@@ -175,14 +151,6 @@ impl<'a> fmt::String for WhereClause<'a> {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::Lifetime {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::Lifetime {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         try!(f.write_str(self.get_ref()));
@@ -190,14 +158,6 @@ impl fmt::String for clean::Lifetime {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::PolyTrait {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::PolyTrait {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if self.lifetimes.len() > 0 {
@@ -214,14 +174,6 @@ impl fmt::String for clean::PolyTrait {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::TyParamBound {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::TyParamBound {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -239,14 +191,6 @@ impl fmt::String for clean::TyParamBound {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::PathParameters {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::PathParameters {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -292,14 +236,6 @@ impl fmt::String for clean::PathParameters {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::PathSegment {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::PathSegment {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         try!(f.write_str(self.name.as_slice()));
@@ -307,14 +243,6 @@ impl fmt::String for clean::PathSegment {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::Path {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::Path {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if self.global {
@@ -501,14 +429,6 @@ fn tybounds(w: &mut fmt::Formatter,
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::Type {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::Type {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -650,15 +570,6 @@ impl fmt::String for clean::Type {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::Arguments {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
-
 impl fmt::String for clean::Arguments {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         for (i, input) in self.values.iter().enumerate() {
@@ -672,14 +583,6 @@ impl fmt::String for clean::Arguments {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::FunctionRetTy {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::FunctionRetTy {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -690,28 +593,12 @@ impl fmt::String for clean::FunctionRetTy {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::FnDecl {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::FnDecl {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "({args}){arrow}", args = self.inputs, arrow = self.output)
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for Method<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for Method<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let Method(selfty, d) = *self;
@@ -742,14 +629,6 @@ impl<'a> fmt::String for Method<'a> {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for VisSpace {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for VisSpace {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.get() {
@@ -759,14 +638,6 @@ impl fmt::String for VisSpace {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for UnsafetySpace {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for UnsafetySpace {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.get() {
@@ -776,14 +647,6 @@ impl fmt::String for UnsafetySpace {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::ViewPath {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::ViewPath {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -811,14 +674,6 @@ impl fmt::String for clean::ViewPath {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::ImportSource {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::ImportSource {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.did {
@@ -836,14 +691,6 @@ impl fmt::String for clean::ImportSource {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::ViewListIdent {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::ViewListIdent {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.source {
@@ -865,14 +712,6 @@ impl fmt::String for clean::ViewListIdent {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for MutableSpace {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for MutableSpace {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -882,14 +721,6 @@ impl fmt::String for MutableSpace {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for RawMutableSpace {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for RawMutableSpace {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -899,14 +730,6 @@ impl fmt::String for RawMutableSpace {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for Stability<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for Stability<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let Stability(stab) = *self;
@@ -921,14 +744,6 @@ impl<'a> fmt::String for Stability<'a> {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for ConciseStability<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for ConciseStability<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let ConciseStability(stab) = *self;
@@ -946,14 +761,6 @@ impl<'a> fmt::String for ConciseStability<'a> {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for ModuleSummary {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for ModuleSummary {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fn fmt_inner<'a>(f: &mut fmt::Formatter,

src/librustdoc/html/item_type.rs

@@ -103,14 +103,6 @@ impl ItemType {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for ItemType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for ItemType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         self.to_static_str().fmt(f)

src/librustdoc/html/markdown.rs

@@ -435,14 +435,6 @@ pub fn reset_headers() {
     TEST_IDX.with(|s| s.set(0));
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for Markdown<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for Markdown<'a> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let Markdown(md) = *self;
@@ -452,14 +444,6 @@ impl<'a> fmt::String for Markdown<'a> {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for MarkdownWithToc<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for MarkdownWithToc<'a> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let MarkdownWithToc(md) = *self;

src/librustdoc/html/render.rs

@@ -1351,14 +1351,6 @@ impl<'a> Item<'a> {
 }
 
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for Item<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for Item<'a> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         // Write the breadcrumb trail header for the top
@@ -1634,14 +1626,6 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
 
 struct Initializer<'a>(&'a str);
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for Initializer<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for Initializer<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let Initializer(s) = *self;
@@ -2204,14 +2188,6 @@ fn item_typedef(w: &mut fmt::Formatter, it: &clean::Item,
     document(w, it)
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for Sidebar<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for Sidebar<'a> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let cx = self.cx;
@@ -2267,14 +2243,6 @@ impl<'a> fmt::String for Sidebar<'a> {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for Source<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for Source<'a> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let Source(s) = *self;

src/libserialize/json.rs

@@ -2458,14 +2458,6 @@ impl<'a> fmt::String for PrettyJson<'a> {
     }
 }
 
-#[cfg(stage0)]
-//NOTE(stage0): remove impl after snapshot
-impl<'a, T: Encodable> fmt::Show for AsJson<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a, T: Encodable> fmt::String for AsJson<'a, T> {
     /// Encodes a json value into a string
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

src/libserialize/lib.rs

@@ -24,8 +24,9 @@ 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)]
-#![feature(slicing_syntax)]
 #![cfg_attr(stage0, allow(unused_attributes))]
+#![feature(old_impl_check)]
+#![feature(slicing_syntax)]
 
 // test harness access
 #[cfg(test)] extern crate test;

src/libstd/io/mod.rs

@@ -1783,9 +1783,8 @@ pub struct UnstableFileStat {
 }
 
 
-// NOTE(stage0): change this one last #[doc=..] to /// after the next snapshot
 bitflags! {
-    #[doc = "A set of permissions for a file or directory is represented by a set of"]
+    /// A set of permissions for a file or directory is represented by a set of
     /// flags which are or'd together.
     flags FilePermission: u32 {
         const USER_READ     = 0o400,

src/libstd/io/process.rs

@@ -395,13 +395,6 @@ impl Command {
     }
 }
 
-#[cfg(stage0)]
-impl fmt::Show for Command {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for Command {
     /// Format the program and arguments of a Command for display. Any
     /// non-utf8 data is lossily converted using the utf8 replacement

src/libstd/lib.rs

@@ -109,7 +109,6 @@
 #![feature(lang_items, unsafe_destructor)]
 #![feature(slicing_syntax, unboxed_closures)]
 #![feature(old_impl_check)]
-#![cfg_attr(stage0, allow(unused_attributes))]
 
 // Don't link to std. We are std.
 #![no_std]
@@ -154,7 +153,6 @@ pub use core::finally;
 pub use core::hash;
 pub use core::intrinsics;
 pub use core::iter;
-#[cfg(stage0)] #[cfg(not(test))] pub use core::marker as kinds;
 #[cfg(not(test))] pub use core::marker;
 pub use core::mem;
 #[cfg(not(test))] pub use core::ops;
@@ -205,12 +203,14 @@ mod int_macros;
 mod uint_macros;
 
 #[path = "num/int.rs"]  pub mod int;
+#[path = "num/isize.rs"]  pub mod isize;
 #[path = "num/i8.rs"]   pub mod i8;
 #[path = "num/i16.rs"]  pub mod i16;
 #[path = "num/i32.rs"]  pub mod i32;
 #[path = "num/i64.rs"]  pub mod i64;
 
 #[path = "num/uint.rs"] pub mod uint;
+#[path = "num/usize.rs"] pub mod usize;
 #[path = "num/u8.rs"]   pub mod u8;
 #[path = "num/u16.rs"]  pub mod u16;
 #[path = "num/u32.rs"]  pub mod u32;
@@ -286,8 +286,6 @@ mod std {
     pub use vec; // used for vec![]
     pub use cell; // used for tls!
     pub use thread_local; // used for thread_local!
-    #[cfg(stage0)]
-    pub use marker as kinds;
     pub use marker;  // used for tls!
     pub use ops; // used for bitflags!
 

src/libstd/num/int.rs

@@ -8,10 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Operations and constants for architecture-sized signed integers (`int` type)
+//! Deprecated: replaced by `isize`.
+//!
+//! The rollout of the new type will gradually take place over the
+//! alpha cycle along with the development of clearer conventions
+//! around integer types.
 
-#![stable]
-#![doc(primitive = "int")]
+#![deprecated = "replaced by isize"]
 
 pub use core::int::{BITS, BYTES, MIN, MAX};
 

src/libstd/num/isize.rs

@@ -0,0 +1,22 @@
+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Operations and constants for pointer-sized signed integers (`isize` type)
+//!
+//! This type was recently added to replace `int`. The rollout of the
+//! new type will gradually take place over the alpha cycle along with
+//! the development of clearer conventions around integer types.
+
+#![stable]
+#![doc(primitive = "isize")]
+
+pub use core::isize::{BITS, BYTES, MIN, MAX};
+
+int_module! { isize }

src/libstd/num/uint.rs

@@ -8,10 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Operations and constants for architecture-sized unsigned integers (`uint` type)
+//! Deprecated: replaced by `usize`.
+//!
+//! The rollout of the new type will gradually take place over the
+//! alpha cycle along with the development of clearer conventions
+//! around integer types.
 
-#![stable]
-#![doc(primitive = "uint")]
+#![deprecated = "replaced by usize"]
 
 pub use core::uint::{BITS, BYTES, MIN, MAX};
 

src/libstd/num/usize.rs

@@ -0,0 +1,22 @@
+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Operations and constants for pointer-sized unsigned integers (`usize` type)
+//!
+//! This type was recently added to replace `uint`. The rollout of the
+//! new type will gradually take place over the alpha cycle along with
+//! the development of clearer conventions around integer types.
+
+#![stable]
+#![doc(primitive = "usize")]
+
+pub use core::usize::{BITS, BYTES, MIN, MAX};
+
+uint_module! { usize }

src/libstd/path/mod.rs

@@ -823,7 +823,6 @@ pub struct Display<'a, P:'a> {
     filename: bool
 }
 
-//NOTE(stage0): replace with deriving(Show) after snapshot
 impl<'a, P: GenericPath> fmt::Show for Display<'a, P> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::String::fmt(self, f)

src/libsyntax/ast.rs

@@ -100,7 +100,6 @@ impl Ident {
     }
 }
 
-//NOTE(stage0): remove after snapshot
 impl fmt::Show for Ident {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}#{}", self.name, self.ctxt)
@@ -1085,7 +1084,6 @@ pub enum IntTy {
     TyI64,
 }
 
-//NOTE(stage0): remove after snapshot
 impl fmt::Show for IntTy {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::String::fmt(self, f)
@@ -1127,7 +1125,6 @@ impl UintTy {
     }
 }
 
-//NOTE(stage0): remove after snapshot
 impl fmt::Show for UintTy {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::String::fmt(self, f)
@@ -1146,7 +1143,6 @@ pub enum FloatTy {
     TyF64,
 }
 
-//NOTE(stage0): remove after snapshot
 impl fmt::Show for FloatTy {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::String::fmt(self, f)

src/libsyntax/ast_map/mod.rs

@@ -32,7 +32,7 @@ use std::slice;
 
 pub mod blocks;
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, PartialEq, Show)]
 pub enum PathElem {
     PathMod(Name),
     PathName(Name)
@@ -46,13 +46,6 @@ impl PathElem {
     }
 }
 
-//NOTE(stage0): replace with deriving(Show) after snapshot
-impl fmt::Show for PathElem {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for PathElem {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let slot = token::get_name(self.name());

src/snapshots.txt

@@ -1,3 +1,12 @@
+S 2015-01-07 9e4e524
+  freebsd-x86_64 2563d33151bce1bbe08a85d712564bddc7503fc6
+  linux-i386 d8b73fc9aa3ad72ce1408a41e35d78dba10eb4d4
+  linux-x86_64 697880d3640e981bbbf23284363e8e9a158b588d
+  macos-i386 a73b1fc03e8cac747aab0aa186292bb4332a7a98
+  macos-x86_64 e4ae2670ea4ba5c2e5b4245409c9cab45c9eeb5b
+  winnt-i386 ddffa59d9605aa05e83e8f664db802da512611e9
+  winnt-x86_64 a56261ebbc580c6c14b1c1d0be25010f5201dc3f
+
 S 2015-01-06 340ac04
   freebsd-x86_64 5413b8931d7076e90c873e0cc7a43e0793c2b17a
   linux-i386 cacb8e3ad15937916e455d8f63e740c30a807b10

src/test/compile-fail/mut-pattern-mismatched.rs

@@ -13,7 +13,7 @@ fn main() {
 
     // (separate lines to ensure the spans are accurate)
 
-    // SNAP 340ac04 uncomment this after the next snapshot
+    // SNAP 9e4e524 uncomment this after the next snapshot
     // NOTE(stage0) just in case tidy doesn't check snap's in tests
     // let &_ // ~ ERROR expected `&mut isize`, found `&_`
     //    = foo;