---

yaml
---
r: 158707
b: refs/heads/snap-stage3
c: 4af52ee
h: refs/heads/master
i:
  158705: c4f7d0a
  158703: ddfd100
v: v3

Author: nikomatsakis

[refs]

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

branches/snap-stage3/src/compiletest/runtest.rs

@@ -444,7 +444,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                 //waiting 1 second for gdbserver start
                 timer::sleep(Duration::milliseconds(1000));
                 let result = task::try(proc() {
-                    tcp::TcpStream::connect("127.0.0.1:5039").unwrap();
+                    tcp::TcpStream::connect("127.0.0.1", 5039).unwrap();
                 });
                 if result.is_err() {
                     continue;

branches/snap-stage3/src/libarena/lib.rs

@@ -132,7 +132,7 @@ impl Drop for Arena {
 
 #[inline]
 fn round_up(base: uint, align: uint) -> uint {
-    (base.checked_add(&(align - 1))).unwrap() & !(&(align - 1))
+    (base.checked_add(&(align - 1))).unwrap() & !(align - 1)
 }
 
 // Walk down a chunk, running the destructors for any objects stored

branches/snap-stage3/src/libcollections/vec.rs

@@ -919,7 +919,7 @@ impl<T> Vec<T> {
     ///
     /// ```
     /// let mut vec = vec![1i, 2, 3, 4];
-    /// vec.retain(|x| x%2 == 0);
+    /// vec.retain(|&x| x%2 == 0);
     /// assert_eq!(vec, vec![2, 4]);
     /// ```
     #[unstable = "the closure argument may become an unboxed closure"]

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

@@ -250,6 +250,37 @@ 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 {
@@ -539,13 +570,33 @@ 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)
@@ -563,6 +614,15 @@ 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)
@@ -581,6 +641,20 @@ 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;
@@ -592,25 +666,62 @@ 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)
@@ -686,23 +797,65 @@ 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,6 +171,7 @@ 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,30 +849,34 @@ pub trait DerefMut<Sized? Result>: Deref<Result> {
 #[lang="fn"]
 pub trait Fn<Args,Result> {
     /// This is called when the call operator is used.
-    extern "rust-call" fn call(&self, args: Args) -> Result;
+    #[rust_call_abi_hack]
+    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.
-    extern "rust-call" fn call_mut(&mut self, args: Args) -> Result;
+    #[rust_call_abi_hack]
+    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.
-    extern "rust-call" fn call_once(self, args: Args) -> Result;
+    #[rust_call_abi_hack]
+    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)]
-            extern "rust-call" fn call_mut(&mut self, args: ($($args,)*)) -> Result {
+            fn call_mut(&mut self, args: ($($args,)*)) -> Result {
                 let ($($args,)*) = args;
                 (*self)($($args,)*)
             }

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

@@ -787,8 +787,8 @@ impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V> {
     /// use std::uint;
     ///
     /// let v = vec!(1u, 2u);
-    /// let res: Option<Vec<uint>> = v.iter().map(|x: &uint|
-    ///     if *x == uint::MAX { None }
+    /// let res: Option<Vec<uint>> = v.iter().map(|&x: &uint|
+    ///     if x == uint::MAX { None }
     ///     else { Some(x + 1) }
     /// ).collect();
     /// assert!(res == Some(vec!(2u, 3u)));

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

@@ -33,6 +33,49 @@
 use fmt;
 use intrinsics;
 
+// NOTE(stage0): remove after a snapshot
+#[cfg(stage0)]
+#[cold] #[inline(never)] // this is the slow path, always
+#[lang="fail"]
+pub fn panic(expr_file_line: &(&'static str, &'static str, uint)) -> ! {
+    let (expr, file, line) = *expr_file_line;
+    let ref file_line = (file, line);
+    format_args!(|args| -> () {
+        panic_fmt(args, file_line);
+    }, "{}", expr);
+
+    unsafe { intrinsics::abort() }
+}
+
+// NOTE(stage0): remove after a snapshot
+#[cfg(stage0)]
+#[cold] #[inline(never)]
+#[lang="fail_bounds_check"]
+fn panic_bounds_check(file_line: &(&'static str, uint),
+                     index: uint, len: uint) -> ! {
+    format_args!(|args| -> () {
+        panic_fmt(args, file_line);
+    }, "index out of bounds: the len is {} but the index is {}", len, index);
+    unsafe { intrinsics::abort() }
+}
+
+// NOTE(stage0): remove after a snapshot
+#[cfg(stage0)]
+#[cold] #[inline(never)]
+pub fn panic_fmt(fmt: &fmt::Arguments, file_line: &(&'static str, uint)) -> ! {
+    #[allow(improper_ctypes)]
+    extern {
+        #[lang = "fail_fmt"]
+        fn panic_impl(fmt: &fmt::Arguments, file: &'static str,
+                        line: uint) -> !;
+
+    }
+    let (file, line) = *file_line;
+    unsafe { panic_impl(fmt, file, line) }
+}
+
+// NOTE(stage0): remove cfg after a snapshot
+#[cfg(not(stage0))]
 #[cold] #[inline(never)] // this is the slow path, always
 #[lang="panic"]
 pub fn panic(expr_file_line: &(&'static str, &'static str, uint)) -> ! {
@@ -45,6 +88,8 @@ pub fn panic(expr_file_line: &(&'static str, &'static str, uint)) -> ! {
     unsafe { intrinsics::abort() }
 }
 
+// NOTE(stage0): remove cfg after a snapshot
+#[cfg(not(stage0))]
 #[cold] #[inline(never)]
 #[lang="panic_bounds_check"]
 fn panic_bounds_check(file_line: &(&'static str, uint),
@@ -55,6 +100,8 @@ fn panic_bounds_check(file_line: &(&'static str, uint),
     unsafe { intrinsics::abort() }
 }
 
+// NOTE(stage0): remove cfg after a snapshot
+#[cfg(not(stage0))]
 #[cold] #[inline(never)]
 pub fn panic_fmt(fmt: &fmt::Arguments, file_line: &(&'static str, uint)) -> ! {
     #[allow(improper_ctypes)]