register snapshots

Author: Jorge Aparicio

src/libcollections/slice.rs

@@ -98,9 +98,6 @@ use core::iter::{range_step, MultiplicativeIterator};
 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;

src/libcollections/str.rs

@@ -61,11 +61,6 @@ use core::clone::Clone;
 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;

src/libcollections/string.rs

@@ -877,16 +877,6 @@ impl ops::Index<ops::RangeFrom<uint>> for String {
         &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() {

src/libcollections/vec.rs

@@ -1318,16 +1318,6 @@ impl<T> ops::Index<ops::RangeFrom<uint>> for Vec<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 @@ impl<T> ops::IndexMut<ops::RangeFrom<uint>> for Vec<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;
 

src/libcore/array.rs

@@ -20,9 +20,6 @@ use fmt;
 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};

src/libcore/fmt/mod.rs

@@ -38,7 +38,6 @@ mod float;
 #[stable(feature = "rust1", since = "1.0.0")]
 #[doc(hidden)]
 pub mod rt {
-    #[cfg(stage0)] pub use self::v1::*;
     pub mod v1;
 }
 
@@ -191,46 +190,13 @@ impl<'a> Arguments<'a> {
         }
     }
 
-    /// 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
     /// `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(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 @@ impl Display for Error {
     }
 }
 
-/// 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 {

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 {

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 {

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

src/libcore/slice.rs

@@ -43,9 +43,6 @@ use default::Default;
 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 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, 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];