Register new snapshots

Author: alexcrichton

src/liballoc/heap.rs

@@ -133,14 +133,7 @@ unsafe fn exchange_malloc(size: uint, align: uint) -> *mut u8 {
     }
 }
 
-#[cfg(not(test), stage0)]
-#[lang="exchange_free"]
-#[inline]
-unsafe fn exchange_free(ptr: *mut u8) {
-    deallocate(ptr, 0, 8);
-}
-
-#[cfg(not(test), not(stage0))]
+#[cfg(not(test))]
 #[lang="exchange_free"]
 #[inline]
 unsafe fn exchange_free(ptr: *mut u8, size: uint, align: uint) {

src/libcore/failure.rs

@@ -30,12 +30,10 @@
 
 use fmt;
 use intrinsics;
-#[cfg(not(test), stage0)]
-use str::raw::c_str_to_static_slice;
 
 #[cold] #[inline(never)] // this is the slow path, always
 #[lang="fail_"]
-#[cfg(not(test), not(stage0))]
+#[cfg(not(test))]
 fn fail_(expr: &'static str, file: &'static str, line: uint) -> ! {
     format_args!(|args| -> () {
         begin_unwind(args, file, line);
@@ -44,24 +42,9 @@ fn fail_(expr: &'static str, file: &'static str, line: uint) -> ! {
     unsafe { intrinsics::abort() }
 }
 
-#[cold] #[inline(never)] // this is the slow path, always
-#[lang="fail_"]
-#[cfg(not(test), stage0)]
-fn fail_(expr: *u8, file: *u8, line: uint) -> ! {
-    unsafe {
-        let expr = c_str_to_static_slice(expr as *i8);
-        let file = c_str_to_static_slice(file as *i8);
-        format_args!(|args| -> () {
-            begin_unwind(args, file, line);
-        }, "{}", expr);
-
-        intrinsics::abort()
-    }
-}
-
 #[cold]
 #[lang="fail_bounds_check"]
-#[cfg(not(test), not(stage0))]
+#[cfg(not(test))]
 fn fail_bounds_check(file: &'static str, line: uint,
                      index: uint, len: uint) -> ! {
     format_args!(|args| -> () {
@@ -70,28 +53,9 @@ fn fail_bounds_check(file: &'static str, line: uint,
     unsafe { intrinsics::abort() }
 }
 
-#[cold]
-#[lang="fail_bounds_check"]
-#[cfg(not(test), stage0)]
-fn fail_bounds_check(file: *u8, line: uint, index: uint, len: uint) -> ! {
-    let file = unsafe { c_str_to_static_slice(file as *i8) };
-    format_args!(|args| -> () {
-        begin_unwind(args, file, line);
-    }, "index out of bounds: the len is {} but the index is {}", len, index);
-    unsafe { intrinsics::abort() }
-}
-
 #[cold]
 pub fn begin_unwind(fmt: &fmt::Arguments, file: &'static str, line: uint) -> ! {
     #[allow(ctypes)]
-    #[cfg(stage0)]
-    extern {
-        #[link_name = "rust_begin_unwind"]
-        fn begin_unwind(fmt: &fmt::Arguments, file: &'static str,
-                        line: uint) -> !;
-    }
-    #[allow(ctypes)]
-    #[cfg(not(stage0))]
     extern {
         #[lang = "begin_unwind"]
         fn begin_unwind(fmt: &fmt::Arguments, file: &'static str,

src/libstd/fmt.rs

@@ -492,10 +492,6 @@ will look like `"\\{"`.
 
 use io::Writer;
 use io;
-#[cfg(stage0)]
-use option::None;
-#[cfg(stage0)]
-use repr;
 use result::{Ok, Err};
 use str::{Str, StrAllocating};
 use str;
@@ -524,21 +520,6 @@ pub use core::fmt::{secret_float, secret_upper_exp, secret_lower_exp};
 #[doc(hidden)]
 pub use core::fmt::{secret_pointer};
 
-#[doc(hidden)]
-#[cfg(stage0)]
-pub fn secret_poly<T: Poly>(x: &T, fmt: &mut Formatter) -> Result {
-    // FIXME #11938 - UFCS would make us able call the this method
-    //                directly Poly::fmt(x, fmt).
-    x.fmt(fmt)
-}
-
-/// Format trait for the `?` character
-#[cfg(stage0)]
-pub trait Poly {
-    /// Formats the value using the given formatter.
-    fn fmt(&self, &mut Formatter) -> Result;
-}
-
 /// The format function takes a precompiled format string and a list of
 /// arguments, to return the resulting formatted string.
 ///
@@ -562,27 +543,6 @@ pub fn format(args: &Arguments) -> string::String{
     str::from_utf8(output.unwrap().as_slice()).unwrap().into_string()
 }
 
-#[cfg(stage0)]
-impl<T> Poly for T {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        match (f.width, f.precision) {
-            (None, None) => {
-                match repr::write_repr(f, self) {
-                    Ok(()) => Ok(()),
-                    Err(..) => Err(WriteError),
-                }
-            }
-
-            // If we have a specified width for formatting, then we have to make
-            // this allocation of a new string
-            _ => {
-                let s = repr::repr_to_str(self);
-                f.pad(s.as_slice())
-            }
-        }
-    }
-}
-
 impl<'a> Writer for Formatter<'a> {
     fn write(&mut self, b: &[u8]) -> io::IoResult<()> {
         match (*self).write(b) {

src/libstd/lib.rs

@@ -241,13 +241,6 @@ pub mod path;
 pub mod fmt;
 pub mod cleanup;
 
-/* Unsupported interfaces */
-
-#[unstable]
-pub mod repr;
-#[unstable]
-pub mod reflect;
-
 // Private APIs
 #[unstable]
 pub mod unstable;