---

yaml
---
r: 158706
b: refs/heads/snap-stage3
c: 5c1fd5f
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 0b48001c28329392b26961eaf1c3ed293a352d6f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 0f610f3c14f25bb51a865d04a42a4cbb62b8815f
+refs/heads/snap-stage3: 5c1fd5f8b7351085765217b198c6d5a8c0026b74
 refs/heads/try: f58aad6dce273570fb130b4df008ef9acd5a5be2
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/mk/main.mk

@@ -148,12 +148,13 @@ endif
 # libraries, so in the interest of space, prefer dynamic linking throughout the
 # compilation process.
 #
-# Note though that these flags are omitted for stage2+. This means that the
-# snapshot will be generated with a statically linked rustc so we only have to
-# worry about the distribution of one file (with its native dynamic
+# Note though that these flags are omitted for the *bins* in stage2+. This means
+# that the snapshot will be generated with a statically linked rustc so we only
+# have to worry about the distribution of one file (with its native dynamic
 # dependencies)
 RUSTFLAGS_STAGE0 += -C prefer-dynamic
 RUSTFLAGS_STAGE1 += -C prefer-dynamic
+RUST_LIB_FLAGS_ST2 += -C prefer-dynamic
 
 # Landing pads require a lot of codegen. We can get through bootstrapping faster
 # by not emitting them.

branches/snap-stage3/mk/target.mk

@@ -17,9 +17,9 @@ export CFG_COMPILER_HOST_TRIPLE
 # code, make sure that these common warnings are denied by default. These can
 # be overridden during development temporarily. For stage0, we allow warnings
 # which may be bugs in stage0 (should be fixed in stage1+)
-WFLAGS_ST0 = -W warnings
-WFLAGS_ST1 = -D warnings
-WFLAGS_ST2 = -D warnings
+RUST_LIB_FLAGS_ST0 += -W warnings
+RUST_LIB_FLAGS_ST1 += -D warnings
+RUST_LIB_FLAGS_ST2 += -D warnings
 
 # Macro that generates the full list of dependencies for a crate at a particular
 # stage/target/host tuple.
@@ -80,7 +80,7 @@ $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4): \
 	$$(call REMOVE_ALL_OLD_GLOB_MATCHES, \
 	    $$(dir $$@)$$(call CFG_RLIB_GLOB,$(4)))
 	$$(STAGE$(1)_T_$(2)_H_$(3)) \
-		$$(WFLAGS_ST$(1)) \
+		$$(RUST_LIB_FLAGS_ST$(1)) \
 		-L "$$(RT_OUTPUT_DIR_$(2))" \
 		-L "$$(LLVM_LIBDIR_$(2))" \
 		-L "$$(dir $$(LLVM_STDCPP_LOCATION_$(2)))" \

branches/snap-stage3/src/libcore/fmt/mod.rs

@@ -250,37 +250,6 @@ pub trait UpperExp for Sized? {
     fn fmt(&self, &mut Formatter) -> Result;
 }
 
-// NOTE(stage0): Remove macro after next snapshot
-#[cfg(stage0)]
-macro_rules! uniform_fn_call_workaround {
-    ($( $name: ident, $trait_: ident; )*) => {
-        $(
-            #[doc(hidden)]
-            pub fn $name<Sized? T: $trait_>(x: &T, fmt: &mut Formatter) -> Result {
-                x.fmt(fmt)
-            }
-            )*
-    }
-}
-// NOTE(stage0): Remove macro after next snapshot
-#[cfg(stage0)]
-uniform_fn_call_workaround! {
-    secret_show, Show;
-    secret_bool, Bool;
-    secret_char, Char;
-    secret_signed, Signed;
-    secret_unsigned, Unsigned;
-    secret_octal, Octal;
-    secret_binary, Binary;
-    secret_lower_hex, LowerHex;
-    secret_upper_hex, UpperHex;
-    secret_string, String;
-    secret_pointer, Pointer;
-    secret_float, Float;
-    secret_lower_exp, LowerExp;
-    secret_upper_exp, UpperExp;
-}
-
 static DEFAULT_ARGUMENT: rt::Argument<'static> = rt::Argument {
     position: rt::ArgumentNext,
     format: rt::FormatSpec {
@@ -570,33 +539,13 @@ pub fn argument<'a, T>(f: extern "Rust" fn(&T, &mut Formatter) -> Result,
 
 /// When the compiler determines that the type of an argument *must* be a string
 /// (such as for select), then it invokes this method.
-// NOTE(stage0): remove function after a snapshot
-#[cfg(stage0)]
-#[doc(hidden)] #[inline]
-pub fn argumentstr<'a>(s: &'a &str) -> Argument<'a> {
-    argument(secret_string, s)
-}
-
-/// When the compiler determines that the type of an argument *must* be a string
-/// (such as for select), then it invokes this method.
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 #[doc(hidden)] #[inline]
 pub fn argumentstr<'a>(s: &'a &str) -> Argument<'a> {
     argument(String::fmt, s)
 }
 
 /// When the compiler determines that the type of an argument *must* be a uint
 /// (such as for plural), then it invokes this method.
-// NOTE(stage0): remove function after a snapshot
-#[cfg(stage0)]
-#[doc(hidden)] #[inline]
-pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> {
-    argument(secret_unsigned, s)
-}
-
-/// When the compiler determines that the type of an argument *must* be a uint
-/// (such as for plural), then it invokes this method.
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 #[doc(hidden)] #[inline]
 pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> {
     argument(Unsigned::fmt, s)
@@ -614,15 +563,6 @@ impl<'a> Show for &'a Show+'a {
     fn fmt(&self, f: &mut Formatter) -> Result { (*self).fmt(f) }
 }
 
-// NOTE(stage0): remove impl after a snapshot
-#[cfg(stage0)]
-impl Bool for bool {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        secret_string(&(if *self {"true"} else {"false"}), f)
-    }
-}
-
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 impl Bool for bool {
     fn fmt(&self, f: &mut Formatter) -> Result {
         String::fmt(if *self { "true" } else { "false" }, f)
@@ -641,20 +581,6 @@ impl String for str {
     }
 }
 
-// NOTE(stage0): remove impl after a snapshot
-#[cfg(stage0)]
-impl Char for char {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        use char::Char;
-
-        let mut utf8 = [0u8, ..4];
-        let amt = self.encode_utf8(utf8).unwrap_or(0);
-        let s: &str = unsafe { mem::transmute(utf8[..amt]) };
-        secret_string(&s, f)
-    }
-}
-
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 impl Char for char {
     fn fmt(&self, f: &mut Formatter) -> Result {
         use char::Char;
@@ -666,62 +592,25 @@ impl Char for char {
     }
 }
 
-// NOTE(stage0): remove impl after a snapshot
-#[cfg(stage0)]
-impl<T> Pointer for *const T {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        f.flags |= 1 << (rt::FlagAlternate as uint);
-        secret_lower_hex::<uint>(&(*self as uint), f)
-    }
-}
-
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 impl<T> Pointer for *const T {
     fn fmt(&self, f: &mut Formatter) -> Result {
         f.flags |= 1 << (rt::FlagAlternate as uint);
         LowerHex::fmt(&(*self as uint), f)
     }
 }
 
-// NOTE(stage0): remove impl after a snapshot
-#[cfg(stage0)]
-impl<T> Pointer for *mut T {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        secret_pointer::<*const T>(&(*self as *const T), f)
-    }
-}
-
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 impl<T> Pointer for *mut T {
     fn fmt(&self, f: &mut Formatter) -> Result {
         Pointer::fmt(&(*self as *const T), f)
     }
 }
 
-// NOTE(stage0): remove impl after a snapshot
-#[cfg(stage0)]
-impl<'a, T> Pointer for &'a T {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        secret_pointer::<*const T>(&(&**self as *const T), f)
-    }
-}
-
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 impl<'a, T> Pointer for &'a T {
     fn fmt(&self, f: &mut Formatter) -> Result {
         Pointer::fmt(&(*self as *const T), f)
     }
 }
 
-// NOTE(stage0): remove impl after a snapshot
-#[cfg(stage0)]
-impl<'a, T> Pointer for &'a mut T {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        secret_pointer::<*const T>(&(&**self as *const T), f)
-    }
-}
-
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 impl<'a, T> Pointer for &'a mut T {
     fn fmt(&self, f: &mut Formatter) -> Result {
         Pointer::fmt(&(&**self as *const T), f)
@@ -797,65 +686,23 @@ floating!(f64)
 
 // Implementation of Show for various core types
 
-// NOTE(stage0): remove macro after a snapshot
-#[cfg(stage0)]
-macro_rules! delegate(($ty:ty to $other:ident) => {
-    impl Show for $ty {
-        fn fmt(&self, f: &mut Formatter) -> Result {
-            (concat_idents!(secret_, $other)(self, f))
-        }
-    }
-})
-
-// NOTE(stage0): remove these macros after a snapshot
-#[cfg(stage0)]
-delegate!(str to string)
-#[cfg(stage0)]
-delegate!(bool to bool)
-#[cfg(stage0)]
-delegate!(char to char)
-#[cfg(stage0)]
-delegate!(f32 to float)
-#[cfg(stage0)]
-delegate!(f64 to float)
-
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 macro_rules! delegate(($ty:ty to $other:ident) => {
     impl Show for $ty {
         fn fmt(&self, f: &mut Formatter) -> Result {
             $other::fmt(self, f)
         }
     }
 })
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 delegate!(str to String)
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 delegate!(bool to Bool)
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 delegate!(char to Char)
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 delegate!(f32 to Float)
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 delegate!(f64 to Float)
 
-// NOTE(stage0): remove impl after a snapshot
-#[cfg(stage0)]
-impl<T> Show for *const T {
-    fn fmt(&self, f: &mut Formatter) -> Result { secret_pointer(self, f) }
-}
-
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 impl<T> Show for *const T {
     fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) }
 }
 
-// NOTE(stage0): remove impl after a snapshot
-#[cfg(stage0)]
-impl<T> Show for *mut T {
-    fn fmt(&self, f: &mut Formatter) -> Result { secret_pointer(self, f) }
-}
-
-#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 impl<T> Show for *mut T {
     fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) }
 }

branches/snap-stage3/src/libcore/intrinsics.rs

@@ -171,7 +171,6 @@ extern "rust-intrinsic" {
     /// with optimization of surrounding code and reduce performance. It should
     /// not be used if the invariant can be discovered by the optimizer on its
     /// own, or if it does not enable any significant optimizations.
-    #[cfg(not(stage0))]
     pub fn assume(b: bool);
 
     /// Execute a breakpoint trap, for inspection by a debugger.

branches/snap-stage3/src/libcore/ops.rs

@@ -849,34 +849,30 @@ pub trait DerefMut<Sized? Result>: Deref<Result> {
 #[lang="fn"]
 pub trait Fn<Args,Result> {
     /// This is called when the call operator is used.
-    #[rust_call_abi_hack]
-    fn call(&self, args: Args) -> Result;
+    extern "rust-call" fn call(&self, args: Args) -> Result;
 }
 
 /// A version of the call operator that takes a mutable receiver.
 #[lang="fn_mut"]
 pub trait FnMut<Args,Result> {
     /// This is called when the call operator is used.
-    #[rust_call_abi_hack]
-    fn call_mut(&mut self, args: Args) -> Result;
+    extern "rust-call" fn call_mut(&mut self, args: Args) -> Result;
 }
 
 /// A version of the call operator that takes a by-value receiver.
 #[lang="fn_once"]
 pub trait FnOnce<Args,Result> {
     /// This is called when the call operator is used.
-    #[rust_call_abi_hack]
-    fn call_once(self, args: Args) -> Result;
+    extern "rust-call" fn call_once(self, args: Args) -> Result;
 }
 
 macro_rules! def_fn_mut(
     ($($args:ident)*) => (
         impl<Result$(,$args)*>
         FnMut<($($args,)*),Result>
         for extern "Rust" fn($($args: $args,)*) -> Result {
-            #[rust_call_abi_hack]
             #[allow(non_snake_case)]
-            fn call_mut(&mut self, args: ($($args,)*)) -> Result {
+            extern "rust-call" fn call_mut(&mut self, args: ($($args,)*)) -> Result {
                 let ($($args,)*) = args;
                 (*self)($($args,)*)
             }