---

yaml
---
r: 159313
b: refs/heads/master
c: 5b895a8
h: refs/heads/master
i:
  159311: 8ab6d14
v: v3

Author: aturon

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 37ea270accf97fc4eed21a7373c3e7e62de7bbeb
+refs/heads/master: 5b895a833a6443046bbc8a6362b1a957cf68d1b4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 9c96a79a74f10bed18b031ce0ac4126c56d6cfb3
 refs/heads/try: f58aad6dce273570fb130b4df008ef9acd5a5be2

trunk/src/doc/guide.md

@@ -5274,7 +5274,7 @@ let result = task::try(proc() {
 
 This task will randomly panic or succeed. `task::try` returns a `Result`
 type, so we can handle the response like any other computation that may
-fail.
+panic.
 
 # Macros
 

trunk/src/etc/emacs/rust-mode.el

@@ -176,7 +176,7 @@
     "false" "fn" "for"
     "if" "impl" "in"
     "let" "loop"
-    "match" "mod" "move" "mut"
+    "match" "mod" "mut"
     "priv" "proc" "pub"
     "ref" "return"
     "self" "static" "struct" "super"

trunk/src/etc/kate/rust.xml

@@ -34,7 +34,6 @@
 		<item> loop </item>
 		<item> match </item>
 		<item> mod </item>
-		<item> move </item>
 		<item> mut </item>
 		<item> priv </item>
 		<item> pub </item>

trunk/src/liballoc/boxed.rs

@@ -65,12 +65,50 @@ impl<T: Clone> Clone for Box<T> {
     }
 }
 
+// NOTE(stage0): remove impl after a snapshot
+#[cfg(stage0)]
+impl<T:PartialEq> PartialEq for Box<T> {
+    #[inline]
+    fn eq(&self, other: &Box<T>) -> bool { *(*self) == *(*other) }
+    #[inline]
+    fn ne(&self, other: &Box<T>) -> bool { *(*self) != *(*other) }
+}
+// NOTE(stage0): remove impl after a snapshot
+#[cfg(stage0)]
+impl<T:PartialOrd> PartialOrd for Box<T> {
+    #[inline]
+    fn partial_cmp(&self, other: &Box<T>) -> Option<Ordering> {
+        (**self).partial_cmp(&**other)
+    }
+    #[inline]
+    fn lt(&self, other: &Box<T>) -> bool { *(*self) < *(*other) }
+    #[inline]
+    fn le(&self, other: &Box<T>) -> bool { *(*self) <= *(*other) }
+    #[inline]
+    fn ge(&self, other: &Box<T>) -> bool { *(*self) >= *(*other) }
+    #[inline]
+    fn gt(&self, other: &Box<T>) -> bool { *(*self) > *(*other) }
+}
+// NOTE(stage0): remove impl after a snapshot
+#[cfg(stage0)]
+impl<T: Ord> Ord for Box<T> {
+    #[inline]
+    fn cmp(&self, other: &Box<T>) -> Ordering {
+        (**self).cmp(&**other)
+    }
+}
+// NOTE(stage0): remove impl after a snapshot
+#[cfg(stage0)]
+impl<T: Eq> Eq for Box<T> {}
+
+#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 impl<Sized? T: PartialEq> PartialEq for Box<T> {
     #[inline]
     fn eq(&self, other: &Box<T>) -> bool { PartialEq::eq(&**self, &**other) }
     #[inline]
     fn ne(&self, other: &Box<T>) -> bool { PartialEq::ne(&**self, &**other) }
 }
+#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 impl<Sized? T: PartialOrd> PartialOrd for Box<T> {
     #[inline]
     fn partial_cmp(&self, other: &Box<T>) -> Option<Ordering> {
@@ -85,12 +123,14 @@ impl<Sized? T: PartialOrd> PartialOrd for Box<T> {
     #[inline]
     fn gt(&self, other: &Box<T>) -> bool { PartialOrd::gt(&**self, &**other) }
 }
+#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 impl<Sized? T: Ord> Ord for Box<T> {
     #[inline]
     fn cmp(&self, other: &Box<T>) -> Ordering {
         Ord::cmp(&**self, &**other)
     }
 }
+#[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
 impl<Sized? T: Eq> Eq for Box<T> {}
 
 /// Extension methods for an owning `Any` trait object.

trunk/src/libcollections/str.rs

@@ -534,6 +534,13 @@ impl<'a> PartialOrd for MaybeOwned<'a> {
 }
 
 impl<'a> Ord for MaybeOwned<'a> {
+    // NOTE(stage0): remove method after a snapshot
+    #[cfg(stage0)]
+    #[inline]
+    fn cmp(&self, other: &MaybeOwned) -> Ordering {
+        self.as_slice().cmp(&other.as_slice())
+    }
+    #[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
     #[inline]
     fn cmp(&self, other: &MaybeOwned) -> Ordering {
         self.as_slice().cmp(other.as_slice())

trunk/src/libcollections/vec.rs

@@ -506,6 +506,13 @@ impl<T: PartialEq> PartialEq for Vec<T> {
 
 #[unstable = "waiting on PartialOrd stability"]
 impl<T: PartialOrd> PartialOrd for Vec<T> {
+    // NOTE(stage0): remove method after a snapshot
+    #[cfg(stage0)]
+    #[inline]
+    fn partial_cmp(&self, other: &Vec<T>) -> Option<Ordering> {
+        self.as_slice().partial_cmp(&other.as_slice())
+    }
+    #[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
     #[inline]
     fn partial_cmp(&self, other: &Vec<T>) -> Option<Ordering> {
         self.as_slice().partial_cmp(other.as_slice())
@@ -523,6 +530,13 @@ impl<T: PartialEq, V: AsSlice<T>> Equiv<V> for Vec<T> {
 
 #[unstable = "waiting on Ord stability"]
 impl<T: Ord> Ord for Vec<T> {
+    // NOTE(stage0): remove method after a snapshot
+    #[cfg(stage0)]
+    #[inline]
+    fn cmp(&self, other: &Vec<T>) -> Ordering {
+        self.as_slice().cmp(&other.as_slice())
+    }
+    #[cfg(not(stage0))]  // NOTE(stage0): remove cfg after a snapshot
     #[inline]
     fn cmp(&self, other: &Vec<T>) -> Ordering {
         self.as_slice().cmp(other.as_slice())