---

yaml
---
r: 49098
b: refs/heads/snap-stage3
c: 30b1957
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 3bbcac322669cff3abde5be937cc4ec3860f3985
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: d2b267bcb5ac1adbc20bca0c170106ae3b3538ab
+refs/heads/snap-stage3: 30b1957cd447f91d206513d909f564d270410e82
 refs/heads/try: 2a8fb58d79e685d5ca07b039badcf2ae3ef077ea
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

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

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -21,82 +21,86 @@ and `Eq` to overload the `==` and `!=` operators.
 */
 
 /**
-* Trait for values that can be compared for equality and inequality.
+* Trait for values that can be compared for equality
+* and inequality.
 *
-* This trait allows partial equality, where types can be unordered instead of strictly equal or
-* unequal. For example, with the built-in floating-point types `a == b` and `a != b` will both
-* evaluate to false if either `a` or `b` is NaN (cf. IEEE 754-2008 section 5.11).
-*
-* Eventually, this will be implemented by default for types that implement `TotalEq`.
+* Eventually this may be simplified to only require
+* an `eq` method, with the other generated from
+* a default implementation. However it should
+* remain possible to implement `ne` separately, for
+* compatibility with floating-point NaN semantics
+* (cf. IEEE 754-2008 section 5.11).
 */
 #[lang="eq"]
 pub trait Eq {
     fn eq(&self, other: &Self) -> bool;
     fn ne(&self, other: &Self) -> bool;
 }
 
-/// Trait for equality comparisons where `a == b` and `a != b` are strict inverses.
-pub trait TotalEq {
-    fn equals(&self, other: &Self) -> bool;
+#[deriving(Eq)]
+pub enum Ordering { Less, Equal, Greater }
+
+/// Trait for types that form a total order
+pub trait TotalOrd {
+    fn cmp(&self, other: &Self) -> Ordering;
 }
 
-macro_rules! totaleq_impl(
-    ($t:ty) => {
-        impl TotalEq for $t {
-            #[inline(always)]
-            fn equals(&self, other: &$t) -> bool { *self == *other }
-        }
-    }
-)
+#[inline(always)]
+fn icmp<T: Ord>(a: &T, b: &T) -> Ordering {
+    if *a < *b { Less }
+    else if *a > *b { Greater }
+    else { Equal }
+}
 
-totaleq_impl!(bool)
+impl TotalOrd for u8 {
+    #[inline(always)]
+    fn cmp(&self, other: &u8) -> Ordering { icmp(self, other) }
+}
 
-totaleq_impl!(u8)
-totaleq_impl!(u16)
-totaleq_impl!(u32)
-totaleq_impl!(u64)
+impl TotalOrd for u16 {
+    #[inline(always)]
+    fn cmp(&self, other: &u16) -> Ordering { icmp(self, other) }
+}
 
-totaleq_impl!(i8)
-totaleq_impl!(i16)
-totaleq_impl!(i32)
-totaleq_impl!(i64)
+impl TotalOrd for u32 {
+    #[inline(always)]
+    fn cmp(&self, other: &u32) -> Ordering { icmp(self, other) }
+}
 
-totaleq_impl!(int)
-totaleq_impl!(uint)
+impl TotalOrd for u64 {
+    #[inline(always)]
+    fn cmp(&self, other: &u64) -> Ordering { icmp(self, other) }
+}
 
-#[deriving(Eq)]
-pub enum Ordering { Less, Equal, Greater }
+impl TotalOrd for i8 {
+    #[inline(always)]
+    fn cmp(&self, other: &i8) -> Ordering { icmp(self, other) }
+}
 
-/// Trait for types that form a total order
-pub trait TotalOrd: TotalEq {
-    fn cmp(&self, other: &Self) -> Ordering;
+impl TotalOrd for i16 {
+    #[inline(always)]
+    fn cmp(&self, other: &i16) -> Ordering { icmp(self, other) }
 }
 
-macro_rules! totalord_impl(
-    ($t:ty) => {
-        impl TotalOrd for $t {
-            #[inline(always)]
-            fn cmp(&self, other: &$t) -> Ordering {
-                if *self < *other { Less }
-                else if *self > *other { Greater }
-                else { Equal }
-            }
-        }
-    }
-)
+impl TotalOrd for i32 {
+    #[inline(always)]
+    fn cmp(&self, other: &i32) -> Ordering { icmp(self, other) }
+}
 
-totalord_impl!(u8)
-totalord_impl!(u16)
-totalord_impl!(u32)
-totalord_impl!(u64)
+impl TotalOrd for i64 {
+    #[inline(always)]
+    fn cmp(&self, other: &i64) -> Ordering { icmp(self, other) }
+}
 
-totalord_impl!(i8)
-totalord_impl!(i16)
-totalord_impl!(i32)
-totalord_impl!(i64)
+impl TotalOrd for int {
+    #[inline(always)]
+    fn cmp(&self, other: &int) -> Ordering { icmp(self, other) }
+}
 
-totalord_impl!(int)
-totalord_impl!(uint)
+impl TotalOrd for uint {
+    #[inline(always)]
+    fn cmp(&self, other: &uint) -> Ordering { icmp(self, other) }
+}
 
 /**
 * Trait for values that can be compared for a sort-order.
@@ -167,17 +171,11 @@ pub fn max<T:Ord>(v1: T, v2: T) -> T {
 #[cfg(test)]
 mod test {
     #[test]
-    fn test_int_totalord() {
+    fn test_int() {
         assert_eq!(5.cmp(&10), Less);
         assert_eq!(10.cmp(&5), Greater);
         assert_eq!(5.cmp(&5), Equal);
         assert_eq!((-5).cmp(&12), Less);
         assert_eq!(12.cmp(-5), Greater);
     }
-
-    #[test]
-    fn test_int_totaleq() {
-        fail_unless!(5.equals(&5));
-        fail_unless!(!2.equals(&17));
-    }
 }

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

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -15,7 +15,7 @@ Functions for the unit type.
 */
 
 #[cfg(notest)]
-use prelude::*;
+use cmp::{Eq, Ord, TotalOrd, Ordering, Equal};
 
 #[cfg(notest)]
 impl Eq for () {
@@ -42,9 +42,3 @@ impl TotalOrd for () {
     #[inline(always)]
     fn cmp(&self, _other: &()) -> Ordering { Equal }
 }
-
-#[cfg(notest)]
-impl TotalEq for () {
-    #[inline(always)]
-    fn equals(&self, _other: &()) -> bool { true }
-}

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

@@ -77,5 +77,5 @@ pub trait Shr<RHS,Result> {
 
 #[lang="index"]
 pub trait Index<Index,Result> {
-    fn index(&self, index: Index) -> Result;
+    fn index(&self, index: &Index) -> Result;
 }

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

@@ -24,7 +24,7 @@ pub use result::{Result, Ok, Err};
 /* Reexported types and traits */
 
 pub use clone::Clone;
-pub use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
+pub use cmp::{Eq, Ord, TotalOrd, Ordering, Less, Equal, Greater};
 pub use container::{Container, Mutable, Map, Set};
 pub use hash::Hash;
 pub use iter::{BaseIter, ReverseIter, MutableIter, ExtendedIter, EqIter};

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

@@ -21,7 +21,7 @@ use at_vec;
 use cast;
 use char;
 use clone::Clone;
-use cmp::{Equiv, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
+use cmp::{Equiv, TotalOrd, Ordering, Less, Equal, Greater};
 use libc;
 use option::{None, Option, Some};
 use ptr;
@@ -930,30 +930,6 @@ impl Eq for @str {
     fn ne(&self, other: &@str) -> bool { !(*self).eq(other) }
 }
 
-#[cfg(notest)]
-impl<'self> TotalEq for &'self str {
-    #[inline(always)]
-    fn equals(&self, other: & &'self str) -> bool {
-        eq_slice((*self), (*other))
-    }
-}
-
-#[cfg(notest)]
-impl TotalEq for ~str {
-    #[inline(always)]
-    fn equals(&self, other: &~str) -> bool {
-        eq_slice((*self), (*other))
-    }
-}
-
-#[cfg(notest)]
-impl TotalEq for @str {
-    #[inline(always)]
-    fn equals(&self, other: &@str) -> bool {
-        eq_slice((*self), (*other))
-    }
-}
-
 #[cfg(notest)]
 impl Ord for ~str {
     #[inline(always)]

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

@@ -14,7 +14,7 @@
 
 use container::{Container, Mutable};
 use cast;
-use cmp::{Eq, Equiv, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
+use cmp::{Eq, Equiv, Ord, TotalOrd, Ordering, Less, Equal, Greater};
 use clone::Clone;
 use iter::BaseIter;
 use iter;
@@ -1547,7 +1547,7 @@ pub fn as_mut_buf<T,U>(s: &mut [T], f: &fn(*mut T, uint) -> U) -> U {
 
 // Equality
 
-fn eq<T: Eq>(a: &[T], b: &[T]) -> bool {
+fn eq<T:Eq>(a: &[T], b: &[T]) -> bool {
     let (a_len, b_len) = (a.len(), b.len());
     if a_len != b_len { return false; }
 
@@ -1556,61 +1556,33 @@ fn eq<T: Eq>(a: &[T], b: &[T]) -> bool {
         if a[i] != b[i] { return false; }
         i += 1;
     }
-    true
-}
-
-fn equals<T: TotalEq>(a: &[T], b: &[T]) -> bool {
-    let (a_len, b_len) = (a.len(), b.len());
-    if a_len != b_len { return false; }
 
-    let mut i = 0;
-    while i < a_len {
-        if !a[i].equals(&b[i]) { return false; }
-        i += 1;
-    }
     true
 }
 
 #[cfg(notest)]
 impl<'self,T:Eq> Eq for &'self [T] {
     #[inline(always)]
-    fn eq(&self, other: & &'self [T]) -> bool { eq(*self, *other) }
+    fn eq(&self, other: & &'self [T]) -> bool { eq((*self), (*other)) }
     #[inline(always)]
-    fn ne(&self, other: & &'self [T]) -> bool { !self.eq(other) }
+    fn ne(&self, other: & &'self [T]) -> bool { !(*self).eq(other) }
 }
 
+
 #[cfg(notest)]
 impl<T:Eq> Eq for ~[T] {
     #[inline(always)]
-    fn eq(&self, other: &~[T]) -> bool { eq(*self, *other) }
+    fn eq(&self, other: &~[T]) -> bool { eq((*self), (*other)) }
     #[inline(always)]
-    fn ne(&self, other: &~[T]) -> bool { !self.eq(other) }
+    fn ne(&self, other: &~[T]) -> bool { !(*self).eq(other) }
 }
 
 #[cfg(notest)]
 impl<T:Eq> Eq for @[T] {
     #[inline(always)]
-    fn eq(&self, other: &@[T]) -> bool { eq(*self, *other) }
-    #[inline(always)]
-    fn ne(&self, other: &@[T]) -> bool { !self.eq(other) }
-}
-
-#[cfg(notest)]
-impl<'self,T:TotalEq> TotalEq for &'self [T] {
-    #[inline(always)]
-    fn equals(&self, other: & &'self [T]) -> bool { equals(*self, *other) }
-}
-
-#[cfg(notest)]
-impl<T:TotalEq> TotalEq for ~[T] {
-    #[inline(always)]
-    fn equals(&self, other: &~[T]) -> bool { equals(*self, *other) }
-}
-
-#[cfg(notest)]
-impl<T:TotalEq> TotalEq for @[T] {
+    fn eq(&self, other: &@[T]) -> bool { eq((*self), (*other)) }
     #[inline(always)]
-    fn equals(&self, other: &@[T]) -> bool { equals(*self, *other) }
+    fn ne(&self, other: &@[T]) -> bool { !(*self).eq(other) }
 }
 
 #[cfg(notest)]

branches/snap-stage3/src/librustc/metadata/decoder.rs

@@ -630,7 +630,6 @@ fn get_self_ty(item: ebml::Doc) -> ast::self_ty_ {
     let self_ty_kind = string[0];
     match self_ty_kind as char {
         's' => { return ast::sty_static; }
-        'r' => { return ast::sty_by_ref; }
         'v' => { return ast::sty_value; }
         '@' => { return ast::sty_box(get_mutability(string[1])); }
         '~' => { return ast::sty_uniq(get_mutability(string[1])); }

branches/snap-stage3/src/librustc/metadata/encoder.rs

@@ -410,9 +410,6 @@ fn encode_self_type(ebml_w: writer::Encoder, self_type: ast::self_ty_) {
         sty_static => {
             ebml_w.writer.write(&[ 's' as u8 ]);
         }
-        sty_by_ref => {
-            ebml_w.writer.write(&[ 'r' as u8 ]);
-        }
         sty_value => {
             ebml_w.writer.write(&[ 'v' as u8 ]);
         }

branches/snap-stage3/src/librustc/metadata/tydecode.rs

@@ -24,6 +24,7 @@ use core::vec;
 use syntax::ast;
 use syntax::ast::*;
 use syntax::codemap::{respan, dummy_sp};
+use syntax::opt_vec;
 
 // Compact string representation for ty::t values. API ty_str &
 // parse_from_str. Extra parameters are for converting to/from def_ids in the
@@ -479,7 +480,9 @@ fn parse_sig(st: @mut PState, conv: conv_did) -> ty::FnSig {
     }
     st.pos += 1u; // eat the ']'
     let ret_ty = parse_ty(st, conv);
-    ty::FnSig {inputs: inputs, output: ret_ty}
+    ty::FnSig {bound_lifetime_names: opt_vec::Empty, // FIXME(#4846)
+               inputs: inputs,
+               output: ret_ty}
 }
 
 // Rust metadata parsing