rustc: Implement explicit self for Eq and Ord. r=graydon

Author: pcwalton

src/compiletest/common.rs

@@ -1,11 +1,20 @@
 enum mode { mode_compile_fail, mode_run_fail, mode_run_pass, mode_pretty, }
 
+#[cfg(stage0)]
 impl mode : cmp::Eq {
     pure fn eq(other: &mode) -> bool {
         (*other) as int == self as int
     }
     pure fn ne(other: &mode) -> bool { !self.eq(other) }
 }
+#[cfg(stage1)]
+#[cfg(stage2)]
+impl mode : cmp::Eq {
+    pure fn eq(&self, other: &mode) -> bool {
+        (*other) as int == (*self) as int
+    }
+    pure fn ne(&self, other: &mode) -> bool { !(*self).eq(other) }
+}
 
 type config = {
     // The library paths required for running the compiler

src/libcargo/cargo.rs

@@ -30,6 +30,7 @@ struct Package {
 }
 
 impl Package : cmp::Ord {
+    #[cfg(stage0)]
     pure fn lt(other: &Package) -> bool {
         if self.name.lt(&(*other).name) { return true; }
         if (*other).name.lt(&self.name) { return false; }
@@ -46,9 +47,39 @@ impl Package : cmp::Ord {
         if self.versions.lt(&(*other).versions) { return true; }
         return false;
     }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn lt(&self, other: &Package) -> bool {
+        if (*self).name.lt(&(*other).name) { return true; }
+        if (*other).name.lt(&(*self).name) { return false; }
+        if (*self).uuid.lt(&(*other).uuid) { return true; }
+        if (*other).uuid.lt(&(*self).uuid) { return false; }
+        if (*self).url.lt(&(*other).url) { return true; }
+        if (*other).url.lt(&(*self).url) { return false; }
+        if (*self).method.lt(&(*other).method) { return true; }
+        if (*other).method.lt(&(*self).method) { return false; }
+        if (*self).description.lt(&(*other).description) { return true; }
+        if (*other).description.lt(&(*self).description) { return false; }
+        if (*self).tags.lt(&(*other).tags) { return true; }
+        if (*other).tags.lt(&(*self).tags) { return false; }
+        if (*self).versions.lt(&(*other).versions) { return true; }
+        return false;
+    }
+    #[cfg(stage0)]
     pure fn le(other: &Package) -> bool { !(*other).lt(&self) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn le(&self, other: &Package) -> bool { !(*other).lt(&(*self)) }
+    #[cfg(stage0)]
     pure fn ge(other: &Package) -> bool { !self.lt(other)     }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn ge(&self, other: &Package) -> bool { !(*self).lt(other)     }
+    #[cfg(stage0)]
     pure fn gt(other: &Package) -> bool { (*other).lt(&self)  }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn gt(&self, other: &Package) -> bool { (*other).lt(&(*self))  }
 }
 
 struct Source {
@@ -94,10 +125,20 @@ struct Options {
 enum Mode { SystemMode, UserMode, LocalMode }
 
 impl Mode : cmp::Eq {
+    #[cfg(stage0)]
     pure fn eq(other: &Mode) -> bool {
         (self as uint) == ((*other) as uint)
     }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn eq(&self, other: &Mode) -> bool {
+        ((*self) as uint) == ((*other) as uint)
+    }
+    #[cfg(stage0)]
     pure fn ne(other: &Mode) -> bool { !self.eq(other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn ne(&self, other: &Mode) -> bool { !(*self).eq(other) }
 }
 
 fn opts() -> ~[getopts::Opt] {

src/libcore/bool.rs

@@ -66,8 +66,16 @@ pub fn all_values(blk: fn(v: bool)) {
 pub pure fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } }
 
 impl bool : cmp::Eq {
+    #[cfg(stage0)]
     pure fn eq(other: &bool) -> bool { self == (*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn eq(&self, other: &bool) -> bool { (*self) == (*other) }
+    #[cfg(stage0)]
     pure fn ne(other: &bool) -> bool { self != (*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn ne(&self, other: &bool) -> bool { (*self) != (*other) }
 }
 
 #[test]

src/libcore/box.rs

@@ -28,15 +28,39 @@ pub pure fn ptr_eq<T>(a: @T, b: @T) -> bool {
 }
 
 impl<T:Eq> @const T : Eq {
+    #[cfg(stage0)]
     pure fn eq(other: &@const T) -> bool { *self == *(*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn eq(&self, other: &@const T) -> bool { *(*self) == *(*other) }
+    #[cfg(stage0)]
     pure fn ne(other: &@const T) -> bool { *self != *(*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn ne(&self, other: &@const T) -> bool { *(*self) != *(*other) }
 }
 
 impl<T:Ord> @const T : Ord {
+    #[cfg(stage0)]
     pure fn lt(other: &@const T) -> bool { *self < *(*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn lt(&self, other: &@const T) -> bool { *(*self) < *(*other) }
+    #[cfg(stage0)]
     pure fn le(other: &@const T) -> bool { *self <= *(*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn le(&self, other: &@const T) -> bool { *(*self) <= *(*other) }
+    #[cfg(stage0)]
     pure fn ge(other: &@const T) -> bool { *self >= *(*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn ge(&self, other: &@const T) -> bool { *(*self) >= *(*other) }
+    #[cfg(stage0)]
     pure fn gt(other: &@const T) -> bool { *self > *(*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn gt(&self, other: &@const T) -> bool { *(*self) > *(*other) }
 }
 
 #[test]

src/libcore/char.rs

@@ -181,8 +181,16 @@ pub pure fn cmp(a: char, b: char) -> int {
 }
 
 impl char : Eq {
+    #[cfg(stage0)]
     pure fn eq(other: &char) -> bool { self == (*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn eq(&self, other: &char) -> bool { (*self) == (*other) }
+    #[cfg(stage0)]
     pure fn ne(other: &char) -> bool { self != (*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn ne(&self, other: &char) -> bool { (*self) != (*other) }
 }
 
 #[test]

src/libcore/cmp.rs

@@ -30,13 +30,24 @@ mod nounittest {
      * default implementations.
      */
     #[lang="ord"]
+    #[cfg(stage0)]
     pub trait Ord {
         pure fn lt(other: &self) -> bool;
         pure fn le(other: &self) -> bool;
         pure fn ge(other: &self) -> bool;
         pure fn gt(other: &self) -> bool;
     }
 
+    #[lang="ord"]
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pub trait Ord {
+        pure fn lt(&self, other: &self) -> bool;
+        pure fn le(&self, other: &self) -> bool;
+        pure fn ge(&self, other: &self) -> bool;
+        pure fn gt(&self, other: &self) -> bool;
+    }
+
     #[lang="eq"]
     /**
      * Trait for values that can be compared for equality
@@ -47,10 +58,19 @@ mod nounittest {
      * a default implementation.
      */
     #[lang="eq"]
+    #[cfg(stage0)]
     pub trait Eq {
         pure fn eq(other: &self) -> bool;
         pure fn ne(other: &self) -> bool;
     }
+
+    #[lang="eq"]
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pub trait Eq {
+        pure fn eq(&self, other: &self) -> bool;
+        pure fn ne(&self, other: &self) -> bool;
+    }
 }
 
 #[cfg(test)]
@@ -60,17 +80,36 @@ mod nounittest {
 #[cfg(test)]
 mod unittest {
     #[legacy_exports];
+
+    #[cfg(stage0)]
     pub trait Ord {
         pure fn lt(other: &self) -> bool;
         pure fn le(other: &self) -> bool;
         pure fn ge(other: &self) -> bool;
         pure fn gt(other: &self) -> bool;
     }
 
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pub trait Ord {
+        pure fn lt(&self, other: &self) -> bool;
+        pure fn le(&self, other: &self) -> bool;
+        pure fn ge(&self, other: &self) -> bool;
+        pure fn gt(&self, other: &self) -> bool;
+    }
+
+    #[cfg(stage0)]
     pub trait Eq {
         pure fn eq(other: &self) -> bool;
         pure fn ne(other: &self) -> bool;
     }
+
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pub trait Eq {
+        pure fn eq(&self, other: &self) -> bool;
+        pure fn ne(&self, other: &self) -> bool;
+    }
 }
 
 #[cfg(notest)]

src/libcore/either.rs

@@ -132,6 +132,7 @@ pub pure fn unwrap_right<T,U>(eith: Either<T,U>) -> U {
 }
 
 impl<T:Eq,U:Eq> Either<T,U> : Eq {
+    #[cfg(stage0)]
     pure fn eq(other: &Either<T,U>) -> bool {
         match self {
             Left(ref a) => {
@@ -148,7 +149,29 @@ impl<T:Eq,U:Eq> Either<T,U> : Eq {
             }
         }
     }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn eq(&self, other: &Either<T,U>) -> bool {
+        match (*self) {
+            Left(ref a) => {
+                match (*other) {
+                    Left(ref b) => (*a).eq(b),
+                    Right(_) => false
+                }
+            }
+            Right(ref a) => {
+                match (*other) {
+                    Left(_) => false,
+                    Right(ref b) => (*a).eq(b)
+                }
+            }
+        }
+    }
+    #[cfg(stage0)]
     pure fn ne(other: &Either<T,U>) -> bool { !self.eq(other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn ne(&self, other: &Either<T,U>) -> bool { !(*self).eq(other) }
 }
 
 #[test]

src/libcore/extfmt.rs

@@ -394,6 +394,7 @@ pub mod rt {
     pub enum PadMode { PadSigned, PadUnsigned, PadNozero, PadFloat }
 
     pub impl PadMode : Eq {
+        #[cfg(stage0)]
         pure fn eq(other: &PadMode) -> bool {
             match (self, (*other)) {
                 (PadSigned, PadSigned) => true,
@@ -406,7 +407,25 @@ pub mod rt {
                 (PadFloat, _) => false
             }
         }
+        #[cfg(stage1)]
+        #[cfg(stage2)]
+        pure fn eq(&self, other: &PadMode) -> bool {
+            match ((*self), (*other)) {
+                (PadSigned, PadSigned) => true,
+                (PadUnsigned, PadUnsigned) => true,
+                (PadNozero, PadNozero) => true,
+                (PadFloat, PadFloat) => true,
+                (PadSigned, _) => false,
+                (PadUnsigned, _) => false,
+                (PadNozero, _) => false,
+                (PadFloat, _) => false
+            }
+        }
+        #[cfg(stage0)]
         pure fn ne(other: &PadMode) -> bool { !self.eq(other) }
+        #[cfg(stage1)]
+        #[cfg(stage2)]
+        pure fn ne(&self, other: &PadMode) -> bool { !(*self).eq(other) }
     }
 
     pub fn pad(cv: Conv, s: ~str, mode: PadMode) -> ~str {

src/libcore/float.rs

@@ -400,15 +400,39 @@ pub pure fn cos(x: float) -> float { f64::cos(x as f64) as float }
 pub pure fn tan(x: float) -> float { f64::tan(x as f64) as float }
 
 impl float : Eq {
+    #[cfg(stage0)]
     pub pure fn eq(other: &float) -> bool { self == (*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn eq(&self, other: &float) -> bool { (*self) == (*other) }
+    #[cfg(stage0)]
     pub pure fn ne(other: &float) -> bool { self != (*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn ne(&self, other: &float) -> bool { (*self) != (*other) }
 }
 
 impl float : Ord {
+    #[cfg(stage0)]
     pub pure fn lt(other: &float) -> bool { self < (*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn lt(&self, other: &float) -> bool { (*self) < (*other) }
+    #[cfg(stage0)]
     pub pure fn le(other: &float) -> bool { self <= (*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn le(&self, other: &float) -> bool { (*self) <= (*other) }
+    #[cfg(stage0)]
     pub pure fn ge(other: &float) -> bool { self >= (*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn ge(&self, other: &float) -> bool { (*self) >= (*other) }
+    #[cfg(stage0)]
     pub pure fn gt(other: &float) -> bool { self > (*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn gt(&self, other: &float) -> bool { (*self) > (*other) }
 }
 
 impl float: num::Num {

src/libcore/int-template.rs

@@ -55,15 +55,39 @@ pub pure fn abs(i: T) -> T {
 }
 
 impl T : Ord {
+    #[cfg(stage0)]
     pure fn lt(other: &T) -> bool { return self < (*other); }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn lt(&self, other: &T) -> bool { return (*self) < (*other); }
+    #[cfg(stage0)]
     pure fn le(other: &T) -> bool { return self <= (*other); }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn le(&self, other: &T) -> bool { return (*self) <= (*other); }
+    #[cfg(stage0)]
     pure fn ge(other: &T) -> bool { return self >= (*other); }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn ge(&self, other: &T) -> bool { return (*self) >= (*other); }
+    #[cfg(stage0)]
     pure fn gt(other: &T) -> bool { return self > (*other); }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn gt(&self, other: &T) -> bool { return (*self) > (*other); }
 }
 
 impl T : Eq {
+    #[cfg(stage0)]
     pure fn eq(other: &T) -> bool { return self == (*other); }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn eq(&self, other: &T) -> bool { return (*self) == (*other); }
+    #[cfg(stage0)]
     pure fn ne(other: &T) -> bool { return self != (*other); }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn ne(&self, other: &T) -> bool { return (*self) != (*other); }
 }
 
 impl T: num::Num {