rustc: Add an "ne" method to the Eq trait, and implement it everywhere

src/cargo/cargo.rs

@@ -100,6 +100,7 @@ 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] {

src/compiletest/common.rs

@@ -6,6 +6,7 @@ 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 = {

src/fuzzer/fuzzer.rs

@@ -12,6 +12,7 @@ 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) {

src/libcore/bool.rs

@@ -70,9 +70,8 @@ fn all_values(blk: fn(v: bool)) {
 pure fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } }
 
 impl bool : cmp::Eq {
-    pure fn eq(&&other: bool) -> bool {
-        self == other
-    }
+    pure fn eq(&&other: bool) -> bool { self == other }
+    pure fn ne(&&other: bool) -> bool { self != other }
 }
 
 #[test]

src/libcore/box.rs

@@ -15,6 +15,7 @@ pure fn ptr_eq<T>(a: @T, b: @T) -> bool {
 
 impl<T:Eq> @const T : Eq {
     pure fn eq(&&other: @const T) -> bool { *self == *other }
+    pure fn ne(&&other: @const T) -> bool { *self != *other }
 }
 
 impl<T:Ord> @const T : Ord {

src/libcore/char.rs

@@ -191,6 +191,7 @@ pure fn cmp(a: char, b: char) -> int {
 
 impl char: Eq {
     pure fn eq(&&other: char) -> bool { self == other }
+    pure fn ne(&&other: char) -> bool { self != other }
 }
 
 #[test]

src/libcore/cmp.rs

@@ -26,11 +26,13 @@ trait Ord {
 #[lang="eq"]
 trait Eq {
     pure fn eq(&&other: self) -> bool;
+    pure fn ne(&&other: self) -> bool;
 }
 
 #[cfg(test)]
 trait Eq {
     pure fn eq(&&other: self) -> bool;
+    pure fn ne(&&other: self) -> bool;
 }
 
 pure fn lt<T: Ord>(v1: &T, v2: &T) -> bool {
@@ -45,6 +47,10 @@ pure fn eq<T: Eq>(v1: &T, v2: &T) -> bool {
     v1.eq(v2)
 }
 
+pure fn ne<T: Eq>(v1: &T, v2: &T) -> bool {
+    v1.ne(v2)
+}
+
 pure fn ge<T: Ord>(v1: &T, v2: &T) -> bool {
     v1.ge(v2)
 }

src/libcore/either.rs

@@ -143,6 +143,7 @@ impl<T:Eq,U:Eq> Either<T,U> : Eq {
             }
         }
     }
+    pure fn ne(&&other: Either<T,U>) -> bool { !self.eq(other) }
 }
 
 #[test]

src/libcore/extfmt.rs

@@ -401,6 +401,7 @@ mod rt {
                 (pad_float, _) => false
             }
         }
+        pure fn ne(&&other: pad_mode) -> bool { !self.eq(other) }
     }
 
     fn pad(cv: conv, &s: ~str, mode: pad_mode) -> ~str {

src/libcore/float.rs

@@ -416,6 +416,7 @@ pure fn tan(x: float) -> float { f64::tan(x as f64) as float }
 
 impl float: Eq {
     pure fn eq(&&other: float) -> bool { self == other }
+    pure fn ne(&&other: float) -> bool { self != other }
 }
 
 impl float: Ord {

src/libcore/int-template.rs

@@ -76,9 +76,8 @@ impl T: Ord {
 }
 
 impl T: Eq {
-    pure fn eq(&&other: T) -> bool {
-        return self == other;
-    }
+    pure fn eq(&&other: T) -> bool { return self == other; }
+    pure fn ne(&&other: T) -> bool { return self != other; }
 }
 
 impl T: num::Num {

src/libcore/io.rs

@@ -337,6 +337,7 @@ impl WriterType: Eq {
             (Screen, _) | (File, _) => false
         }
     }
+    pure fn ne(&&other: WriterType) -> bool { !self.eq(other) }
 }
 
 // FIXME (#2004): Seekable really should be orthogonal.

src/libcore/option.rs

@@ -266,6 +266,7 @@ impl<T: Eq> Option<T> : Eq {
             }
         }
     }
+    pure fn ne(&&other: Option<T>) -> bool { !self.eq(other) }
 }
 
 #[test]

src/libcore/path.rs

@@ -69,6 +69,7 @@ impl PosixPath : Eq {
         return self.is_absolute == other.is_absolute &&
             self.components == other.components;
     }
+    pure fn ne(&&other: PosixPath) -> bool { !self.eq(other) }
 }
 
 impl WindowsPath : Eq {
@@ -78,6 +79,7 @@ impl WindowsPath : Eq {
             self.is_absolute == other.is_absolute &&
             self.components == other.components;
     }
+    pure fn ne(&&other: WindowsPath) -> bool { !self.eq(other) }
 }
 
 // FIXME (#3227): when default methods in traits are working, de-duplicate

src/libcore/pipes.rs

@@ -128,6 +128,7 @@ impl State: Eq {
     pure fn eq(&&other: State) -> bool {
         (self as uint) == (other as uint)
     }
+    pure fn ne(&&other: State) -> bool { !self.eq(other) }
 }
 
 struct BufferHeader {

src/libcore/ptr.rs

@@ -188,6 +188,7 @@ impl<T> *const T : Eq {
         let b: uint = unsafe::reinterpret_cast(&other);
         return a == b;
     }
+    pure fn ne(&&other: *const T) -> bool { !self.eq(other) }
 }
 
 // Comparison for pointers
@@ -216,9 +217,8 @@ impl<T> *const T : Ord {
 
 // Equality for region pointers
 impl<T:Eq> &const T : Eq {
-    pure fn eq(&&other: &const T) -> bool {
-        return *self == *other;
-    }
+    pure fn eq(&&other: &const T) -> bool { return *self == *other; }
+    pure fn ne(&&other: &const T) -> bool { return *self != *other; }
 }
 
 // Comparison for region pointers

src/libcore/result.rs

@@ -373,6 +373,7 @@ impl<T:Eq,U:Eq> Result<T,U> : Eq {
             }
         }
     }
+    pure fn ne(&&other: Result<T,U>) -> bool { !self.eq(other) }
 }
 
 #[cfg(test)]

src/libcore/str.rs

@@ -780,20 +780,26 @@ impl &str: Eq {
     pure fn eq(&&other: &str) -> bool {
         eq_slice(self, other)
     }
+    #[inline(always)]
+    pure fn ne(&&other: &str) -> bool { !self.eq(other) }
 }
 
 impl ~str: Eq {
     #[inline(always)]
     pure fn eq(&&other: ~str) -> bool {
         eq_slice(self, other)
     }
+    #[inline(always)]
+    pure fn ne(&&other: ~str) -> bool { !self.eq(other) }
 }
 
 impl @str: Eq {
     #[inline(always)]
     pure fn eq(&&other: @str) -> bool {
         eq_slice(self, other)
     }
+    #[inline(always)]
+    pure fn ne(&&other: @str) -> bool { !self.eq(other) }
 }
 
 impl ~str : Ord {

src/libcore/task.rs

@@ -85,9 +85,8 @@ enum Task {
 }
 
 impl Task : cmp::Eq {
-    pure fn eq(&&other: Task) -> bool {
-        *self == *other
-    }
+    pure fn eq(&&other: Task) -> bool { *self == *other }
+    pure fn ne(&&other: Task) -> bool { !self.eq(other) }
 }
 
 /**
@@ -113,6 +112,7 @@ impl TaskResult: Eq {
             (Success, _) | (Failure, _) => false
         }
     }
+    pure fn ne(&&other: TaskResult) -> bool { !self.eq(other) }
 }
 
 /// A message type for notifying of task lifecycle events
@@ -131,6 +131,7 @@ impl Notification : cmp::Eq {
             }
         }
     }
+    pure fn ne(&&other: Notification) -> bool { !self.eq(other) }
 }
 
 /// Scheduler modes
@@ -1324,6 +1325,7 @@ impl LocalData: Eq {
         let ptr_b: (uint, uint) = unsafe::reinterpret_cast(&other);
         return ptr_a == ptr_b;
     }
+    pure fn ne(&&other: LocalData) -> bool { !self.eq(other) }
 }
 
 // We use dvec because it's the best data structure in core. If TLS is used

src/libcore/tuple.rs

@@ -81,6 +81,7 @@ impl<A: Eq, B: Eq> (A, B): Eq {
             }
         }
     }
+    pure fn ne(&&other: (A, B)) -> bool { !self.eq(other) }
 }
 
 impl<A: Ord, B: Ord> (A, B): Ord {
@@ -119,6 +120,7 @@ impl<A: Eq, B: Eq, C: Eq> (A, B, C): Eq {
             }
         }
     }
+    pure fn ne(&&other: (A, B, C)) -> bool { !self.eq(other) }
 }
 
 impl<A: Ord, B: Ord, C: Ord> (A, B, C): Ord {

src/libcore/uint-template.rs

@@ -69,9 +69,8 @@ impl T: Ord {
 }
 
 impl T: Eq {
-    pure fn eq(&&other: T) -> bool {
-        return self == other;
-    }
+    pure fn eq(&&other: T) -> bool { return self == other; }
+    pure fn ne(&&other: T) -> bool { return self != other; }
 }
 
 impl T: num::Num {

src/libcore/uniq.rs

@@ -4,6 +4,7 @@ use cmp::{Eq, Ord};
 
 impl<T:Eq> ~const T : Eq {
     pure fn eq(&&other: ~const T) -> bool { *self == *other }
+    pure fn ne(&&other: ~const T) -> bool { *self != *other }
 }
 
 impl<T:Ord> ~const T : Ord {

src/libcore/unit.rs

@@ -6,6 +6,7 @@ use cmp::{Eq, Ord};
 
 impl () : Eq {
     pure fn eq(&&_other: ()) -> bool { true }
+    pure fn ne(&&_other: ()) -> bool { false }
 }
 
 impl () : Ord {

src/libcore/vec.rs

@@ -1406,23 +1406,23 @@ pure fn eq<T: Eq>(a: &[T], b: &[T]) -> bool {
 
 impl<T: Eq> &[T]: Eq {
     #[inline(always)]
-    pure fn eq(&&other: &[T]) -> bool {
-        eq(self, other)
-    }
+    pure fn eq(&&other: &[T]) -> bool { eq(self, other) }
+    #[inline(always)]
+    pure fn ne(&&other: &[T]) -> bool { !self.eq(other) }
 }
 
 impl<T: Eq> ~[T]: Eq {
     #[inline(always)]
-    pure fn eq(&&other: ~[T]) -> bool {
-        eq(self, other)
-    }
+    pure fn eq(&&other: ~[T]) -> bool { eq(self, other) }
+    #[inline(always)]
+    pure fn ne(&&other: ~[T]) -> bool { !self.eq(other) }
 }
 
 impl<T: Eq> @[T]: Eq {
     #[inline(always)]
-    pure fn eq(&&other: @[T]) -> bool {
-        eq(self, other)
-    }
+    pure fn eq(&&other: @[T]) -> bool { eq(self, other) }
+    #[inline(always)]
+    pure fn ne(&&other: @[T]) -> bool { !self.eq(other) }
 }
 
 // Lexicographical comparison

src/libstd/getopts.rs

@@ -124,12 +124,14 @@ impl Name : Eq {
             }
         }
     }
+    pure fn ne(&&other: Name) -> bool { !self.eq(other) }
 }
 
 impl Occur : Eq {
     pure fn eq(&&other: Occur) -> bool {
         (self as uint) == (other as uint)
     }
+    pure fn ne(&&other: Occur) -> bool { !self.eq(other) }
 }
 
 /// Create an option that is required and takes an argument
@@ -449,6 +451,7 @@ impl FailType : Eq {
     pure fn eq(&&other: FailType) -> bool {
         (self as uint) == (other as uint)
     }
+    pure fn ne(&&other: FailType) -> bool { !self.eq(other) }
 }
 
 #[cfg(test)]

src/libstd/json.rs

@@ -609,12 +609,12 @@ impl Error : Eq {
         self.col == other.col &&
         self.msg == other.msg
     }
+    pure fn ne(&&other: Error) -> bool { !self.eq(other) }
 }
 
 impl Json : Eq {
-    pure fn eq(&&other: Json) -> bool {
-        eq(self, other)
-    }
+    pure fn eq(&&other: Json) -> bool { eq(self, other) }
+    pure fn ne(&&other: Json) -> bool { !self.eq(other) }
 }
 
 trait ToJson { fn to_json() -> Json; }

src/libstd/list.rs

@@ -165,6 +165,7 @@ impl<T:Eq> List<T> : Eq {
             }
         }
     }
+    pure fn ne(&&other: List<T>) -> bool { !self.eq(other) }
 }
 
 #[cfg(test)]

src/libstd/net_url.rs

@@ -320,6 +320,7 @@ impl UserInfo : Eq {
     pure fn eq(&&other: UserInfo) -> bool {
         self.user == other.user && self.pass == other.pass
     }
+    pure fn ne(&&other: UserInfo) -> bool { !self.eq(other) }
 }
 
 fn query_from_str(rawquery: &str) -> Query {
@@ -386,6 +387,7 @@ impl Input: Eq {
             (Unreserved, _) => false
         }
     }
+    pure fn ne(&&other: Input) -> bool { !self.eq(other) }
 }
 
 // returns userinfo, host, port, and unparsed part, or an error

src/libstd/test.rs

@@ -96,6 +96,7 @@ impl TestResult : Eq {
     pure fn eq(&&other: TestResult) -> bool {
         (self as uint) == (other as uint)
     }
+    pure fn ne(&&other: TestResult) -> bool { !self.eq(other) }
 }
 
 type ConsoleTestState =