Register new snapshot 12e0f72

12 files changed, 8 insertions, 100 deletions

diff --git a/src/libcore/char.rs b/src/libcore/char.rs
index 71144095f47..63ffc4a046f 100644
--- a/src/libcore/char.rs
+++ b/src/libcore/char.rs
@@ -19,9 +19,6 @@ use mem::transmute;
 use option::{None, Option, Some};
 use iter::range_step;
 
-#[cfg(stage0)]
-use iter::Iterator; // NOTE(stage0): Remove after snapshot.
-
 // UTF-8 ranges and tags for encoding characters
 static TAG_CONT: u8    = 0b1000_0000u8;
 static TAG_TWO_B: u8   = 0b1100_0000u8;
diff --git a/src/libcore/failure.rs b/src/libcore/failure.rs
index f5cfa2611d5..e764ae17500 100644
--- a/src/libcore/failure.rs
+++ b/src/libcore/failure.rs
@@ -33,29 +33,6 @@
 use fmt;
 use intrinsics;
 
-#[cfg(stage0)]
-#[cold] #[inline(never)] // this is the slow path, always
-#[lang="fail_"]
-fn fail_(expr: &'static str, file: &'static str, line: uint) -> ! {
-    format_args!(|args| -> () {
-        begin_unwind(args, &(file, line));
-    }, "{}", expr);
-
-    unsafe { intrinsics::abort() }
-}
-
-#[cfg(stage0)]
-#[cold]
-#[lang="fail_bounds_check"]
-fn fail_bounds_check(file: &'static str, line: uint,
-                     index: uint, len: uint) -> ! {
-    format_args!(|args| -> () {
-        begin_unwind(args, &(file, line));
-    }, "index out of bounds: the len is {} but the index is {}", len, index);
-    unsafe { intrinsics::abort() }
-}
-
-#[cfg(not(stage0))]
 #[cold] #[inline(never)] // this is the slow path, always
 #[lang="fail_"]
 fn fail_(expr_file_line: &(&'static str, &'static str, uint)) -> ! {
@@ -68,7 +45,6 @@ fn fail_(expr_file_line: &(&'static str, &'static str, uint)) -> ! {
     unsafe { intrinsics::abort() }
 }
 
-#[cfg(not(stage0))]
 #[cold] #[inline(never)]
 #[lang="fail_bounds_check"]
 fn fail_bounds_check(file_line: &(&'static str, uint),
diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs
index 88702e59e30..1bfa5168cf7 100644
--- a/src/libcore/fmt/float.rs
+++ b/src/libcore/fmt/float.rs
@@ -21,11 +21,6 @@ use slice::{ImmutableVector, MutableVector};
 use slice;
 use str::StrSlice;
 
-#[cfg(stage0)]
-use iter::Iterator;         // NOTE(stage0): Remove after snapshot.
-#[cfg(stage0)]
-use option::{Some, None};   // NOTE(stage0): Remove after snapshot.
-
 /// A flag that specifies whether to use exponential (scientific) notation.
 pub enum ExponentFormat {
     /// Do not use exponential notation.
diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs
index 99920dc7881..bba3e4cb9af 100644
--- a/src/libcore/fmt/num.rs
+++ b/src/libcore/fmt/num.rs
@@ -20,11 +20,6 @@ use iter::DoubleEndedIterator;
 use num::{Int, cast, zero};
 use slice::{ImmutableVector, MutableVector};
 
-#[cfg(stage0)]
-use iter::Iterator;         // NOTE(stage0): Remove after snapshot.
-#[cfg(stage0)]
-use option::{Some, None};   // NOTE(stage0): Remove after snapshot.
-
 /// A type that represents a specific radix
 #[doc(hidden)]
 trait GenericRadix {
diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs
index 839243970ac..23577dd29e0 100644
--- a/src/libcore/ops.rs
+++ b/src/libcore/ops.rs
@@ -771,7 +771,6 @@ pub trait FnOnce<Args,Result> {
 
 macro_rules! def_fn_mut(
     ($($args:ident)*) => (
-        #[cfg(not(stage0))]
         impl<Result$(,$args)*>
         FnMut<($($args,)*),Result>
         for extern "Rust" fn($($args: $args,)*) -> Result {
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index 4921802ba73..eb9bede85d8 100644
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -95,9 +95,6 @@ use option::{Some, None, Option};
 
 use cmp::{PartialEq, Eq, PartialOrd, Equiv, Ordering, Less, Equal, Greater};
 
-#[cfg(stage0)]
-use iter::Iterator; // NOTE(stage0): Remove after snapshot.
-
 pub use intrinsics::copy_memory;
 pub use intrinsics::copy_nonoverlapping_memory;
 pub use intrinsics::set_memory;
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index 5eb46368790..c1166a7621e 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -1030,9 +1030,6 @@ pub mod traits {
     use option::{Option, Some};
     use str::{Str, StrSlice, eq_slice};
 
-    #[cfg(stage0)]
-    use option::None;   // NOTE(stage0): Remove after snapshot.
-
     impl<'a> Ord for &'a str {
         #[inline]
         fn cmp(&self, other: & &'a str) -> Ordering {
diff --git a/src/librustrt/unwind.rs b/src/librustrt/unwind.rs
index 117f680011e..79f83df5be8 100644
--- a/src/librustrt/unwind.rs
+++ b/src/librustrt/unwind.rs
@@ -523,22 +523,6 @@ pub fn begin_unwind_fmt(msg: &fmt::Arguments, file_line: &(&'static str, uint))
 }
 
 /// This is the entry point of unwinding for fail!() and assert!().
-#[cfg(stage0)]
-#[inline(never)] #[cold] // avoid code bloat at the call sites as much as possible
-pub fn begin_unwind<M: Any + Send>(msg: M, file: &'static str, line: uint) -> ! {
-    // Note that this should be the only allocation performed in this code path.
-    // Currently this means that fail!() on OOM will invoke this code path,
-    // but then again we're not really ready for failing on OOM anyway. If
-    // we do start doing this, then we should propagate this allocation to
-    // be performed in the parent of this task instead of the task that's
-    // failing.
-
-    // see below for why we do the `Any` coercion here.
-    begin_unwind_inner(box msg, &(file, line))
-}
-
-/// This is the entry point of unwinding for fail!() and assert!().
-#[cfg(not(stage0))]
 #[inline(never)] #[cold] // avoid code bloat at the call sites as much as possible
 pub fn begin_unwind<M: Any + Send>(msg: M, file_line: &(&'static str, uint)) -> ! {
     // Note that this should be the only allocation performed in this code path.
diff --git a/src/libstd/io/tempfile.rs b/src/libstd/io/tempfile.rs
index 1d53ed81437..2faa23a6aa0 100644
--- a/src/libstd/io/tempfile.rs
+++ b/src/libstd/io/tempfile.rs
@@ -21,9 +21,6 @@ use path::{Path, GenericPath};
 use result::{Ok, Err};
 use sync::atomic;
 
-#[cfg(stage0)]
-use iter::Iterator; // NOTE(stage0): Remove after snapshot.
-
 /// A wrapper for a path to temporary directory implementing automatic
 /// scope-based deletion.
 pub struct TempDir {
diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs
index 3184c151bd2..f2d7fb0cea6 100644
--- a/src/libstd/macros.rs
+++ b/src/libstd/macros.rs
@@ -37,7 +37,6 @@
 /// fail!("this is a {} {message}", "fancy", message = "message");
 /// ```
 #[macro_export]
-#[cfg(not(stage0))]
 macro_rules! fail(
     () => ({
         fail!("explicit failure")
@@ -68,39 +67,6 @@ macro_rules! fail(
     });
 )
 
-#[macro_export]
-#[cfg(stage0)]
-macro_rules! fail(
-    () => ({
-        fail!("explicit failure")
-    });
-    ($msg:expr) => ({
-        // static requires less code at runtime, more constant data
-        static FILE_LINE: (&'static str, uint) = (file!(), line!());
-        let (file, line) = FILE_LINE;
-        ::std::rt::begin_unwind($msg, file, line)
-    });
-    ($fmt:expr, $($arg:tt)*) => ({
-        // a closure can't have return type !, so we need a full
-        // function to pass to format_args!, *and* we need the
-        // file and line numbers right here; so an inner bare fn
-        // is our only choice.
-        //
-        // LLVM doesn't tend to inline this, presumably because begin_unwind_fmt
-        // is #[cold] and #[inline(never)] and because this is flagged as cold
-        // as returning !. We really do want this to be inlined, however,
-        // because it's just a tiny wrapper. Small wins (156K to 149K in size)
-        // were seen when forcing this to be inlined, and that number just goes
-        // up with the number of calls to fail!()
-        #[inline(always)]
-        fn run_fmt(fmt: &::std::fmt::Arguments) -> ! {
-            static FILE_LINE: (&'static str, uint) = (file!(), line!());
-            ::std::rt::begin_unwind_fmt(fmt, &FILE_LINE)
-        }
-        format_args!(run_fmt, $fmt, $($arg)*)
-    });
-)
-
 /// Ensure that a boolean expression is `true` at runtime.
 ///
 /// This will invoke the `fail!` macro if the provided expression cannot be
diff --git a/src/libunicode/normalize.rs b/src/libunicode/normalize.rs
index df0be09aea1..ec31181e8a7 100644
--- a/src/libunicode/normalize.rs
+++ b/src/libunicode/normalize.rs
@@ -39,9 +39,6 @@ pub fn decompose_canonical(c: char, i: |char|) { d(c, i, false); }
 pub fn decompose_compatible(c: char, i: |char|) { d(c, i, true); }
 
 fn d(c: char, i: |char|, k: bool) {
-    #[cfg(stage0)]
-    use core::iter::Iterator;
-
     // 7-bit ASCII never decomposes
     if c <= '\x7f' { i(c); return; }
 
diff --git a/src/snapshots.txt b/src/snapshots.txt
index 623f8f8bcc0..a07be82d58e 100644
--- a/src/snapshots.txt
+++ b/src/snapshots.txt
@@ -1,3 +1,11 @@
+S 2014-08-07 12e0f72
+  freebsd-x86_64 e55055a876ebbde0d3ed3bcb97579afab9264def
+  linux-i386 2665e45879f2ef77ce0c9015f971642fe424ac33
+  linux-x86_64 51ed1f4cf0707585a136bb149a443394067c074c
+  macos-i386 78f1996954a6e0718d684a3756b4870a6f8771ee
+  macos-x86_64 216f46f65866207a9f41c3ed654f5c1e085cb7f3
+  winnt-i386 95a9b8a8bf587761ae954392aee2ccee3758a533
+
 S 2014-07-17 9fc8394
   freebsd-x86_64 5a4b645e2b42ae06224cc679d4a43b3d89be1482
   linux-i386 a5e1bb723020ac35173d49600e76b0935e257a6a