rustc: De-mode all overloaded operators

Author: pcwalton

src/cargo/cargo.rs

@@ -26,6 +26,7 @@ type package = {
     versions: ~[(~str, ~str)]
 };
 
+#[cfg(stage0)]
 impl package : cmp::Ord {
     pure fn lt(&&other: package) -> bool {
         if self.name.lt(other.name) { return true; }
@@ -47,6 +48,29 @@ impl package : cmp::Ord {
     pure fn ge(&&other: package) -> bool { !self.lt(other) }
     pure fn gt(&&other: package) -> bool { other.lt(self)  }
 }
+#[cfg(stage1)]
+#[cfg(stage2)]
+impl package : cmp::Ord {
+    pure fn lt(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;
+    }
+    pure fn le(other: &package) -> bool { !(*other).lt(&self) }
+    pure fn ge(other: &package) -> bool { !self.lt(other)     }
+    pure fn gt(other: &package) -> bool { (*other).lt(&self)  }
+}
 
 type local_package = {
     name: ~str,
@@ -97,12 +121,21 @@ type options = {
 
 enum mode { system_mode, user_mode, local_mode }
 
+#[cfg(stage0)]
 impl mode : cmp::Eq {
     pure fn eq(&&other: mode) -> bool {
         (self as uint) == (other as uint)
     }
     pure fn ne(&&other: mode) -> bool { !self.eq(other) }
 }
+#[cfg(stage1)]
+#[cfg(stage2)]
+impl mode : cmp::Eq {
+    pure fn eq(other: &mode) -> bool {
+        (self as uint) == ((*other) as uint)
+    }
+    pure fn ne(other: &mode) -> bool { !self.eq(other) }
+}
 
 fn opts() -> ~[getopts::Opt] {
     ~[optflag(~"g"), optflag(~"G"), optflag(~"test"),

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(other: &mode) -> bool {
+        (*other) as int == self as int
+    }
+    pure fn ne(other: &mode) -> bool { !self.eq(other) }
+}
 
 type config = {
     // The library paths required for running the compiler

src/fuzzer/fuzzer.rs

@@ -8,12 +8,21 @@ use syntax::diagnostic;
 enum test_mode { tm_converge, tm_run, }
 type context = { mode: test_mode }; // + rng
 
+#[cfg(stage0)]
 impl test_mode : cmp::Eq {
     pure fn eq(&&other: test_mode) -> bool {
         (self as uint) == (other as uint)
     }
     pure fn ne(&&other: test_mode) -> bool { !self.eq(other) }
 }
+#[cfg(stage1)]
+#[cfg(stage2)]
+impl test_mode : cmp::Eq {
+    pure fn eq(other: &test_mode) -> bool {
+        (self as uint) == ((*other) as uint)
+    }
+    pure fn ne(other: &test_mode) -> bool { !self.eq(other) }
+}
 
 fn write_file(filename: &Path, content: ~str) {
     result::get(

src/libcore/at_vec.rs

@@ -8,6 +8,7 @@ export build_sized, build, build_sized_opt;
 export map;
 export from_fn, from_elem;
 export raw;
+export traits;
 
 /// Code for dealing with @-vectors. This is pretty incomplete, and
 /// contains a bunch of duplication from the code for ~-vectors.
@@ -133,13 +134,26 @@ pure fn from_elem<T: Copy>(n_elts: uint, t: T) -> @[T] {
 }
 
 #[cfg(notest)]
-impl<T: Copy> @[T]: Add<&[const T],@[T]> {
-    #[inline(always)]
-    pure fn add(rhs: &[const T]) -> @[T] {
-        append(self, rhs)
+mod traits {
+    #[cfg(stage0)]
+    impl<T: Copy> @[T]: Add<&[const T],@[T]> {
+        #[inline(always)]
+        pure fn add(rhs: &[const T]) -> @[T] {
+            append(self, rhs)
+        }
+    }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    impl<T: Copy> @[T] : Add<&[const T],@[T]> {
+        #[inline(always)]
+        pure fn add(rhs: & &[const T]) -> @[T] {
+            append(self, (*rhs))
+        }
     }
 }
 
+#[cfg(test)]
+mod traits {}
 
 mod raw {
     type VecRepr = vec::raw::VecRepr;

src/libcore/bool.rs

@@ -69,10 +69,17 @@ fn all_values(blk: fn(v: bool)) {
 /// converts truth value to an 8 bit byte
 pure fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } }
 
+#[cfg(stage0)]
 impl bool : cmp::Eq {
     pure fn eq(&&other: bool) -> bool { self == other }
     pure fn ne(&&other: bool) -> bool { self != other }
 }
+#[cfg(stage1)]
+#[cfg(stage2)]
+impl bool : cmp::Eq {
+    pure fn eq(other: &bool) -> bool { self == (*other) }
+    pure fn ne(other: &bool) -> bool { self != (*other) }
+}
 
 #[test]
 fn test_bool_from_str() {

src/libcore/box.rs

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

src/libcore/char.rs

@@ -189,10 +189,17 @@ pure fn cmp(a: char, b: char) -> int {
     else { 0 }
 }
 
+#[cfg(stage0)]
 impl char: Eq {
     pure fn eq(&&other: char) -> bool { self == other }
     pure fn ne(&&other: char) -> bool { self != other }
 }
+#[cfg(stage1)]
+#[cfg(stage2)]
+impl char : Eq {
+    pure fn eq(other: &char) -> bool { self == (*other) }
+    pure fn ne(other: &char) -> bool { self != (*other) }
+}
 
 #[test]
 fn test_is_lowercase() {