register snapshots

diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
index d2f92d1c8dba6d0876e4a680fe2fa23d357c40bf..affa4898010063b64fb868a6f34719a5530fa639 100644 (file)
--- a/src/libcollections/slice.rs
+++ b/src/libcollections/slice.rs
@@ -98,9 +98,6 @@
 use core::marker::Sized;
 use core::mem::size_of;
 use core::mem;
-#[cfg(stage0)]
-use core::ops::{FnMut, FullRange};
-#[cfg(not(stage0))]
 use core::ops::FnMut;
 use core::option::Option::{self, Some, None};
 use core::ptr::PtrExt;
@@ -1512,9 +1509,6 @@ mod tests {
     use core::prelude::{Some, None, range, Clone};
     use core::prelude::{Iterator, IteratorExt};
     use core::prelude::{AsSlice};
-    #[cfg(stage0)]
-    use core::prelude::{Ord, FullRange};
-    #[cfg(not(stage0))]
     use core::prelude::Ord;
     use core::default::Default;
     use core::mem;

diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index ded6385d29325b90cce788211d5b820f76b405f6..43b5d14cc86e5c45d3a1f769ee7b3c38015061b4 100644 (file)
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -61,11 +61,6 @@
 use core::iter::AdditiveIterator;
 use core::iter::{Iterator, IteratorExt};
 use core::ops::Index;
-#[cfg(stage0)]
-use core::ops::FullRange as RangeFull;
-#[cfg(stage0)]
-use core::ops::FullRange;
-#[cfg(not(stage0))]
 use core::ops::RangeFull;
 use core::option::Option::{self, Some, None};
 use core::result::Result;

diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
index 4cb7b05f967a063b7d0c8fa1b88346e8e07c8e30..d0b89cfa2c360d0e9178e05ba7b5aefedd47301a 100644 (file)
--- a/src/libcollections/string.rs
+++ b/src/libcollections/string.rs
@@ -877,16 +877,6 @@ fn index(&self, index: &ops::RangeFrom<uint>) -> &str {
         &self[][*index]
     }
 }
-#[cfg(stage0)]
-#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::FullRange> for String {
-    type Output = str;
-    #[inline]
-    fn index(&self, _index: &ops::FullRange) -> &str {
-        unsafe { mem::transmute(self.vec.as_slice()) }
-    }
-}
-#[cfg(not(stage0))]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl ops::Index<ops::RangeFull> for String {
     type Output = str;
@@ -1011,8 +1001,6 @@ mod tests {
     use str::Utf8Error;
     use core::iter::repeat;
     use super::{as_string, CowString};
-    #[cfg(stage0)]
-    use core::ops::FullRange;
 
     #[test]
     fn test_as_string() {

diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index c45879ae251a52546a3330db5f5c20824827845e..82c1c37ab6abd983c76faf9d4a1886079d11868a 100644 (file)
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -1318,16 +1318,6 @@ fn index(&self, index: &ops::RangeFrom<uint>) -> &[T] {
         self.as_slice().index(index)
     }
 }
-#[cfg(stage0)]
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::Index<ops::FullRange> for Vec<T> {
-    type Output = [T];
-    #[inline]
-    fn index(&self, _index: &ops::FullRange) -> &[T] {
-        self.as_slice()
-    }
-}
-#[cfg(not(stage0))]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> ops::Index<ops::RangeFull> for Vec<T> {
     type Output = [T];
@@ -1361,16 +1351,6 @@ fn index_mut(&mut self, index: &ops::RangeFrom<uint>) -> &mut [T] {
         self.as_mut_slice().index_mut(index)
     }
 }
-#[cfg(stage0)]
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::IndexMut<ops::FullRange> for Vec<T> {
-    type Output = [T];
-    #[inline]
-    fn index_mut(&mut self, _index: &ops::FullRange) -> &mut [T] {
-        self.as_mut_slice()
-    }
-}
-#[cfg(not(stage0))]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> ops::IndexMut<ops::RangeFull> for Vec<T> {
     type Output = [T];
@@ -1934,8 +1914,6 @@ mod tests {
     use prelude::*;
     use core::mem::size_of;
     use core::iter::repeat;
-    #[cfg(stage0)]
-    use core::ops::FullRange;
     use test::Bencher;
     use super::as_vec;
 

diff --git a/src/libcore/array.rs b/src/libcore/array.rs
index ec3d9783255cb77a13c09e24d45fc606bb7c57d9..5c4567e567b0daa9f880559994473760a69bbc2b 100644 (file)
--- a/src/libcore/array.rs
+++ b/src/libcore/array.rs
@@ -20,9 +20,6 @@
 use hash::{Hash, Hasher, self};
 use iter::IntoIterator;
 use marker::Copy;
-#[cfg(stage0)]
-use ops::{Deref, FullRange};
-#[cfg(not(stage0))]
 use ops::Deref;
 use option::Option;
 use slice::{Iter, IterMut, SliceExt};

diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 2ff67ebd550abb910d5a82eec4b1ad8abb07b9a7..694888bb2bc1a9ccff96b3d84b9d0d21f4afb8f7 100644 (file)
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -38,7 +38,6 @@
 #[stable(feature = "rust1", since = "1.0.0")]
 #[doc(hidden)]
 pub mod rt {
-    #[cfg(stage0)] pub use self::v1::*;
     pub mod v1;
 }
 
@@ -191,20 +190,6 @@ pub fn new_v1(pieces: &'a [&'a str],
         }
     }
 
-    /// When using the format_args!() macro, this function is used to generate the
-    /// Arguments structure.
-    #[doc(hidden)] #[inline]
-    #[cfg(stage0)]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn new(pieces: &'a [&'a str],
-               args: &'a [ArgumentV1<'a>]) -> Arguments<'a> {
-        Arguments {
-            pieces: pieces,
-            fmt: None,
-            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
@@ -212,25 +197,6 @@ pub fn new(pieces: &'a [&'a str],
     /// created with `argumentuint`. However, failing to do so doesn't cause
     /// unsafety, but will ignore invalid .
     #[doc(hidden)] #[inline]
-    #[cfg(stage0)]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn with_placeholders(pieces: &'a [&'a str],
-                             fmt: &'a [rt::v1::Argument],
-                             args: &'a [ArgumentV1<'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]
-    #[cfg(not(stage0))]
     pub fn new_v1_formatted(pieces: &'a [&'a str],
                             args: &'a [ArgumentV1<'a>],
                             fmt: &'a [rt::v1::Argument]) -> Arguments<'a> {
@@ -684,25 +650,6 @@ fn fmt(&self, f: &mut Formatter) -> Result {
     }
 }
 
-/// This is a function which calls are emitted to by the compiler itself to
-/// create the Argument structures that are passed into the `format` function.
-#[doc(hidden)] #[inline]
-#[cfg(stage0)]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result,
-                       t: &'a T) -> ArgumentV1<'a> {
-    ArgumentV1::new(t, f)
-}
-
-/// When the compiler determines that the type of an argument *must* be a uint
-/// (such as for width and precision), then it invokes this method.
-#[doc(hidden)] #[inline]
-#[cfg(stage0)]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub fn argumentuint<'a>(s: &'a uint) -> ArgumentV1<'a> {
-    ArgumentV1::from_uint(s)
-}
-
 // Implementations of the core formatting traits
 
 macro_rules! fmt_refs {

diff --git a/src/libcore/fmt/rt/v1.rs b/src/libcore/fmt/rt/v1.rs
index f0c82759b70560ffce03c6c947b2b7c5622c9d68..0c9bb6316e0d805ecbcc08a05c1c6bb2fa67bc5e 100644 (file)
--- a/src/libcore/fmt/rt/v1.rs
+++ b/src/libcore/fmt/rt/v1.rs
@@ -16,19 +16,6 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-#[cfg(stage0)] pub use self::Position::*;
-
-#[cfg(stage0)] pub use self::Alignment::Left as AlignLeft;
-#[cfg(stage0)] pub use self::Alignment::Right as AlignRight;
-#[cfg(stage0)] pub use self::Alignment::Center as AlignCenter;
-#[cfg(stage0)] pub use self::Alignment::Unknown as AlignUnknown;
-#[cfg(stage0)] pub use self::Count::Is as CountIs;
-#[cfg(stage0)] pub use self::Count::Implied as CountImplied;
-#[cfg(stage0)] pub use self::Count::Param as CountIsParam;
-#[cfg(stage0)] pub use self::Count::NextParam as CountIsNextParam;
-#[cfg(stage0)] pub use self::Position::Next as ArgumentNext;
-#[cfg(stage0)] pub use self::Position::At as ArgumentIs;
-
 #[derive(Copy)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Argument {

diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs
index f656fd4b8b9a874f945c82de03707b799735ac97..7af94c73f324d80324fdacec9a44edd95df61698 100644 (file)
--- a/src/libcore/ops.rs
+++ b/src/libcore/ops.rs
@@ -947,28 +947,11 @@ pub trait IndexMut<Index: ?Sized> {
 }
 
 /// An unbounded range.
-#[cfg(stage0)]
-#[derive(Copy, Clone, PartialEq, Eq)]
-#[lang="full_range"]
-#[unstable(feature = "core", reason  = "may be renamed to RangeFull")]
-pub struct FullRange;
-
-/// An unbounded range.
-#[cfg(not(stage0))]
 #[derive(Copy, Clone, PartialEq, Eq)]
 #[lang="range_full"]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct RangeFull;
 
-#[cfg(stage0)]
-#[stable(feature = "rust1", since = "1.0.0")]
-impl fmt::Debug for FullRange {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt("..", fmt)
-    }
-}
-
-#[cfg(not(stage0))]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl fmt::Debug for RangeFull {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {

diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs
index 9d25317866493c65173c342d1a0b74a6f392ec7e..f4b1a0633de5ceecf1d122fdce30ffd0bec80707 100644 (file)
--- a/src/libcore/prelude.rs
+++ b/src/libcore/prelude.rs
@@ -26,9 +26,6 @@
 
 // Reexported core operators
 pub use marker::{Copy, Send, Sized, Sync};
-#[cfg(stage0)]
-pub use ops::{Drop, Fn, FnMut, FnOnce, FullRange};
-#[cfg(not(stage0))]
 pub use ops::{Drop, Fn, FnMut, FnOnce};
 
 // Reexported functions

diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index a368ddba9bc30d177d8b7913c69ee54c1d176532..a750e81bf596b7fd9aeebbec55822b0146c0956d 100644 (file)
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -43,9 +43,6 @@
 use iter::*;
 use num::Int;
 use ops::{FnMut, self, Index};
-#[cfg(stage0)]
-use ops::FullRange as RangeFull;
-#[cfg(not(stage0))]
 use ops::RangeFull;
 use option::Option;
 use option::Option::{None, Some};
@@ -769,16 +766,6 @@ fn index(&self, index: &ops::RangeFrom<uint>) -> &[T] {
     }
 }
 
-#[cfg(stage0)]
-#[unstable(feature = "core")]
-impl<'a, T> ops::Index<ops::FullRange> for Iter<'a, T> {
-    type Output = [T];
-    #[inline]
-    fn index(&self, _index: &ops::FullRange) -> &[T] {
-        self.as_slice()
-    }
-}
-#[cfg(not(stage0))]
 #[unstable(feature = "core")]
 impl<'a, T> ops::Index<RangeFull> for Iter<'a, T> {
     type Output = [T];

diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index cb7af3b3d35a1297fe73e529e2105435443b23fa..026f708b30553f229949bde7ab1df351748f12a4 100644 (file)
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -1266,16 +1266,6 @@ fn index(&self, index: &ops::RangeFrom<uint>) -> &str {
         }
     }
 
-    #[cfg(stage0)]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    impl ops::Index<ops::FullRange> for str {
-        type Output = str;
-        #[inline]
-        fn index(&self, _index: &ops::FullRange) -> &str {
-            self
-        }
-    }
-    #[cfg(not(stage0))]
     #[stable(feature = "rust1", since = "1.0.0")]
     impl ops::Index<ops::RangeFull> for str {
         type Output = str;

diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs
index 8a473ad43af19bf0bc36b51a7c167446b0ad1640..fc8d18df81523a6889f4216ccbc935fe9dbe4959 100644 (file)
--- a/src/libfmt_macros/lib.rs
+++ b/src/libfmt_macros/lib.rs
@@ -24,7 +24,6 @@
        html_root_url = "http://doc.rust-lang.org/nightly/",
        html_playground_url = "http://play.rust-lang.org/")]
 
-#![cfg_attr(stage0, feature(core))]
 #![feature(int_uint)]
 #![feature(slicing_syntax)]
 #![feature(staged_api)]

diff --git a/src/libstd/ffi/os_str.rs b/src/libstd/ffi/os_str.rs
index 18e2aa8c098a712de0c4cc00dd849224a22b0be3..61cc47375b265a84252e57793cbd511a2d7e790a 100644 (file)
--- a/src/libstd/ffi/os_str.rs
+++ b/src/libstd/ffi/os_str.rs
@@ -82,17 +82,6 @@ pub fn push_os_str(&mut self, s: &OsStr) {
     }
 }
 
-#[cfg(stage0)]
-impl ops::Index<ops::FullRange> for OsString {
-    type Output = OsStr;
-
-    #[inline]
-    fn index(&self, _index: &ops::FullRange) -> &OsStr {
-        unsafe { mem::transmute(self.inner.as_slice()) }
-    }
-}
-
-#[cfg(not(stage0))]
 impl ops::Index<ops::RangeFull> for OsString {
     type Output = OsStr;
 

diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs
index 8e86aa651967f9d4e2a281930db710e7c7d6ab2c..47f5d64e2607cb11a024c488bb9a0c5f4137fa34 100644 (file)
--- a/src/libstd/fmt.rs
+++ b/src/libstd/fmt.rs
@@ -413,10 +413,6 @@
 pub use core::fmt::Error;
 pub use core::fmt::{ArgumentV1, Arguments, write, radix, Radix, RadixFmt};
 
-#[doc(hidden)]
-#[cfg(stage0)]
-pub use core::fmt::{argument, argumentuint};
-
 /// The format function takes a precompiled format string and a list of
 /// arguments, to return the resulting formatted string.
 ///

diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index 96aebb735ef123ea1fb3f0e495778f97089f0a4c..f0981145af727d23f899d7b48ace55f06ebd0d96 100644 (file)
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -120,7 +120,7 @@
 #![feature(staged_api)]
 #![feature(unboxed_closures)]
 #![feature(unicode)]
-#![cfg_attr(not(stage0), feature(macro_reexport))]
+#![feature(macro_reexport)]
 #![cfg_attr(test, feature(test))]
 
 // Don't link to std. We are std.

diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
index b5409da9c9ca4c8c6f68ebd8bc26b499aee45c8b..74b8757f6a95326b6bd05aafbf41b98de06fd2a9 100644 (file)
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/path/mod.rs
@@ -68,8 +68,6 @@
 use iter::IteratorExt;
 use option::Option;
 use option::Option::{None, Some};
-#[cfg(stage0)]
-use ops::FullRange;
 use str;
 use str::StrExt;
 use string::{String, CowString};

diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index b524b89ef9fb27b24a18bf26bccd5c90cfcbf392..7ddd919c11e1fd858559bf78ec93edfd4e61886f 100644 (file)
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -25,8 +25,6 @@
 use iter::{Iterator, IteratorExt, Map, repeat};
 use mem;
 use option::Option::{self, Some, None};
-#[cfg(stage0)]
-use ops::FullRange;
 use result::Result::{self, Ok, Err};
 use slice::{SliceExt, SliceConcatExt};
 use str::{SplitTerminator, FromStr, StrExt};

diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs
index b3c4ffa5120e88eed17620067b13658f2c789471..2398485afefb7ab481eaa38a0c18bd59ab941691 100644 (file)
--- a/src/libstd/prelude/v1.rs
+++ b/src/libstd/prelude/v1.rs
@@ -18,10 +18,6 @@
 #[stable(feature = "rust1", since = "1.0.0")]
 #[doc(no_inline)] pub use ops::{Drop, Fn, FnMut, FnOnce};
 
-#[cfg(stage0)]
-#[unstable(feature = "std_misc")]
-#[doc(no_inline)] pub use ops::FullRange;
-
 // Reexported functions
 #[stable(feature = "rust1", since = "1.0.0")]
 #[doc(no_inline)] pub use mem::drop;

diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs
index fb40a6c8f609d37c4005d488f207f31147baf191..757aecaaaff39db28384601e4950f74e28cd4ac8 100644 (file)
--- a/src/libstd/rt/unwind.rs
+++ b/src/libstd/rt/unwind.rs
@@ -160,7 +160,7 @@ pub fn panicking() -> bool {
 // An uninlined, unmangled function upon which to slap yer breakpoints
 #[inline(never)]
 #[no_mangle]
-#[cfg_attr(not(stage0), allow(private_no_mangle_fns))]
+#[allow(private_no_mangle_fns)]
 fn rust_panic(cause: Box<Any + Send>) -> ! {
     rtdebug!("begin_unwind()");
 
@@ -238,7 +238,7 @@ fn __gcc_personality_v0(version: c_int,
 
     #[lang="eh_personality"]
     #[no_mangle] // referenced from rust_try.ll
-    #[cfg_attr(not(stage0), allow(private_no_mangle_fns))]
+    #[allow(private_no_mangle_fns)]
     extern fn rust_eh_personality(
         version: c_int,
         actions: uw::_Unwind_Action,

diff --git a/src/libstd/sys/common/wtf8.rs b/src/libstd/sys/common/wtf8.rs
index fdcb0c19f30afbb1a59e0ecf3e481975cd943213..1a898e73cda879e6c7fb2c01e5ea4e0b90c8cc9a 100644 (file)
--- a/src/libstd/sys/common/wtf8.rs
+++ b/src/libstd/sys/common/wtf8.rs
@@ -680,17 +680,6 @@ fn index(&self, range: &ops::RangeTo<usize>) -> &Wtf8 {
     }
 }
 
-#[cfg(stage0)]
-impl ops::Index<ops::FullRange> for Wtf8 {
-    type Output = Wtf8;
-
-    #[inline]
-    fn index(&self, _range: &ops::FullRange) -> &Wtf8 {
-        self
-    }
-}
-
-#[cfg(not(stage0))]
 impl ops::Index<ops::RangeFull> for Wtf8 {
     type Output = Wtf8;
 

diff --git a/src/snapshots.txt b/src/snapshots.txt
index 3406a91e718b066db72da294af01b7bb0edf9200..058e2e6bf7f28680c60817ed391389e5590bb4a5 100644 (file)
--- a/src/snapshots.txt
+++ b/src/snapshots.txt
@@ -1,3 +1,12 @@
+S 2015-01-31 474b324
+  freebsd-x86_64 c5b55eb488790ff8425d74afa3b37c49517bc55f
+  linux-i386 319f2f3573c058cb2c4dfc75faaf8ea3ae86ef11
+  linux-x86_64 7e71108be890adfecc7644ab6ad183e8a657dc97
+  macos-i386 b0b2676681c6d8ec8cb85700428555761c7bdbb8
+  macos-x86_64 381dd1587920388e2f71e120a1eabac2648d9672
+  winnt-i386 5f99509f88355437824a746f7f90fc22233edb9b
+  winnt-x86_64 382aa20518b1a19d374f06a038025619ba00b77d
+
 S 2015-01-28 a45e117
   freebsd-x86_64 08a3ce7331fd1a52466acc0598cf745a009f86f6
   linux-i386 66e36a3461c12e2102a7f7f241d1b0e242c704d0