diff options
| author | Alex Crichton <alex@alexcrichton.com> | 2014-05-29 17:45:07 -0700 |
|---|---|---|
| committer | Alex Crichton <alex@alexcrichton.com> | 2014-05-30 15:52:24 -0700 |
| commit | 748bc3ca49de8ab0b890726120c40567094e43fc (patch) | |
| tree | a205dcd5582cbecbb1a02fa3ed1ebfdcc85ff881 /src | |
| parent | f4fa7c8a07a96cc9d0aae0bfc6515fb747f25341 (diff) | |
| download | rust-748bc3ca49de8ab0b890726120c40567094e43fc.tar.gz rust-748bc3ca49de8ab0b890726120c40567094e43fc.zip | |
std: Rename {Eq,Ord} to Partial{Eq,Ord}
This is part of the ongoing renaming of the equality traits. See #12517 for more
details. All code using Eq/Ord will temporarily need to move to Partial{Eq,Ord}
or the Total{Eq,Ord} traits. The Total traits will soon be renamed to {Eq,Ord}.
cc #12517
[breaking-change]
Diffstat (limited to 'src')
256 files changed, 834 insertions, 831 deletions
diff --git a/src/compiletest/common.rs b/src/compiletest/common.rs index 4788229ff79..3df46fde59a 100644 --- a/src/compiletest/common.rs +++ b/src/compiletest/common.rs @@ -12,7 +12,7 @@ use std::from_str::FromStr; use std::fmt; use regex::Regex; -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub enum Mode { CompileFail, RunFail, diff --git a/src/doc/rust.md b/src/doc/rust.md index bf4fd3dcc93..ee37cd2126c 100644 --- a/src/doc/rust.md +++ b/src/doc/rust.md @@ -1436,7 +1436,7 @@ trait Circle : Shape { fn radius() -> f64; } ~~~~ the syntax `Circle : Shape` means that types that implement `Circle` must also have an implementation for `Shape`. -Multiple supertraits are separated by `+`, `trait Circle : Shape + Eq { }`. +Multiple supertraits are separated by `+`, `trait Circle : Shape + PartialEq { }`. In an implementation of `Circle` for a given type `T`, methods can refer to `Shape` methods, since the typechecker checks that any type with an implementation of `Circle` also has an implementation of `Shape`. @@ -2159,23 +2159,23 @@ There are three different types of inline attributes: The `deriving` attribute allows certain traits to be automatically implemented for data structures. For example, the following will -create an `impl` for the `Eq` and `Clone` traits for `Foo`, the type -parameter `T` will be given the `Eq` or `Clone` constraints for the +create an `impl` for the `PartialEq` and `Clone` traits for `Foo`, the type +parameter `T` will be given the `PartialEq` or `Clone` constraints for the appropriate `impl`: ~~~~ -#[deriving(Eq, Clone)] +#[deriving(PartialEq, Clone)] struct Foo<T> { a: int, b: T } ~~~~ -The generated `impl` for `Eq` is equivalent to +The generated `impl` for `PartialEq` is equivalent to ~~~~ # struct Foo<T> { a: int, b: T } -impl<T: Eq> Eq for Foo<T> { +impl<T: PartialEq> PartialEq for Foo<T> { fn eq(&self, other: &Foo<T>) -> bool { self.a == other.a && self.b == other.b } @@ -2188,7 +2188,7 @@ impl<T: Eq> Eq for Foo<T> { Supported traits for `deriving` are: -* Comparison traits: `Eq`, `TotalEq`, `Ord`, `TotalOrd`. +* Comparison traits: `PartialEq`, `TotalEq`, `PartialOrd`, `TotalOrd`. * Serialization: `Encodable`, `Decodable`. These require `serialize`. * `Clone`, to create `T` from `&T` via a copy. * `Hash`, to iterate over the bytes in a data type. @@ -2734,22 +2734,22 @@ The default meaning of the operators on standard types is given here. * `==` : Equal to. - Calls the `eq` method on the `std::cmp::Eq` trait. + Calls the `eq` method on the `std::cmp::PartialEq` trait. * `!=` : Unequal to. - Calls the `ne` method on the `std::cmp::Eq` trait. + Calls the `ne` method on the `std::cmp::PartialEq` trait. * `<` : Less than. - Calls the `lt` method on the `std::cmp::Ord` trait. + Calls the `lt` method on the `std::cmp::PartialOrd` trait. * `>` : Greater than. - Calls the `gt` method on the `std::cmp::Ord` trait. + Calls the `gt` method on the `std::cmp::PartialOrd` trait. * `<=` : Less than or equal. - Calls the `le` method on the `std::cmp::Ord` trait. + Calls the `le` method on the `std::cmp::PartialOrd` trait. * `>=` : Greater than or equal. - Calls the `ge` method on the `std::cmp::Ord` trait. + Calls the `ge` method on the `std::cmp::PartialOrd` trait. #### Type cast expressions diff --git a/src/doc/tutorial.md b/src/doc/tutorial.md index a22256650b8..a4c89436d50 100644 --- a/src/doc/tutorial.md +++ b/src/doc/tutorial.md @@ -61,7 +61,7 @@ There are two ways to install the Rust compiler: by building from source or by downloading prebuilt binaries or installers for your platform. The [install page][rust-install] contains links to download binaries for both the nightly build and the most current Rust major release. For Windows and -OS X, the install page provides links to native installers. +OS X, the install page provides links to native installers. > *Note:* Windows users should read the detailed > [Getting started][wiki-start] notes on the wiki. Even when using @@ -69,8 +69,8 @@ OS X, the install page provides links to native installers. > the precise details of which are not discussed here. For Linux and OS X, the install page provides links to binary tarballs. -To install the Rust compiler from the from a binary tarball, download -the binary package, extract it, and execute the `install.sh` script in +To install the Rust compiler from the from a binary tarball, download +the binary package, extract it, and execute the `install.sh` script in the root directory of the package. To build the Rust compiler from source, you will need to obtain the source through @@ -1303,7 +1303,7 @@ be specified up-front. Our previous definition of list equality relied on the el the `==` operator available, and took advantage of the lack of a destructor on `u32` to copy it without a move of ownership. -We can add a *trait bound* on the `Eq` trait to require that the type implement the `==` operator. +We can add a *trait bound* on the `PartialEq` trait to require that the type implement the `==` operator. Two more `ref` annotations need to be added to avoid attempting to move out the element types: ~~~ @@ -1311,7 +1311,7 @@ Two more `ref` annotations need to be added to avoid attempting to move out the # Cons(T, Box<List<T>>), # Nil # } -fn eq<T: Eq>(xs: &List<T>, ys: &List<T>) -> bool { +fn eq<T: PartialEq>(xs: &List<T>, ys: &List<T>) -> bool { // Match on the next node in both lists. match (xs, ys) { // If we have reached the end of both lists, they are equal. @@ -1329,8 +1329,8 @@ let ys = Cons('c', box Cons('a', box Cons('t', box Nil))); assert!(eq(&xs, &ys)); ~~~ -This would be a good opportunity to implement the `Eq` trait for our list type, making the `==` and -`!=` operators available. We'll need to provide an `impl` for the `Eq` trait and a definition of the +This would be a good opportunity to implement the `PartialEq` trait for our list type, making the `==` and +`!=` operators available. We'll need to provide an `impl` for the `PartialEq` trait and a definition of the `eq` method. In a method, the `self` parameter refers to an instance of the type we're implementing on. @@ -1339,7 +1339,7 @@ on. # Cons(T, Box<List<T>>), # Nil # } -impl<T: Eq> Eq for List<T> { +impl<T: PartialEq> PartialEq for List<T> { fn eq(&self, ys: &List<T>) -> bool { // Match on the next node in both lists. match (self, ys) { @@ -1356,12 +1356,12 @@ impl<T: Eq> Eq for List<T> { let xs = Cons(5, box Cons(10, box Nil)); let ys = Cons(5, box Cons(10, box Nil)); -// The methods below are part of the Eq trait, +// The methods below are part of the PartialEq trait, // which we implemented on our linked list. assert!(xs.eq(&ys)); assert!(!xs.ne(&ys)); -// The Eq trait also allows us to use the shorthand infix operators. +// The PartialEq trait also allows us to use the shorthand infix operators. assert!(xs == ys); // `xs == ys` is short for `xs.eq(&ys)` assert!(!(xs != ys)); // `xs != ys` is short for `xs.ne(&ys)` ~~~ @@ -2345,12 +2345,12 @@ trait describes types that support an equality operation: ~~~~ // In a trait, `self` refers to the self argument. // `Self` refers to the type implementing the trait. -trait Eq { +trait PartialEq { fn equals(&self, other: &Self) -> bool; } // In an impl, `self` refers just to the value of the receiver -impl Eq for int { +impl PartialEq for int { fn equals(&self, other: &int) -> bool { *other == *self } } ~~~~ @@ -2600,13 +2600,13 @@ A small number of traits in `std` and `extra` can have implementations that can be automatically derived. These instances are specified by placing the `deriving` attribute on a data type declaration. For example, the following will mean that `Circle` has an implementation -for `Eq` and can be used with the equality operators, and that a value +for `PartialEq` and can be used with the equality operators, and that a value of type `ABC` can be randomly generated and converted to a string: ~~~ extern crate rand; -#[deriving(Eq)] +#[deriving(PartialEq)] struct Circle { radius: f64 } #[deriving(Rand, Show)] @@ -2618,7 +2618,7 @@ fn main() { } ~~~ -The full list of derivable traits is `Eq`, `TotalEq`, `Ord`, +The full list of derivable traits is `PartialEq`, `TotalEq`, `Ord`, `TotalOrd`, `Encodable`, `Decodable`, `Clone`, `Hash`, `Rand`, `Default`, `Zero`, `FromPrimitive` and `Show`. diff --git a/src/etc/generate-deriving-span-tests.py b/src/etc/generate-deriving-span-tests.py index 51bec8f4c24..7e6bfcdd4ec 100755 --- a/src/etc/generate-deriving-span-tests.py +++ b/src/etc/generate-deriving-span-tests.py @@ -35,7 +35,7 @@ TEMPLATE = """// Copyright {year} The Rust Project Developers. See the COPYRIGHT // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; @@ -117,8 +117,10 @@ traits = { for (trait, supers, errs) in [('Rand', [], 1), ('Clone', [], 1), - ('Eq', [], 2), ('Ord', [], 8), - ('TotalEq', [], 1), ('TotalOrd', ['TotalEq'], 1), + ('PartialEq', [], 2), + ('PartialOrd', ['PartialEq'], 8), + ('TotalEq', ['PartialEq'], 1), + ('TotalOrd', ['TotalEq', 'PartialOrd', 'PartialEq'], 1), ('Show', [], 1), ('Hash', [], 1)]: traits[trait] = (ALL, supers, errs) diff --git a/src/liballoc/owned.rs b/src/liballoc/owned.rs index 114fe4eb0d4..61fff41374b 100644 --- a/src/liballoc/owned.rs +++ b/src/liballoc/owned.rs @@ -12,7 +12,7 @@ use core::any::{Any, AnyRefExt}; use core::clone::Clone; -use core::cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering}; +use core::cmp::{PartialEq, PartialOrd, TotalEq, TotalOrd, Ordering}; use core::default::Default; use core::fmt; use core::intrinsics; @@ -51,13 +51,13 @@ impl<T: Clone> Clone for Box<T> { } // box pointers -impl<T:Eq> Eq for Box<T> { +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) } } -impl<T:Ord> Ord for Box<T> { +impl<T:PartialOrd> PartialOrd for Box<T> { #[inline] fn lt(&self, other: &Box<T>) -> bool { *(*self) < *(*other) } #[inline] diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index 96d90e6ed63..8bf7f64a719 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -26,7 +26,7 @@ pointers, and then storing the parent pointers as `Weak` pointers. use core::mem::transmute; use core::cell::Cell; use core::clone::Clone; -use core::cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering}; +use core::cmp::{PartialEq, PartialOrd, TotalEq, TotalOrd, Ordering}; use core::kinds::marker; use core::ops::{Deref, Drop}; use core::option::{Option, Some, None}; @@ -150,7 +150,7 @@ impl<T> Clone for Rc<T> { } } -impl<T: Eq> Eq for Rc<T> { +impl<T: PartialEq> PartialEq for Rc<T> { #[inline(always)] fn eq(&self, other: &Rc<T>) -> bool { **self == **other } #[inline(always)] @@ -159,7 +159,7 @@ impl<T: Eq> Eq for Rc<T> { impl<T: TotalEq> TotalEq for Rc<T> {} -impl<T: Ord> Ord for Rc<T> { +impl<T: PartialOrd> PartialOrd for Rc<T> { #[inline(always)] fn lt(&self, other: &Rc<T>) -> bool { **self < **other } diff --git a/src/libarena/lib.rs b/src/libarena/lib.rs index 58d8bf289e1..7acef128016 100644 --- a/src/libarena/lib.rs +++ b/src/libarena/lib.rs @@ -43,7 +43,7 @@ use std::rt::heap::allocate; // The way arena uses arrays is really deeply awful. The arrays are // allocated, and have capacities reserved, but the fill for the array // will always stay at 0. -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] struct Chunk { data: Rc<RefCell<Vec<u8> >>, fill: Cell<uint>, diff --git a/src/libcollections/bitv.rs b/src/libcollections/bitv.rs index 54bc6989d7c..c91a5289faa 100644 --- a/src/libcollections/bitv.rs +++ b/src/libcollections/bitv.rs @@ -796,7 +796,7 @@ impl BitvSet { } } -impl cmp::Eq for BitvSet { +impl cmp::PartialEq for BitvSet { fn eq(&self, other: &BitvSet) -> bool { if self.size != other.size { return false; diff --git a/src/libcollections/btree.rs b/src/libcollections/btree.rs index 184a59303f3..e0bb8658c13 100644 --- a/src/libcollections/btree.rs +++ b/src/libcollections/btree.rs @@ -92,7 +92,7 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for BTree<K, V> { } } -impl<K: TotalOrd, V: TotalEq> Eq for BTree<K, V> { +impl<K: TotalOrd, V: TotalEq> PartialEq for BTree<K, V> { fn eq(&self, other: &BTree<K, V>) -> bool { self.root.cmp(&other.root) == Equal } @@ -100,7 +100,7 @@ impl<K: TotalOrd, V: TotalEq> Eq for BTree<K, V> { impl<K: TotalOrd, V: TotalEq> TotalEq for BTree<K, V> {} -impl<K: TotalOrd, V: TotalEq> Ord for BTree<K, V> { +impl<K: TotalOrd, V: TotalEq> PartialOrd for BTree<K, V> { fn lt(&self, other: &BTree<K, V>) -> bool { self.cmp(other) == Less } @@ -198,7 +198,7 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for Node<K, V> { } } -impl<K: TotalOrd, V: TotalEq> Eq for Node<K, V> { +impl<K: TotalOrd, V: TotalEq> PartialEq for Node<K, V> { fn eq(&self, other: &Node<K, V>) -> bool { match *self{ BranchNode(ref branch) => { @@ -222,7 +222,7 @@ impl<K: TotalOrd, V: TotalEq> Eq for Node<K, V> { impl<K: TotalOrd, V: TotalEq> TotalEq for Node<K, V> {} -impl<K: TotalOrd, V: TotalEq> Ord for Node<K, V> { +impl<K: TotalOrd, V: TotalEq> PartialOrd for Node<K, V> { fn lt(&self, other: &Node<K, V>) -> bool { self.cmp(other) == Less } @@ -393,7 +393,7 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for Leaf<K, V> { } } -impl<K: TotalOrd, V: TotalEq> Eq for Leaf<K, V> { +impl<K: TotalOrd, V: TotalEq> PartialEq for Leaf<K, V> { fn eq(&self, other: &Leaf<K, V>) -> bool { self.elts == other.elts } @@ -401,7 +401,7 @@ impl<K: TotalOrd, V: TotalEq> Eq for Leaf<K, V> { impl<K: TotalOrd, V: TotalEq> TotalEq for Leaf<K, V> {} -impl<K: TotalOrd, V: TotalEq> Ord for Leaf<K, V> { +impl<K: TotalOrd, V: TotalEq> PartialOrd for Leaf<K, V> { fn lt(&self, other: &Leaf<K, V>) -> bool { self.cmp(other) == Less } @@ -623,7 +623,7 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for Branch<K, V> { } } -impl<K: TotalOrd, V: TotalEq> Eq for Branch<K, V> { +impl<K: TotalOrd, V: TotalEq> PartialEq for Branch<K, V> { fn eq(&self, other: &Branch<K, V>) -> bool { self.elts == other.elts } @@ -631,7 +631,7 @@ impl<K: TotalOrd, V: TotalEq> Eq for Branch<K, V> { impl<K: TotalOrd, V: TotalEq> TotalEq for Branch<K, V> {} -impl<K: TotalOrd, V: TotalEq> Ord for Branch<K, V> { +impl<K: TotalOrd, V: TotalEq> PartialOrd for Branch<K, V> { fn lt(&self, other: &Branch<K, V>) -> bool { self.cmp(other) == Less } @@ -691,7 +691,7 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for LeafElt<K, V> { } } -impl<K: TotalOrd, V: TotalEq> Eq for LeafElt<K, V> { +impl<K: TotalOrd, V: TotalEq> PartialEq for LeafElt<K, V> { fn eq(&self, other: &LeafElt<K, V>) -> bool { self.key == other.key && self.value == other.value } @@ -699,7 +699,7 @@ impl<K: TotalOrd, V: TotalEq> Eq for LeafElt<K, V> { impl<K: TotalOrd, V: TotalEq> TotalEq for LeafElt<K, V> {} -impl<K: TotalOrd, V: TotalEq> Ord for LeafElt<K, V> { +impl<K: TotalOrd, V: TotalEq> PartialOrd for LeafElt<K, V> { fn lt(&self, other: &LeafElt<K, V>) -> bool { self.cmp(other) == Less } @@ -740,7 +740,7 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for BranchElt<K, V> { } } -impl<K: TotalOrd, V: TotalEq> Eq for BranchElt<K, V>{ +impl<K: TotalOrd, V: TotalEq> PartialEq for BranchElt<K, V>{ fn eq(&self, other: &BranchElt<K, V>) -> bool { self.key == other.key && self.value == other.value } @@ -748,7 +748,7 @@ impl<K: TotalOrd, V: TotalEq> Eq for BranchElt<K, V>{ impl<K: TotalOrd, V: TotalEq> TotalEq for BranchElt<K, V>{} -impl<K: TotalOrd, V: TotalEq> Ord for BranchElt<K, V> { +impl<K: TotalOrd, V: TotalEq> PartialOrd for BranchElt<K, V> { fn lt(&self, other: &BranchElt<K, V>) -> bool { self.cmp(other) == Less } diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index 95729919738..d99474cf5f8 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -572,7 +572,7 @@ impl<A> Extendable<A> for DList<A> { } } -impl<A: Eq> Eq for DList<A> { +impl<A: PartialEq> PartialEq for DList<A> { fn eq(&self, other: &DList<A>) -> bool { self.len() == other.len() && iter::order::eq(self.iter(), other.iter()) @@ -584,7 +584,7 @@ impl<A: Eq> Eq for DList<A> { } } -impl<A: Ord> Ord for DList<A> { +impl<A: PartialOrd> PartialOrd for DList<A> { fn lt(&self, other: &DList<A>) -> bool { iter::order::lt(self.iter(), other.iter()) } diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs index 41501f2d261..797fbbcebf7 100644 --- a/src/libcollections/enum_set.rs +++ b/src/libcollections/enum_set.rs @@ -15,7 +15,7 @@ use std::num::Bitwise; -#[deriving(Clone, Eq, TotalEq, Hash, Show)] +#[deriving(Clone, PartialEq, TotalEq, Hash, Show)] /// A specialized Set implementation to use enum types. pub struct EnumSet<E> { // We must maintain the invariant that no bits are set @@ -141,7 +141,7 @@ mod test { use enum_set::{EnumSet, CLike}; - #[deriving(Eq, Show)] + #[deriving(PartialEq, Show)] #[repr(uint)] enum Foo { A, B, C diff --git a/src/libcollections/hashmap.rs b/src/libcollections/hashmap.rs index c1bc379f0b7..f535e87de5c 100644 --- a/src/libcollections/hashmap.rs +++ b/src/libcollections/hashmap.rs @@ -12,7 +12,7 @@ use std::container::{Container, Mutable, Map, MutableMap, Set, MutableSet}; use std::clone::Clone; -use std::cmp::{Eq, TotalEq, Equiv, max}; +use std::cmp::{PartialEq, TotalEq, Equiv, max}; use std::default::Default; use std::fmt; use std::fmt::Show; @@ -32,7 +32,7 @@ use std::slice::ImmutableVector; mod table { use std::clone::Clone; use std::cmp; - use std::cmp::Eq; + use std::cmp::PartialEq; use std::hash::{Hash, Hasher}; use std::kinds::marker; use std::num::{CheckedMul, is_power_of_two}; @@ -145,7 +145,7 @@ mod table { /// A hash that is not zero, since we use a hash of zero to represent empty /// buckets. - #[deriving(Eq)] + #[deriving(PartialEq)] pub struct SafeHash { hash: u64, } @@ -661,8 +661,8 @@ static INITIAL_LOAD_FACTOR: Fraction = (9, 10); /// denial-of-service attacks (Hash DoS). This behaviour can be /// overridden with one of the constructors. /// -/// It is required that the keys implement the `Eq` and `Hash` traits, although -/// this can frequently be achieved by using `#[deriving(Eq, Hash)]`. +/// It is required that the keys implement the `PartialEq` and `Hash` traits, although +/// this can frequently be achieved by using `#[deriving(PartialEq, Hash)]`. /// /// Relevant papers/articles: /// @@ -1402,7 +1402,7 @@ impl<K: TotalEq + Hash<S>, V: Clone, S, H: Hasher<S>> HashMap<K, V, H> { } } -impl<K: TotalEq + Hash<S>, V: Eq, S, H: Hasher<S>> Eq for HashMap<K, V, H> { +impl<K: TotalEq + Hash<S>, V: PartialEq, S, H: Hasher<S>> PartialEq for HashMap<K, V, H> { fn eq(&self, other: &HashMap<K, V, H>) -> bool { if self.len() != other.len() { return false; } @@ -1480,13 +1480,13 @@ pub type SetMoveItems<K> = /// An implementation of a hash set using the underlying representation of a /// HashMap where the value is (). As with the `HashMap` type, a `HashSet` -/// requires that the elements implement the `Eq` and `Hash` traits. +/// requires that the elements implement the `PartialEq` and `Hash` traits. #[deriving(Clone)] pub struct HashSet<T, H = sip::SipHasher> { map: HashMap<T, (), H> } -impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> Eq for HashSet<T, H> { +impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> PartialEq for HashSet<T, H> { fn eq(&self, other: &HashSet<T, H>) -> bool { if self.len() != other.len() { return false; } @@ -1691,7 +1691,7 @@ mod test_map { local_data_key!(drop_vector: RefCell<Vec<int>>) - #[deriving(Hash, Eq, TotalEq)] + #[deriving(Hash, PartialEq, TotalEq)] struct Dropable { k: uint } diff --git a/src/libcollections/lru_cache.rs b/src/libcollections/lru_cache.rs index 7db3525a36e..7c8513bac32 100644 --- a/src/libcollections/lru_cache.rs +++ b/src/libcollections/lru_cache.rs @@ -67,7 +67,7 @@ impl<S, K: Hash<S>> Hash<S> for KeyRef<K> { } } -impl<K: Eq> Eq for KeyRef<K> { +impl<K: PartialEq> PartialEq for KeyRef<K> { fn eq(&self, other: &KeyRef<K>) -> bool { unsafe{ (*self.k).eq(&*other.k) } } @@ -253,7 +253,7 @@ impl<K, V> Drop for LruCache<K, V> { mod tests { use super::LruCache; - fn assert_opt_eq<V: Eq>(opt: Option<&V>, v: V) { + fn assert_opt_eq<V: PartialEq>(opt: Option<&V>, v: V) { assert!(opt.is_some()); assert!(opt.unwrap() == &v); } diff --git a/src/libcollections/ringbuf.rs b/src/libcollections/ringbuf.rs index f45c9685be5..0ca4177b7aa 100644 --- a/src/libcollections/ringbuf.rs +++ b/src/libcollections/ringbuf.rs @@ -364,7 +364,7 @@ fn raw_index(lo: uint, len: uint, index: uint) -> uint { } } -impl<A: Eq> Eq for RingBuf<A> { +impl<A: PartialEq> PartialEq for RingBuf<A> { fn eq(&self, other: &RingBuf<A>) -> bool { self.nelts == other.nelts && self.iter().zip(other.iter()).all(|(a, b)| a.eq(b)) @@ -397,7 +397,7 @@ mod tests { use self::test::Bencher; use deque::Deque; use std::clone::Clone; - use std::cmp::Eq; + use std::cmp::PartialEq; use std::fmt::Show; use super::RingBuf; @@ -483,7 +483,7 @@ mod tests { } #[cfg(test)] - fn test_parameterized<T:Clone + Eq + Show>(a: T, b: T, c: T, d: T) { + fn test_parameterized<T:Clone + PartialEq + Show>(a: T, b: T, c: T, d: T) { let mut deq = RingBuf::new(); assert_eq!(deq.len(), 0); deq.push_front(a.clone()); @@ -568,21 +568,21 @@ mod tests { }) } - #[deriving(Clone, Eq, Show)] + #[deriving(Clone, PartialEq, Show)] enum Taggy { One(int), Two(int, int), Three(int, int, int), } - #[deriving(Clone, Eq, Show)] + #[deriving(Clone, PartialEq, Show)] enum Taggypar<T> { Onepar(int), Twopar(int, int), Threepar(int, int, int), } - #[deriving(Clone, Eq, Show)] + #[deriving(Clone, PartialEq, Show)] struct RecCy { x: int, y: int, diff --git a/src/libcollections/treemap.rs b/src/libcollections/treemap.rs index 793b562b582..98816003a37 100644 --- a/src/libcollections/treemap.rs +++ b/src/libcollections/treemap.rs @@ -43,7 +43,7 @@ pub struct TreeMap<K, V> { length: uint } -impl<K: Eq + TotalOrd, V: Eq> Eq for TreeMap<K, V> { +impl<K: PartialEq + TotalOrd, V: PartialEq> PartialEq for TreeMap<K, V> { fn eq(&self, other: &TreeMap<K, V>) -> bool { self.len() == other.len() && self.iter().zip(other.iter()).all(|(a, b)| a == b) @@ -51,7 +51,7 @@ impl<K: Eq + TotalOrd, V: Eq> Eq for TreeMap<K, V> { } // Lexicographical comparison -fn lt<K: Ord + TotalOrd, V: Ord>(a: &TreeMap<K, V>, +fn lt<K: PartialOrd + TotalOrd, V: PartialOrd>(a: &TreeMap<K, V>, b: &TreeMap<K, V>) -> bool { // the Zip iterator is as long as the shortest of a and b. for ((key_a, value_a), (key_b, value_b)) in a.iter().zip(b.iter()) { @@ -64,7 +64,7 @@ fn lt<K: Ord + TotalOrd, V: Ord>(a: &TreeMap<K, V>, a.len() < b.len() } -impl<K: Ord + TotalOrd, V: Ord> Ord for TreeMap<K, V> { +impl<K: PartialOrd + TotalOrd, V: PartialOrd> PartialOrd for TreeMap<K, V> { #[inline] fn lt(&self, other: &TreeMap<K, V>) -> bool { lt(self, other) } } @@ -552,12 +552,12 @@ pub struct TreeSet<T> { map: TreeMap<T, ()> } -impl<T: Eq + TotalOrd> Eq for TreeSet<T> { +impl<T: PartialEq + TotalOrd> PartialEq for TreeSet<T> { #[inline] fn eq(&self, other: &TreeSet<T>) -> bool { self.map == other.map } } -impl<T: Ord + TotalOrd> Ord for TreeSet<T> { +impl<T: PartialOrd + TotalOrd> PartialOrd for TreeSet<T> { #[inline] fn lt(&self, other: &TreeSet<T>) -> bool { self.map < other.map } } @@ -1070,7 +1070,7 @@ mod test_treemap { assert_eq!(m.find(&k1), Some(&v1)); } - fn check_equal<K: Eq + TotalOrd, V: Eq>(ctrl: &[(K, V)], + fn check_equal<K: PartialEq + TotalOrd, V: PartialEq>(ctrl: &[(K, V)], map: &TreeMap<K, V>) { assert_eq!(ctrl.is_empty(), map.is_empty()); for x in ctrl.iter() { diff --git a/src/libcore/any.rs b/src/libcore/any.rs index f463c194424..2a03eacf13c 100644 --- a/src/libcore/any.rs +++ b/src/libcore/any.rs @@ -121,7 +121,7 @@ mod tests { use realstd::owned::{Box, AnyOwnExt}; use realstd::str::Str; - #[deriving(Eq, Show)] + #[deriving(PartialEq, Show)] struct Test; static TEST: &'static str = "Test"; diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index e03e24e606d..f6c438698b4 100644 --- a/src/libcore/cell.rs +++ b/src/libcore/cell.rs @@ -160,7 +160,7 @@ // FIXME: Relationship to Atomic types and RWLock use clone::Clone; -use cmp::Eq; +use cmp::PartialEq; use kinds::{marker, Copy}; use ops::{Deref, DerefMut, Drop}; use option::{None, Option, Some}; @@ -202,7 +202,7 @@ impl<T:Copy> Clone for Cell<T> { } } -impl<T:Eq + Copy> Eq for Cell<T> { +impl<T:PartialEq + Copy> PartialEq for Cell<T> { fn eq(&self, other: &Cell<T>) -> bool { self.get() == other.get() } @@ -308,7 +308,7 @@ impl<T: Clone> Clone for RefCell<T> { } } -impl<T: Eq> Eq for RefCell<T> { +impl<T: PartialEq> PartialEq for RefCell<T> { fn eq(&self, other: &RefCell<T>) -> bool { *self.borrow() == *other.borrow() } diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index 32fc3331fa2..5bf15ff18f0 100644 --- a/src/libcore/cmp.rs +++ b/src/libcore/cmp.rs @@ -8,14 +8,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -//! Defines the `Ord` and `Eq` comparison traits. +//! Defines the `PartialOrd` and `PartialEq` comparison traits. //! -//! This module defines both `Ord` and `Eq` traits which are used by the +//! This module defines both `PartialOrd` and `PartialEq` traits which are used by the //! compiler to implement comparison operators. Rust programs may implement -//!`Ord` to overload the `<`, `<=`, `>`, and `>=` operators, and may implement -//! `Eq` to overload the `==` and `!=` operators. +//!`PartialOrd` to overload the `<`, `<=`, `>`, and `>=` operators, and may implement +//! `PartialEq` to overload the `==` and `!=` operators. //! -//! For example, to define a type with a customized definition for the Eq +//! For example, to define a type with a customized definition for the PartialEq //! operators, you could do the following: //! //! ```rust @@ -24,8 +24,8 @@ //! num : int //! } //! -//! // Our implementation of `Eq` to support `==` and `!=`. -//! impl Eq for SketchyNum { +//! // Our implementation of `PartialEq` to support `==` and `!=`. +//! impl PartialEq for SketchyNum { //! // Our custom eq allows numbers which are near each other to be equal! :D //! fn eq(&self, other: &SketchyNum) -> bool { //! (self.num - other.num).abs() < 5 @@ -37,9 +37,6 @@ //! assert!(SketchyNum {num: 25} != SketchyNum {num: 57}); //! ``` -pub use PartialEq = cmp::Eq; -pub use PartialOrd = cmp::Ord; - /// Trait for values that can be compared for equality and inequality. /// /// This trait allows partial equality, where types can be unordered instead of @@ -47,13 +44,13 @@ pub use PartialOrd = cmp::Ord; /// 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). /// -/// Eq only requires the `eq` method to be implemented; `ne` is its negation by +/// PartialEq only requires the `eq` method to be implemented; `ne` is its negation by /// default. /// /// Eventually, this will be implemented by default for types that implement /// `TotalEq`. #[lang="eq"] -pub trait Eq { +pub trait PartialEq { /// This method tests for `self` and `other` values to be equal, and is used by `==`. fn eq(&self, other: &Self) -> bool; @@ -71,7 +68,7 @@ pub trait Eq { /// - reflexive: `a == a`; /// - symmetric: `a == b` implies `b == a`; and /// - transitive: `a == b` and `b == c` implies `a == c`. -pub trait TotalEq: Eq { +pub trait TotalEq: PartialEq { // FIXME #13101: this method is used solely by #[deriving] to // assert that every component of a type implements #[deriving] // itself, the current deriving infrastructure means doing this @@ -85,7 +82,7 @@ pub trait TotalEq: Eq { } /// An ordering is, e.g, a result of a comparison between two values. -#[deriving(Clone, Eq, Show)] +#[deriving(Clone, PartialEq, Show)] pub enum Ordering { /// An ordering where a compared value is less [than another]. Less = -1, @@ -104,7 +101,7 @@ pub enum Ordering { /// true; and /// - transitive, `a < b` and `b < c` implies `a < c`. The same must hold for /// both `==` and `>`. -pub trait TotalOrd: TotalEq + Ord { +pub trait TotalOrd: TotalEq + PartialOrd { /// This method returns an ordering between `self` and `other` values. /// /// By convention, `self.cmp(&other)` returns the ordering matching @@ -127,7 +124,7 @@ impl TotalOrd for Ordering { } } -impl Ord for Ordering { +impl PartialOrd for Ordering { #[inline] fn lt(&self, other: &Ordering) -> bool { (*self as int) < (*other as int) } } @@ -147,14 +144,14 @@ pub fn lexical_ordering(o1: Ordering, o2: Ordering) -> Ordering { /// Trait for values that can be compared for a sort-order. /// -/// Ord only requires implementation of the `lt` method, +/// PartialOrd only requires implementation of the `lt` method, /// with the others generated from default implementations. /// /// However it remains possible to implement the others separately, /// for compatibility with floating-point NaN semantics /// (cf. IEEE 754-2008 section 5.11). #[lang="ord"] -pub trait Ord: Eq { +pub trait PartialOrd: PartialEq { /// This method tests less than (for `self` and `other`) and is used by the `<` operator. fn lt(&self, other: &Self) -> bool; @@ -192,14 +189,15 @@ pub fn max<T: TotalOrd>(v1: T, v2: T) -> T { if v1 > v2 { v1 } else { v2 } } -// Implementation of Eq, TotalEq, Ord and TotalOrd for primitive types +// Implementation of PartialEq, TotalEq, PartialOrd and TotalOrd for primitive types #[cfg(not(test))] mod impls { - use cmp::{Ord, TotalOrd, Eq, TotalEq, Ordering, Less, Greater, Equal}; + use cmp::{PartialOrd, TotalOrd, PartialEq, TotalEq, Ordering, + Less, Greater, Equal}; macro_rules! eq_impl( ($($t:ty)*) => ($( - impl Eq for $t { + impl PartialEq for $t { #[inline] fn eq(&self, other: &$t) -> bool { (*self) == (*other) } #[inline] @@ -208,7 +206,7 @@ mod impls { )*) ) - impl Eq for () { + impl PartialEq for () { #[inline] fn eq(&self, _other: &()) -> bool { true } #[inline] @@ -227,7 +225,7 @@ mod impls { macro_rules! ord_impl( ($($t:ty)*) => ($( - impl Ord for $t { + impl PartialOrd for $t { #[inline] fn lt(&self, other: &$t) -> bool { (*self) < (*other) } #[inline] @@ -240,12 +238,12 @@ mod impls { )*) ) - impl Ord for () { + impl PartialOrd for () { #[inline] fn lt(&self, _other: &()) -> bool { false } } - impl Ord for bool { + impl PartialOrd for bool { #[inline] fn lt(&self, other: &bool) -> bool { (*self as u8) < (*other as u8) @@ -282,13 +280,13 @@ mod impls { totalord_impl!(char uint u8 u16 u32 u64 int i8 i16 i32 i64) // & pointers - impl<'a, T: Eq> Eq for &'a T { + impl<'a, T: PartialEq> PartialEq for &'a T { #[inline] fn eq(&self, other: & &'a T) -> bool { *(*self) == *(*other) } #[inline] fn ne(&self, other: & &'a T) -> bool { *(*self) != *(*other) } } - impl<'a, T: Ord> Ord for &'a T { + impl<'a, T: PartialOrd> PartialOrd for &'a T { #[inline] fn lt(&self, other: & &'a T) -> bool { *(*self) < *(*other) } #[inline] @@ -305,13 +303,13 @@ mod impls { impl<'a, T: TotalEq> TotalEq for &'a T {} // &mut pointers - impl<'a, T: Eq> Eq for &'a mut T { + impl<'a, T: PartialEq> PartialEq for &'a mut T { #[inline] fn eq(&self, other: &&'a mut T) -> bool { **self == *(*other) } #[inline] fn ne(&self, other: &&'a mut T) -> bool { **self != *(*other) } } - impl<'a, T: Ord> Ord for &'a mut T { + impl<'a, T: PartialOrd> PartialOrd for &'a mut T { #[inline] fn lt(&self, other: &&'a mut T) -> bool { **self < **other } #[inline] @@ -328,13 +326,13 @@ mod impls { impl<'a, T: TotalEq> TotalEq for &'a mut T {} // @ pointers - impl<T:Eq> Eq for @T { + impl<T:PartialEq> PartialEq for @T { #[inline] fn eq(&self, other: &@T) -> bool { *(*self) == *(*other) } #[inline] fn ne(&self, other: &@T) -> bool { *(*self) != *(*other) } } - impl<T:Ord> Ord for @T { + impl<T:PartialOrd> PartialOrd for @T { #[inline] fn lt(&self, other: &@T) -> bool { *(*self) < *(*other) } #[inline] @@ -400,8 +398,8 @@ mod test { num : int } - // Our implementation of `Eq` to support `==` and `!=`. - impl Eq for SketchyNum { + // Our implementation of `PartialEq` to support `==` and `!=`. + impl PartialEq for SketchyNum { // Our custom eq allows numbers which are near each other to be equal! :D fn eq(&self, other: &SketchyNum) -> bool { (self.num - other.num).abs() < 5 diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index 7ad78df2fe8..890733dc229 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -65,23 +65,23 @@ trait GenericRadix { } /// A binary (base 2) radix -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] struct Binary; /// An octal (base 8) radix -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] struct Octal; /// A decimal (base 10) radix -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] struct Decimal; /// A hexadecimal (base 16) radix, formatted with lower-case characters -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] struct LowerHex; /// A hexadecimal (base 16) radix, formatted with upper-case characters -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub struct UpperHex; macro_rules! radix { @@ -108,7 +108,7 @@ radix!(UpperHex, 16, "0x", x @ 0 .. 9 => '0' as u8 + x, x @ 10 ..15 => 'A' as u8 + (x - 10)) /// A radix with in the range of `2..36`. -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub struct Radix { base: u8, } diff --git a/src/libcore/fmt/rt.rs b/src/libcore/fmt/rt.rs index 00c8661c8e3..f2e1476cc1c 100644 --- a/src/libcore/fmt/rt.rs +++ b/src/libcore/fmt/rt.rs @@ -40,7 +40,7 @@ pub struct FormatSpec { pub width: Count, } -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum Alignment { AlignLeft, AlignRight, diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs index 095c48c818b..b36735713af 100644 --- a/src/libcore/intrinsics.rs +++ b/src/libcore/intrinsics.rs @@ -550,7 +550,7 @@ extern "rust-intrinsic" { /// `TypeId` represents a globally unique identifier for a type #[lang="type_id"] // This needs to be kept in lockstep with the code in trans/intrinsic.rs and // middle/lang_items.rs -#[deriving(Eq, TotalEq, Show)] +#[deriving(PartialEq, TotalEq, Show)] #[cfg(not(test))] pub struct TypeId { t: u64, diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index e58ef49c17f..e18244280bf 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -68,7 +68,7 @@ use cmp; use num::{Zero, One, CheckedAdd, CheckedSub, Saturating, ToPrimitive, Int}; use option::{Option, Some, None}; use ops::{Add, Mul, Sub}; -use cmp::{Eq, Ord, TotalOrd}; +use cmp::{PartialEq, PartialOrd, TotalOrd}; use clone::Clone; use uint; use mem; @@ -847,7 +847,7 @@ impl<A: Mul<A, A> + One, T: Iterator<A>> MultiplicativeIterator<A> for T { } /// A trait for iterators over elements which can be compared to one another. -/// The type of each element must ascribe to the `Ord` trait. +/// The type of each element must ascribe to the `PartialOrd` trait. pub trait OrdIterator<A> { /// Consumes the entire iterator to return the maximum element. /// @@ -971,7 +971,7 @@ impl<A: TotalOrd, T: Iterator<A>> OrdIterator<A> for T { } /// `MinMaxResult` is an enum returned by `min_max`. See `OrdIterator::min_max` for more detail. -#[deriving(Clone, Eq, Show)] +#[deriving(Clone, PartialEq, Show)] pub enum MinMaxResult<T> { /// Empty iterator NoElements, @@ -1945,12 +1945,12 @@ pub struct Range<A> { /// Return an iterator over the range [start, stop) #[inline] -pub fn range<A: Add<A, A> + Ord + Clone + One>(start: A, stop: A) -> Range<A> { +pub fn range<A: Add<A, A> + PartialOrd + Clone + One>(start: A, stop: A) -> Range<A> { Range{state: start, stop: stop, one: One::one()} } // FIXME: #10414: Unfortunate type bound -impl<A: Add<A, A> + Ord + Clone + ToPrimitive> Iterator<A> for Range<A> { +impl<A: Add<A, A> + PartialOrd + Clone + ToPrimitive> Iterator<A> for Range<A> { #[inline] fn next(&mut self) -> Option<A> { if self.state < self.stop { @@ -1997,7 +1997,7 @@ impl<A: Add<A, A> + Ord + Clone + ToPrimitive> Iterator<A> for Range<A> { /// `Int` is required to ensure the range will be the same regardless of /// the direction it is consumed. -impl<A: Int + Ord + Clone + ToPrimitive> DoubleEndedIterator<A> for Range<A> { +impl<A: Int + PartialOrd + Clone + ToPrimitive> DoubleEndedIterator<A> for Range<A> { #[inline] fn next_back(&mut self) -> Option<A> { if self.stop > self.state { @@ -2018,12 +2018,12 @@ pub struct RangeInclusive<A> { /// Return an iterator over the range [start, stop] #[inline] -pub fn range_inclusive<A: Add<A, A> + Ord + Clone + One>(start: A, stop: A) +pub fn range_inclusive<A: Add<A, A> + PartialOrd + Clone + One>(start: A, stop: A) -> RangeInclusive<A> { RangeInclusive{range: range(start, stop), done: false} } -impl<A: Add<A, A> + Ord + Clone + ToPrimitive> Iterator<A> for RangeInclusive<A> { +impl<A: Add<A, A> + PartialOrd + Clone + ToPrimitive> Iterator<A> for RangeInclusive<A> { #[inline] fn next(&mut self) -> Option<A> { match self.range.next() { @@ -2055,7 +2055,7 @@ impl<A: Add<A, A> + Ord + Clone + ToPrimitive> Iterator<A> for RangeInclusive<A> } } -impl<A: Sub<A, A> + Int + Ord + Clone + ToPrimitive> DoubleEndedIterator<A> +impl<A: Sub<A, A> + Int + PartialOrd + Clone + ToPrimitive> DoubleEndedIterator<A> for RangeInclusive<A> { #[inline] fn next_back(&mut self) -> Option<A> { @@ -2083,12 +2083,12 @@ pub struct RangeStep<A> { /// Return an iterator over the range [start, stop) by `step`. It handles overflow by stopping. #[inline] -pub fn range_step<A: CheckedAdd + Ord + Clone + Zero>(start: A, stop: A, step: A) -> RangeStep<A> { +pub fn range_step<A: CheckedAdd + PartialOrd + Clone + Zero>(start: A, stop: A, step: A) -> RangeStep<A> { let rev = step < Zero::zero(); RangeStep{state: start, stop: stop, step: step, rev: rev} } -impl<A: CheckedAdd + Ord + Clone> Iterator<A> for RangeStep<A> { +impl<A: CheckedAdd + PartialOrd + Clone> Iterator<A> for RangeStep<A> { #[inline] fn next(&mut self) -> Option<A> { if (self.rev && self.state > self.stop) || (!self.rev && self.state < self.stop) { @@ -2116,13 +2116,13 @@ pub struct RangeStepInclusive<A> { /// Return an iterator over the range [start, stop] by `step`. It handles overflow by stopping. #[inline] -pub fn range_step_inclusive<A: CheckedAdd + Ord + Clone + Zero>(start: A, stop: A, +pub fn range_step_inclusive<A: CheckedAdd + PartialOrd + Clone + Zero>(start: A, stop: A, step: A) -> RangeStepInclusive<A> { let rev = step < Zero::zero(); RangeStepInclusive{state: start, stop: stop, step: step, rev: rev, done: false} } -impl<A: CheckedAdd + Ord + Clone + Eq> Iterator<A> for RangeStepInclusive<A> { +impl<A: CheckedAdd + PartialOrd + Clone + PartialEq> Iterator<A> for RangeStepInclusive<A> { #[inline] fn next(&mut self) -> Option<A> { if !self.done && ((self.rev && self.state >= self.stop) || @@ -2175,13 +2175,13 @@ impl<A: Clone> RandomAccessIterator<A> for Repeat<A> { /// Functions for lexicographical ordering of sequences. /// /// Lexicographical ordering through `<`, `<=`, `>=`, `>` requires -/// that the elements implement both `Eq` and `Ord`. +/// that the elements implement both `PartialEq` and `PartialOrd`. /// /// If two sequences are equal up until the point where one ends, /// the shorter sequence compares less. pub mod order { use cmp; - use cmp::{TotalEq, TotalOrd, Ord, Eq}; + use cmp::{TotalEq, TotalOrd, PartialOrd, PartialEq}; use option::{Some, None}; use super::Iterator; @@ -2211,8 +2211,8 @@ pub mod order { } } - /// Compare `a` and `b` for equality (Using partial equality, `Eq`) - pub fn eq<A: Eq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { + /// Compare `a` and `b` for equality (Using partial equality, `PartialEq`) + pub fn eq<A: PartialEq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { loop { match (a.next(), b.next()) { (None, None) => return true, @@ -2222,8 +2222,8 @@ pub mod order { } } - /// Compare `a` and `b` for nonequality (Using partial equality, `Eq`) - pub fn ne<A: Eq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { + /// Compare `a` and `b` for nonequality (Using partial equality, `PartialEq`) + pub fn ne<A: PartialEq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { loop { match (a.next(), b.next()) { (None, None) => return false, @@ -2233,8 +2233,8 @@ pub mod order { } } - /// Return `a` < `b` lexicographically (Using partial order, `Ord`) - pub fn lt<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { + /// Return `a` < `b` lexicographically (Using partial order, `PartialOrd`) + pub fn lt<A: PartialOrd, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { loop { match (a.next(), b.next()) { (None, None) => return false, @@ -2245,8 +2245,8 @@ pub mod order { } } - /// Return `a` <= `b` lexicographically (Using partial order, `Ord`) - pub fn le<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { + /// Return `a` <= `b` lexicographically (Using partial order, `PartialOrd`) + pub fn le<A: PartialOrd, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { loop { match (a.next(), b.next()) { (None, None) => return true, @@ -2257,8 +2257,8 @@ pub mod order { } } - /// Return `a` > `b` lexicographically (Using partial order, `Ord`) - pub fn gt<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { + /// Return `a` > `b` lexicographically (Using partial order, `PartialOrd`) + pub fn gt<A: PartialOrd, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { loop { match (a.next(), b.next()) { (None, None) => return false, @@ -2269,8 +2269,8 @@ pub mod order { } } - /// Return `a` >= `b` lexicographically (Using partial order, `Ord`) - pub fn ge<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { + /// Return `a` >= `b` lexicographically (Using partial order, `PartialOrd`) + pub fn ge<A: PartialOrd, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { loop { match (a.next(), b.next()) { (None, None) => return true, @@ -2849,7 +2849,7 @@ mod tests { #[cfg(test)] - fn check_randacc_iter<A: Eq, T: Clone + RandomAccessIterator<A>>(a: T, len: uint) + fn check_randacc_iter<A: PartialEq, T: Clone + RandomAccessIterator<A>>(a: T, len: uint) { let mut b = a.clone(); assert_eq!(len, b.indexable()); @@ -3009,13 +3009,13 @@ mod tests { } } - impl Eq for Foo { + impl PartialEq for Foo { fn eq(&self, _: &Foo) -> bool { true } } - impl Ord for Foo { + impl PartialOrd for Foo { fn lt(&self, _: &Foo) -> bool { false } diff --git a/src/libcore/kinds.rs b/src/libcore/kinds.rs index 770aa7547ff..40b716181e6 100644 --- a/src/libcore/kinds.rs +++ b/src/libcore/kinds.rs @@ -133,7 +133,7 @@ pub mod marker { /// (for example, `S<&'static int>` is a subtype of `S<&'a int>` /// for some lifetime `'a`, but not the other way around). #[lang="covariant_type"] - #[deriving(Eq,Clone)] + #[deriving(PartialEq,Clone)] pub struct CovariantType<T>; /// A marker type whose type parameter `T` is considered to be @@ -176,7 +176,7 @@ pub mod marker { /// function requires arguments of type `T`, it must also accept /// arguments of type `U`, hence such a conversion is safe. #[lang="contravariant_type"] - #[deriving(Eq,Clone)] + #[deriving(PartialEq,Clone)] pub struct ContravariantType<T>; /// A marker type whose type parameter `T` is considered to be @@ -201,7 +201,7 @@ pub mod marker { /// never written, but in fact `Cell` uses unsafe code to achieve /// interior mutability. #[lang="invariant_type"] - #[deriving(Eq,Clone)] + #[deriving(PartialEq,Clone)] pub struct InvariantType<T>; /// As `CovariantType`, but for lifetime parameters. Using @@ -221,7 +221,7 @@ pub mod marker { /// For more information about variance, refer to this Wikipedia /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>. #[lang="covariant_lifetime"] - #[deriving(Eq,Clone)] + #[deriving(PartialEq,Clone)] pub struct CovariantLifetime<'a>; /// As `ContravariantType`, but for lifetime parameters. Using @@ -237,7 +237,7 @@ pub mod marker { /// For more information about variance, refer to this Wikipedia /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>. #[lang="contravariant_lifetime"] - #[deriving(Eq,Clone)] + #[deriving(PartialEq,Clone)] pub struct ContravariantLifetime<'a>; /// As `InvariantType`, but for lifetime parameters. Using @@ -248,7 +248,7 @@ pub mod marker { /// and this pointer is itself stored in an inherently mutable /// location (such as a `Cell`). #[lang="invariant_lifetime"] - #[deriving(Eq,Clone)] + #[deriving(PartialEq,Clone)] pub struct InvariantLifetime<'a>; /// A type which is considered "not sendable", meaning that it cannot @@ -256,26 +256,26 @@ pub mod marker { /// typically embedded in other types, such as `Gc`, to ensure that /// their instances remain thread-local. #[lang="no_send_bound"] - #[deriving(Eq,Clone)] + #[deriving(PartialEq,Clone)] pub struct NoSend; /// A type which is considered "not POD", meaning that it is not /// implicitly copyable. This is typically embedded in other types to /// ensure that they are never copied, even if they lack a destructor. #[lang="no_copy_bound"] - #[deriving(Eq,Clone)] + #[deriving(PartialEq,Clone)] pub struct NoCopy; /// A type which is considered "not shareable", meaning that /// its contents are not threadsafe, hence they cannot be /// shared between tasks. #[lang="no_share_bound"] - #[deriving(Eq,Clone)] + #[deriving(PartialEq,Clone)] pub struct NoShare; /// A type which is considered managed by the GC. This is typically /// embedded in other types. #[lang="managed_bound"] - #[deriving(Eq,Clone)] + #[deriving(PartialEq,Clone)] pub struct Managed; } diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index fe3f07c6024..a80b20775de 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -17,7 +17,7 @@ use {int, i8, i16, i32, i64}; use {uint, u8, u16, u32, u64}; use {f32, f64}; use clone::Clone; -use cmp::{Eq, Ord}; +use cmp::{PartialEq, PartialOrd}; use kinds::Copy; use mem::size_of; use ops::{Add, Sub, Mul, Div, Rem, Neg}; @@ -25,7 +25,7 @@ use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr}; use option::{Option, Some, None}; /// The base trait for numeric types -pub trait Num: Eq + Zero + One +pub trait Num: PartialEq + Zero + One + Neg<Self> + Add<Self,Self> + Sub<Self,Self> @@ -495,7 +495,7 @@ pub trait Primitive: Copy + Clone + Num + NumCast - + Ord + + PartialOrd + Bounded {} trait_impl!(Primitive for uint u8 u16 u32 u64 int i8 i16 i32 i64 f32 f64) @@ -1043,7 +1043,7 @@ pub trait Saturating { fn saturating_sub(self, v: Self) -> Self; } -impl<T: CheckedAdd + CheckedSub + Zero + Ord + Bounded> Saturating for T { +impl<T: CheckedAdd + CheckedSub + Zero + PartialOrd + Bounded> Saturating for T { #[inline] fn saturating_add(self, v: T) -> T { match self.checked_add(&v) { @@ -1238,7 +1238,7 @@ pub fn test_num<T:Num + NumCast + ::std::fmt::Show>(ten: T, two: T) { } /// Used for representing the classification of floating point numbers -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] pub enum FPCategory { /// "Not a Number", often obtained by dividing by zero FPNaN, diff --git a/src/libcore/option.rs b/src/libcore/option.rs index 975736cb40c..379d14a6e6a 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -141,14 +141,14 @@ //! } //! ``` -use cmp::{Eq, TotalEq, TotalOrd}; +use cmp::{PartialEq, TotalEq, TotalOrd}; use default::Default; use iter::{Iterator, DoubleEndedIterator, FromIterator, ExactSize}; use mem; use slice; /// The `Option` -#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd, Show)] +#[deriving(Clone, PartialEq, PartialOrd, TotalEq, TotalOrd, Show)] pub enum Option<T> { /// No value None, diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs index a8e78e52b12..466f981c926 100644 --- a/src/libcore/prelude.rs +++ b/src/libcore/prelude.rs @@ -45,7 +45,8 @@ pub use mem::drop; pub use char::Char; pub use clone::Clone; -pub use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater, Equiv}; +pub use cmp::{PartialEq, PartialOrd, TotalEq, TotalOrd}; +pub use cmp::{Ordering, Less, Equal, Greater, Equiv}; pub use container::{Container, Mutable, Map, MutableMap, Set, MutableSet}; pub use iter::{FromIterator, Extendable}; pub use iter::{Iterator, DoubleEndedIterator, RandomAccessIterator, CloneableIterator}; diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index 34596480273..442838b3d08 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -93,7 +93,7 @@ use intrinsics; use iter::{range, Iterator}; use option::{Some, None, Option}; -#[cfg(not(test))] use cmp::{Eq, TotalEq, Ord, Equiv}; +#[cfg(not(test))] use cmp::{PartialEq, TotalEq, PartialOrd, Equiv}; /// Return the offset of the first null pointer in `buf`. #[inline] @@ -386,7 +386,7 @@ impl<T> RawPtr<T> for *mut T { // Equality for pointers #[cfg(not(test))] -impl<T> Eq for *T { +impl<T> PartialEq for *T { #[inline] fn eq(&self, other: &*T) -> bool { *self == *other @@ -399,7 +399,7 @@ impl<T> Eq for *T { impl<T> TotalEq for *T {} #[cfg(not(test))] -impl<T> Eq for *mut T { +impl<T> PartialEq for *mut T { #[inline] fn eq(&self, other: &*mut T) -> bool { *self == *other @@ -430,9 +430,9 @@ impl<T> Equiv<*T> for *mut T { #[cfg(not(test))] mod externfnpointers { use mem; - use cmp::Eq; + use cmp::PartialEq; - impl<_R> Eq for extern "C" fn() -> _R { + impl<_R> PartialEq for extern "C" fn() -> _R { #[inline] fn eq(&self, other: &extern "C" fn() -> _R) -> bool { let self_: *() = unsafe { mem::transmute(*self) }; @@ -442,7 +442,7 @@ mod externfnpointers { } macro_rules! fnptreq( ($($p:ident),*) => { - impl<_R,$($p),*> Eq for extern "C" fn($($p),*) -> _R { + impl<_R,$($p),*> PartialEq for extern "C" fn($($p),*) -> _R { #[inline] fn eq(&self, other: &extern "C" fn($($p),*) -> _R) -> bool { let self_: *() = unsafe { mem::transmute(*self) }; @@ -461,13 +461,13 @@ mod externfnpointers { // Comparison for pointers #[cfg(not(test))] -impl<T> Ord for *T { +impl<T> PartialOrd for *T { #[inline] fn lt(&self, other: &*T) -> bool { *self < *other } } #[cfg(not(test))] -impl<T> Ord for *mut T { +impl<T> PartialOrd for *mut T { #[inline] fn lt(&self, other: &*mut T) -> bool { *self < *other } } diff --git a/src/libcore/result.rs b/src/libcore/result.rs index fd51ede204f..f3ec95d9582 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -275,7 +275,7 @@ //! will not resume after failure, that failure is catastrophic. use clone::Clone; -use cmp::Eq; +use cmp::PartialEq; use std::fmt::Show; use iter::{Iterator, FromIterator}; use option::{None, Option, Some}; @@ -283,7 +283,7 @@ use option::{None, Option, Some}; /// `Result` is a type that represents either success (`Ok`) or failure (`Err`). /// /// See the [`std::result`](index.html) module documentation for details. -#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd, Show)] +#[deriving(Clone, PartialEq, PartialOrd, TotalEq, TotalOrd, Show)] #[must_use] pub enum Result<T, E> { /// Contains the success value diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index 795dd389958..9771d766e65 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -15,7 +15,7 @@ use mem::transmute; use clone::Clone; use container::Container; -use cmp::{Eq, TotalOrd, Ordering, Less, Equal, Greater}; +use cmp::{PartialEq, TotalOrd, Ordering, Less, Equal, Greater}; use cmp; use default::Default; use iter::*; @@ -249,11 +249,11 @@ impl<'a, T> RandomAccessIterator<&'a [T]> for Chunks<'a, T> { pub mod traits { use super::*; - use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Equiv}; + use cmp::{PartialEq, PartialOrd, TotalEq, TotalOrd, Ordering, Equiv}; use iter::{order, Iterator}; use container::Container; - impl<'a,T:Eq> Eq for &'a [T] { + impl<'a,T:PartialEq> PartialEq for &'a [T] { fn eq(&self, other: & &'a [T]) -> bool { self.len() == other.len() && order::eq(self.iter(), other.iter()) @@ -264,7 +264,7 @@ pub mod traits { } } - impl<T:Eq> Eq for ~[T] { + impl<T:PartialEq> PartialEq for ~[T] { #[inline] fn eq(&self, other: &~[T]) -> bool { self.as_slice() == *other } #[inline] @@ -275,12 +275,12 @@ pub mod traits { impl<T:TotalEq> TotalEq for ~[T] {} - impl<'a,T:Eq, V: Vector<T>> Equiv<V> for &'a [T] { + impl<'a,T:PartialEq, V: Vector<T>> Equiv<V> for &'a [T] { #[inline] fn equiv(&self, other: &V) -> bool { self.as_slice() == other.as_slice() } } - impl<'a,T:Eq, V: Vector<T>> Equiv<V> for ~[T] { + impl<'a,T:PartialEq, V: Vector<T>> Equiv<V> for ~[T] { #[inline] fn equiv(&self, other: &V) -> bool { self.as_slice() == other.as_slice() } } @@ -296,7 +296,7 @@ pub mod traits { fn cmp(&self, other: &~[T]) -> Ordering { self.as_slice().cmp(&other.as_slice()) } } - impl<'a, T: Ord> Ord for &'a [T] { + impl<'a, T: PartialOrd> PartialOrd for &'a [T] { fn lt(&self, other: & &'a [T]) -> bool { order::lt(self.iter(), other.iter()) } @@ -314,7 +314,7 @@ pub mod traits { } } - impl<T: Ord> Ord for ~[T] { + impl<T: PartialOrd> PartialOrd for ~[T] { #[inline] fn lt(&self, other: &~[T]) -> bool { self.as_slice() < other.as_slice() } #[inline] @@ -692,8 +692,8 @@ impl<'a,T> ImmutableVector<'a, T> for &'a [T] { } } -/// Extension methods for vectors contain `Eq` elements. -pub trait ImmutableEqVector<T:Eq> { +/// Extension methods for vectors contain `PartialEq` elements. +pub trait ImmutableEqVector<T:PartialEq> { /// Find the first index containing a matching value fn position_elem(&self, t: &T) -> Option<uint>; @@ -710,7 +710,7 @@ pub trait ImmutableEqVector<T:Eq> { fn ends_with(&self, needle: &[T]) -> bool; } -impl<'a,T:Eq> ImmutableEqVector<T> for &'a [T] { +impl<'a,T:PartialEq> ImmutableEqVector<T> for &'a [T] { #[inline] fn position_elem(&self, x: &T) -> Option<uint> { self.iter().position(|y| *x == *y) diff --git a/src/libcore/str.rs b/src/libcore/str.rs index 8b8ddbe847c..a19e720446b 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -16,7 +16,7 @@ use mem; use char; use clone::Clone; use cmp; -use cmp::{Eq, TotalEq}; +use cmp::{PartialEq, TotalEq}; use container::Container; use default::Default; use iter::{Filter, Map, Iterator}; @@ -696,7 +696,7 @@ pub struct Utf16Items<'a> { iter: slice::Items<'a, u16> } /// The possibilities for values decoded from a `u16` stream. -#[deriving(Eq, TotalEq, Clone, Show)] +#[deriving(PartialEq, TotalEq, Clone, Show)] pub enum Utf16Item { /// A valid codepoint. ScalarValue(char), @@ -930,7 +930,7 @@ Section: Trait implementations #[allow(missing_doc)] pub mod traits { use container::Container; - use cmp::{TotalOrd, Ordering, Less, Equal, Greater, Eq, Ord, Equiv, TotalEq}; + use cmp::{TotalOrd, Ordering, Less, Equal, Greater, PartialEq, PartialOrd, Equiv, TotalEq}; use iter::Iterator; use option::{Some, None}; use str::{Str, StrSlice, eq_slice}; @@ -950,7 +950,7 @@ pub mod traits { } } - impl<'a> Eq for &'a str { + impl<'a> PartialEq for &'a str { #[inline] fn eq(&self, other: & &'a str) -> bool { eq_slice((*self), (*other)) @@ -961,7 +961,7 @@ pub mod traits { impl<'a> TotalEq for &'a str {} - impl<'a> Ord for &'a str { + impl<'a> PartialOrd for &'a str { #[inline] fn lt(&self, other: & &'a str) -> bool { self.cmp(other) == Less } } diff --git a/src/libcore/tuple.rs b/src/libcore/tuple.rs index edcb37dbb64..7639700eac9 100644 --- a/src/libcore/tuple.rs +++ b/src/libcore/tuple.rs @@ -27,9 +27,9 @@ //! traits, then a tuple itself also implements it. //! //! * `Clone` -//! * `Eq` +//! * `PartialEq` //! * `TotalEq` -//! * `Ord` +//! * `PartialOrd` //! * `TotalOrd` //! * `Default` //! @@ -109,7 +109,7 @@ macro_rules! tuple_impls { } #[cfg(not(test))] - impl<$($T:Eq),+> Eq for ($($T,)+) { + impl<$($T:PartialEq),+> PartialEq for ($($T,)+) { #[inline] fn eq(&self, other: &($($T,)+)) -> bool { $(*self.$refN() == *other.$refN())&&+ @@ -124,7 +124,7 @@ macro_rules! tuple_impls { impl<$($T:TotalEq),+> TotalEq for ($($T,)+) {} #[cfg(not(test))] - impl<$($T:Ord + Eq),+> Ord for ($($T,)+) { + impl<$($T:PartialOrd + PartialEq),+> PartialOrd for ($($T,)+) { #[inline] fn lt(&self, other: &($($T,)+)) -> bool { lexical_ord!(lt, $(self.$refN(), other.$refN()),+) @@ -335,13 +335,13 @@ mod tests { let nan = 0.0/0.0; - // Eq + // PartialEq assert_eq!(small, small); assert_eq!(big, big); assert!(small != big); assert!(big != small); - // Ord + // PartialOrd assert!(small < big); assert!(!(small < small)); assert!(!(big < small)); diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs index 5300374333b..bcdeb2bf329 100644 --- a/src/libfmt_macros/lib.rs +++ b/src/libfmt_macros/lib.rs @@ -26,7 +26,7 @@ use std::str; /// A piece is a portion of the format string which represents the next part /// to emit. These are emitted as a stream by the `Parser` class. -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum Piece<'a> { /// A literal string which should directly be emitted String(&'a str), @@ -39,7 +39,7 @@ pub enum Piece<'a> { } /// Representation of an argument specification. -#[deriving(Eq)] +#[deriving(PartialEq)] pub struct Argument<'a> { /// Where to find this argument pub position: Position<'a>, @@ -50,7 +50,7 @@ pub struct Argument<'a> { } /// Specification for the formatting of an argument in the format string. -#[deriving(Eq)] +#[deriving(PartialEq)] pub struct FormatSpec<'a> { /// Optionally specified character to fill alignment with pub fill: Option<char>, @@ -69,7 +69,7 @@ pub struct FormatSpec<'a> { } /// Enum describing where an argument for a format can be located. -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum Position<'a> { /// The argument will be in the next position. This is the default. ArgumentNext, @@ -80,7 +80,7 @@ pub enum Position<'a> { } /// Enum of alignments which are supported. -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum Alignment { /// The value will be aligned to the left. AlignLeft, @@ -92,7 +92,7 @@ pub enum Alignment { /// Various flags which can be applied to format strings. The meaning of these /// flags is defined by the formatters themselves. -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum Flag { /// A `+` will be used to denote positive numbers. FlagSignPlus, @@ -108,7 +108,7 @@ pub enum Flag { /// A count is used for the precision and width parameters of an integer, and /// can reference either an argument or a literal integer. -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum Count<'a> { /// The count is specified explicitly. CountIs(uint), @@ -124,7 +124,7 @@ pub enum Count<'a> { /// Enum describing all of the possible methods which the formatting language /// currently supports. -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum Method<'a> { /// A plural method selects on an integer over a list of either integer or /// keyword-defined clauses. The meaning of the keywords is defined by the @@ -146,7 +146,7 @@ pub enum Method<'a> { } /// A selector for what pluralization a plural method should take -#[deriving(Eq, TotalEq, Hash)] +#[deriving(PartialEq, TotalEq, Hash)] pub enum PluralSelector { /// One of the plural keywords should be used Keyword(PluralKeyword), @@ -155,7 +155,7 @@ pub enum PluralSelector { } /// Structure representing one "arm" of the `plural` function. -#[deriving(Eq)] +#[deriving(PartialEq)] pub struct PluralArm<'a> { /// A selector can either be specified by a keyword or with an integer /// literal. @@ -168,7 +168,7 @@ pub struct PluralArm<'a> { /// is specially placed in the `Plural` variant of `Method`. /// /// http://www.icu-project.org/apiref/icu4c/classicu_1_1PluralRules.html -#[deriving(Eq, TotalEq, Hash, Show)] +#[deriving(PartialEq, TotalEq, Hash, Show)] #[allow(missing_doc)] pub enum PluralKeyword { /// The plural form for zero objects. @@ -184,7 +184,7 @@ pub enum PluralKeyword { } /// Structure representing one "arm" of the `select` function. -#[deriving(Eq)] +#[deriving(PartialEq)] pub struct SelectArm<'a> { /// String selector which guards this arm pub selector: &'a str, diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs index 37c3fe0d2ef..0311c333924 100644 --- a/src/libgetopts/lib.rs +++ b/src/libgetopts/lib.rs @@ -92,13 +92,13 @@ #[cfg(test)] extern crate debug; #[cfg(test)] #[phase(syntax, link)] extern crate log; -use std::cmp::Eq; +use std::cmp::PartialEq; use std::result::{Err, Ok}; use std::result; use std::string::String; /// Name of an option. Either a string or a single char. -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub enum Name { /// A string representing the long name of an option. /// For example: "help" @@ -109,7 +109,7 @@ pub enum Name { } /// Describes whether an option has an argument. -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub enum HasArg { /// The option requires an argument. Yes, @@ -120,7 +120,7 @@ pub enum HasArg { } /// Describes how often an option may occur. -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub enum Occur { /// The option occurs once. Req, @@ -131,7 +131,7 @@ pub enum Occur { } /// A description of a possible option. -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub struct Opt { /// Name of the option pub name: Name, @@ -145,7 +145,7 @@ pub struct Opt { /// One group of options, e.g., both -h and --help, along with /// their shared description and properties. -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub struct OptGroup { /// Short Name of the `OptGroup` pub short_name: String, @@ -162,7 +162,7 @@ pub struct OptGroup { } /// Describes wether an option is given at all or has a value. -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] enum Optval { Val(String), Given, @@ -170,7 +170,7 @@ enum Optval { /// The result of checking command line arguments. Contains a vector /// of matches and a vector of free strings. -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub struct Matches { /// Options that matched opts: Vec<Opt> , @@ -183,7 +183,7 @@ pub struct Matches { /// The type returned when the command line does not conform to the /// expected format. Call the `to_err_msg` method to retrieve the /// error as a string. -#[deriving(Clone, Eq, Show)] +#[deriving(Clone, PartialEq, Show)] pub enum Fail_ { /// The option requires an argument but none was passed. ArgumentMissing(String), @@ -198,7 +198,7 @@ pub enum Fail_ { } /// The type of failure that occurred. -#[deriving(Eq)] +#[deriving(PartialEq)] #[allow(missing_doc)] pub enum FailType { ArgumentMissing_, diff --git a/src/libglob/lib.rs b/src/libglob/lib.rs index 1affeadbff1..8db8f0dac10 100644 --- a/src/libglob/lib.rs +++ b/src/libglob/lib.rs @@ -198,12 +198,12 @@ fn list_dir_sorted(path: &Path) -> Option<Vec<Path>> { /** * A compiled Unix shell style pattern. */ -#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash, Default)] +#[deriving(Clone, PartialEq, TotalEq, PartialOrd, TotalOrd, Hash, Default)] pub struct Pattern { tokens: Vec<PatternToken>, } -#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash)] +#[deriving(Clone, PartialEq, TotalEq, PartialOrd, TotalOrd, Hash)] enum PatternToken { Char(char), AnyChar, @@ -212,13 +212,13 @@ enum PatternToken { AnyExcept(Vec<CharSpecifier> ) } -#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash)] +#[deriving(Clone, PartialEq, TotalEq, PartialOrd, TotalOrd, Hash)] enum CharSpecifier { SingleChar(char), CharRange(char, char) } -#[deriving(Eq)] +#[deriving(PartialEq)] enum MatchResult { Match, SubPatternDoesntMatch, @@ -596,7 +596,7 @@ fn chars_eq(a: char, b: char, case_sensitive: bool) -> bool { /** * Configuration options to modify the behaviour of `Pattern::matches_with(..)` */ -#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash, Default)] +#[deriving(Clone, PartialEq, TotalEq, PartialOrd, TotalOrd, Hash, Default)] pub struct MatchOptions { /** diff --git a/src/libgreen/sched.rs b/src/libgreen/sched.rs index 6dc6ccb7901..e410d2719b1 100644 --- a/src/libgreen/sched.rs +++ b/src/libgreen/sched.rs @@ -105,7 +105,7 @@ pub struct Scheduler { /// An indication of how hard to work on a given operation, the difference /// mainly being whether memory is synchronized or not -#[deriving(Eq)] +#[deriving(PartialEq)] enum EffortLevel { DontTryTooHard, GiveItYourBest diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs index 6f9f3f2e21e..11df847122b 100644 --- a/src/liblog/lib.rs +++ b/src/liblog/lib.rs @@ -172,7 +172,7 @@ struct DefaultLogger { } /// Wraps the log level with fmt implementations. -#[deriving(Eq, Ord)] +#[deriving(PartialEq, PartialOrd)] pub struct LogLevel(pub u32); impl fmt::Show for LogLevel { diff --git a/src/libnum/bigint.rs b/src/libnum/bigint.rs index c6af8ac9b4b..9264cb541a9 100644 --- a/src/libnum/bigint.rs +++ b/src/libnum/bigint.rs @@ -83,7 +83,7 @@ pub struct BigUint { data: Vec<BigDigit> } -impl Eq for BigUint { +impl PartialEq for BigUint { #[inline] fn eq(&self, other: &BigUint) -> bool { match self.cmp(other) { Equal => true, _ => false } @@ -91,7 +91,7 @@ impl Eq for BigUint { } impl TotalEq for BigUint {} -impl Ord for BigUint { +impl PartialOrd for BigUint { #[inline] fn lt(&self, other: &BigUint) -> bool { match self.cmp(other) { Less => true, _ => false} @@ -786,7 +786,7 @@ fn get_radix_base(radix: uint) -> (DoubleBigDigit, uint) { } /// A Sign is a `BigInt`'s composing element. -#[deriving(Eq, Ord, TotalEq, TotalOrd, Clone, Show)] +#[deriving(PartialEq, PartialOrd, TotalEq, TotalOrd, Clone, Show)] pub enum Sign { Minus, Zero, Plus } impl Neg<Sign> for Sign { @@ -808,7 +808,7 @@ pub struct BigInt { data: BigUint } -impl Eq for BigInt { +impl PartialEq for BigInt { #[inline] fn eq(&self, other: &BigInt) -> bool { match self.cmp(other) { Equal => true, _ => false } @@ -817,7 +817,7 @@ impl Eq for BigInt { impl TotalEq for BigInt {} -impl Ord for BigInt { +impl PartialOrd for BigInt { #[inline] fn lt(&self, other: &BigInt) -> bool { match self.cmp(other) { Less => true, _ => false} diff --git a/src/libnum/complex.rs b/src/libnum/complex.rs index 6c5547b28e8..7febeb26616 100644 --- a/src/libnum/complex.rs +++ b/src/libnum/complex.rs @@ -18,7 +18,7 @@ use std::num::{Zero,One,ToStrRadix}; // probably doesn't map to C's _Complex correctly. /// A complex number in Cartesian form. -#[deriving(Eq,Clone)] +#[deriving(PartialEq,Clone)] pub struct Complex<T> { /// Real portion of the complex number pub re: T, @@ -164,7 +164,7 @@ impl<T: Clone + Num> One for Complex<T> { } /* string conversions */ -impl<T: fmt::Show + Num + Ord> fmt::Show for Complex<T> { +impl<T: fmt::Show + Num + PartialOrd> fmt::Show for Complex<T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.im < Zero::zero() { write!(f, "{}-{}i", self.re, -self.im) @@ -174,7 +174,7 @@ impl<T: fmt::Show + Num + Ord> fmt::Show for Complex<T> { } } -impl<T: ToStrRadix + Num + Ord> ToStrRadix for Complex<T> { +impl<T: ToStrRadix + Num + PartialOrd> ToStrRadix for Complex<T> { fn to_str_radix(&self, radix: uint) -> String { if self.im < Zero::zero() { format!("{}-{}i", diff --git a/src/libnum/lib.rs b/src/libnum/lib.rs index d42c197cab7..29cf769ffc9 100644 --- a/src/libnum/lib.rs +++ b/src/libnum/lib.rs @@ -60,7 +60,7 @@ pub mod bigint; pub mod rational; pub mod complex; -pub trait Integer: Num + Ord +pub trait Integer: Num + PartialOrd + Div<Self, Self> + Rem<Self, Self> { /// Simultaneous truncated integer division and modulus diff --git a/src/libnum/rational.rs b/src/libnum/rational.rs index ba0a571268f..71a23a23a26 100644 --- a/src/libnum/rational.rs +++ b/src/libnum/rational.rs @@ -34,7 +34,7 @@ pub type Rational64 = Ratio<i64>; /// Alias for arbitrary precision rationals. pub type BigRational = Ratio<BigInt>; -impl<T: Clone + Integer + Ord> +impl<T: Clone + Integer + PartialOrd> Ratio<T> { /// Create a ratio representing the integer `t`. #[inline] @@ -192,14 +192,14 @@ macro_rules! cmp_impl { } }; } -cmp_impl!(impl Eq, eq, ne) -cmp_impl!(impl Ord, lt, gt, le, ge) +cmp_impl!(impl PartialEq, eq, ne) +cmp_impl!(impl PartialOrd, lt, gt, le, ge) cmp_impl!(impl TotalEq, ) cmp_impl!(impl TotalOrd, cmp -> cmp::Ordering) /* Arithmetic */ // a/b * c/d = (a*c)/(b*d) -impl<T: Clone + Integer + Ord> +impl<T: Clone + Integer + PartialOrd> Mul<Ratio<T>,Ratio<T>> for Ratio<T> { #[inline] fn mul(&self, rhs: &Ratio<T>) -> Ratio<T> { @@ -208,7 +208,7 @@ impl<T: Clone + Integer + Ord> } // (a/b) / (c/d) = (a*d)/(b*c) -impl<T: Clone + Integer + Ord> +impl<T: Clone + Integer + PartialOrd> Div<Ratio<T>,Ratio<T>> for Ratio<T> { #[inline] fn div(&self, rhs: &Ratio<T>) -> Ratio<T> { @@ -219,7 +219,7 @@ impl<T: Clone + Integer + Ord> // Abstracts the a/b `op` c/d = (a*d `op` b*d) / (b*d) pattern macro_rules! arith_impl { (impl $imp:ident, $method:ident) => { - impl<T: Clone + Integer + Ord> + impl<T: Clone + Integer + PartialOrd> $imp<Ratio<T>,Ratio<T>> for Ratio<T> { #[inline] fn $method(&self, rhs: &Ratio<T>) -> Ratio<T> { @@ -239,7 +239,7 @@ arith_impl!(impl Sub, sub) // a/b % c/d = (a*d % b*c)/(b*d) arith_impl!(impl Rem, rem) -impl<T: Clone + Integer + Ord> +impl<T: Clone + Integer + PartialOrd> Neg<Ratio<T>> for Ratio<T> { #[inline] fn neg(&self) -> Ratio<T> { @@ -248,7 +248,7 @@ impl<T: Clone + Integer + Ord> } /* Constants */ -impl<T: Clone + Integer + Ord> +impl<T: Clone + Integer + PartialOrd> Zero for Ratio<T> { #[inline] fn zero() -> Ratio<T> { @@ -261,7 +261,7 @@ impl<T: Clone + Integer + Ord> } } -impl<T: Clone + Integer + Ord> +impl<T: Clone + Integer + PartialOrd> One for Ratio<T> { #[inline] fn one() -> Ratio<T> { @@ -269,7 +269,7 @@ impl<T: Clone + Integer + Ord> } } -impl<T: Clone + Integer + Ord> +impl<T: Clone + Integer + PartialOrd> Num for Ratio<T> {} /* String conversions */ @@ -288,7 +288,7 @@ impl<T: ToStrRadix> ToStrRadix for Ratio<T> { } } -impl<T: FromStr + Clone + Integer + Ord> +impl<T: FromStr + Clone + Integer + PartialOrd> FromStr for Ratio<T> { /// Parses `numer/denom`. fn from_str(s: &str) -> Option<Ratio<T>> { @@ -305,7 +305,7 @@ impl<T: FromStr + Clone + Integer + Ord> }) } } -impl<T: FromStrRadix + Clone + Integer + Ord> +impl<T: FromStrRadix + Clone + Integer + PartialOrd> FromStrRadix for Ratio<T> { /// Parses `numer/denom` where the numbers are in base `radix`. fn from_str_radix(s: &str, radix: uint) -> Option<Ratio<T>> { diff --git a/src/librand/distributions/mod.rs b/src/librand/distributions/mod.rs index bb09db48802..2e3c0394747 100644 --- a/src/librand/distributions/mod.rs +++ b/src/librand/distributions/mod.rs @@ -260,7 +260,7 @@ mod tests { use {Rng, Rand}; use super::{RandSample, WeightedChoice, Weighted, Sample, IndependentSample}; - #[deriving(Eq, Show)] + #[deriving(PartialEq, Show)] struct ConstRand(uint); impl Rand for ConstRand { fn rand<R: Rng>(_: &mut R) -> ConstRand { diff --git a/src/librand/distributions/range.rs b/src/librand/distributions/range.rs index f0e1d1715a2..13f6d2e81c0 100644 --- a/src/librand/distributions/range.rs +++ b/src/librand/distributions/range.rs @@ -54,7 +54,7 @@ pub struct Range<X> { accept_zone: X } -impl<X: SampleRange + Ord> Range<X> { +impl<X: SampleRange + PartialOrd> Range<X> { /// Create a new `Range` instance that samples uniformly from /// `[low, high)`. Fails if `low >= high`. pub fn new(low: X, high: X) -> Range<X> { diff --git a/src/librand/lib.rs b/src/librand/lib.rs index 353ac4cfed1..3ed086e9b13 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -182,7 +182,7 @@ pub trait Rng { /// let m: f64 = rng.gen_range(-40.0, 1.3e5); /// println!("{}", m); /// ``` - fn gen_range<T: Ord + SampleRange>(&mut self, low: T, high: T) -> T { + fn gen_range<T: PartialOrd + SampleRange>(&mut self, low: T, high: T) -> T { assert!(low < high, "Rng.gen_range called with low >= high"); Range::new(low, high).ind_sample(self) } diff --git a/src/libregex/parse/mod.rs b/src/libregex/parse/mod.rs index 87b6e2b1104..bd2e454a9f8 100644 --- a/src/libregex/parse/mod.rs +++ b/src/libregex/parse/mod.rs @@ -67,7 +67,7 @@ pub enum Ast { Rep(Box<Ast>, Repeater, Greed), } -#[deriving(Show, Eq, Clone)] +#[deriving(Show, PartialEq, Clone)] pub enum Repeater { ZeroOne, ZeroMore, diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs index 5f53cd85705..95c08d6a41e 100644 --- a/src/librustc/back/link.rs +++ b/src/librustc/back/link.rs @@ -45,7 +45,7 @@ use syntax::attr::AttrMetaMethods; use syntax::crateid::CrateId; use syntax::parse::token; -#[deriving(Clone, Eq, Ord, TotalOrd, TotalEq)] +#[deriving(Clone, PartialEq, PartialOrd, TotalOrd, TotalEq)] pub enum OutputType { OutputTypeBitcode, OutputTypeAssembly, diff --git a/src/librustc/back/svh.rs b/src/librustc/back/svh.rs index 9fd829ab901..1fce6eaf8e1 100644 --- a/src/librustc/back/svh.rs +++ b/src/librustc/back/svh.rs @@ -53,7 +53,7 @@ use std::iter::range_step; use syntax::ast; use syntax::visit; -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub struct Svh { hash: String, } diff --git a/src/librustc/driver/config.rs b/src/librustc/driver/config.rs index 16965bfa67f..db934c7a404 100644 --- a/src/librustc/driver/config.rs +++ b/src/librustc/driver/config.rs @@ -46,7 +46,7 @@ pub struct Config { pub uint_type: UintTy, } -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub enum OptLevel { No, // -O0 Less, // -O1 @@ -54,7 +54,7 @@ pub enum OptLevel { Aggressive // -O3 } -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub enum DebugInfoLevel { NoDebugInfo, LimitedDebugInfo, @@ -125,14 +125,14 @@ pub fn basic_options() -> Options { // users can have their own entry // functions that don't start a // scheduler -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum EntryFnType { EntryMain, EntryStart, EntryNone, } -#[deriving(Eq, Ord, Clone, TotalOrd, TotalEq, Hash)] +#[deriving(PartialEq, PartialOrd, Clone, TotalOrd, TotalEq, Hash)] pub enum CrateType { CrateTypeExecutable, CrateTypeDylib, diff --git a/src/librustc/lib/llvm.rs b/src/librustc/lib/llvm.rs index 4a36dfd7842..a6c2d75dc0d 100644 --- a/src/librustc/lib/llvm.rs +++ b/src/librustc/lib/llvm.rs @@ -29,7 +29,7 @@ pub static False: Bool = 0 as Bool; // Consts for the LLVM CallConv type, pre-cast to uint. -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum CallConv { CCallConv = 0, FastCallConv = 8, @@ -156,7 +156,7 @@ pub enum RealPredicate { // The LLVM TypeKind type - must stay in sync with the def of // LLVMTypeKind in llvm/include/llvm-c/Core.h -#[deriving(Eq)] +#[deriving(PartialEq)] #[repr(C)] pub enum TypeKind { Void = 0, @@ -226,7 +226,7 @@ pub enum AsmDialect { AD_Intel = 1 } -#[deriving(Eq)] +#[deriving(PartialEq)] #[repr(C)] pub enum CodeGenOptLevel { CodeGenLevelNone = 0, diff --git a/src/librustc/metadata/common.rs b/src/librustc/metadata/common.rs index c798118bbd0..8aeef3dca98 100644 --- a/src/librustc/metadata/common.rs +++ b/src/librustc/metadata/common.rs @@ -114,7 +114,7 @@ pub static tag_items_data_item_reexport_def_id: uint = 0x39; pub static tag_items_data_item_reexport_name: uint = 0x3a; // used to encode crate_ctxt side tables -#[deriving(Eq)] +#[deriving(PartialEq)] #[repr(uint)] pub enum astencode_tag { // Reserves 0x40 -- 0x5f tag_ast = 0x40, diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs index eb1beda898f..b355ede72c6 100644 --- a/src/librustc/metadata/cstore.rs +++ b/src/librustc/metadata/cstore.rs @@ -45,13 +45,13 @@ pub struct crate_metadata { pub span: Span, } -#[deriving(Show, Eq, Clone)] +#[deriving(Show, PartialEq, Clone)] pub enum LinkagePreference { RequireDynamic, RequireStatic, } -#[deriving(Eq, FromPrimitive)] +#[deriving(PartialEq, FromPrimitive)] pub enum NativeLibaryKind { NativeStatic, // native static library (.a archive) NativeFramework, // OSX-specific @@ -60,7 +60,7 @@ pub enum NativeLibaryKind { // Where a crate came from on the local filesystem. One of these two options // must be non-None. -#[deriving(Eq, Clone)] +#[deriving(PartialEq, Clone)] pub struct CrateSource { pub dylib: Option<Path>, pub rlib: Option<Path>, diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 56b320d2a07..30b40369c10 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -103,7 +103,7 @@ fn lookup_item<'a>(item_id: ast::NodeId, data: &'a [u8]) -> ebml::Doc<'a> { find_item(item_id, items) } -#[deriving(Eq)] +#[deriving(PartialEq)] enum Family { ImmStatic, // c MutStatic, // b diff --git a/src/librustc/middle/borrowck/check_loans.rs b/src/librustc/middle/borrowck/check_loans.rs index 77fad454e6e..140bfcd684a 100644 --- a/src/librustc/middle/borrowck/check_loans.rs +++ b/src/librustc/middle/borrowck/check_loans.rs @@ -82,7 +82,7 @@ pub fn check_loans(bccx: &BorrowckCtxt, clcx.visit_block(body, ()); } -#[deriving(Eq)] +#[deriving(PartialEq)] enum MoveError { MoveOk, MoveWhileBorrowed(/*loan*/Rc<LoanPath>, /*loan*/Span) diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs index e52d8ba3975..c1f8ea4d00c 100644 --- a/src/librustc/middle/borrowck/mod.rs +++ b/src/librustc/middle/borrowck/mod.rs @@ -166,7 +166,7 @@ pub struct BorrowStats { pub type BckResult<T> = Result<T, BckError>; -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum PartialTotal { Partial, // Loan affects some portion Total // Loan affects entire path @@ -188,13 +188,13 @@ pub struct Loan { cause: euv::LoanCause, } -#[deriving(Eq, TotalEq, Hash)] +#[deriving(PartialEq, TotalEq, Hash)] pub enum LoanPath { LpVar(ast::NodeId), // `x` in doc.rs LpExtend(Rc<LoanPath>, mc::MutabilityCategory, LoanPathElem) } -#[deriving(Eq, TotalEq, Hash)] +#[deriving(PartialEq, TotalEq, Hash)] pub enum LoanPathElem { LpDeref(mc::PointerKind), // `*LV` in doc.rs LpInterior(mc::InteriorKind) // `LV.f` in doc.rs @@ -267,7 +267,7 @@ pub struct Restriction { set: RestrictionSet } -#[deriving(Eq)] +#[deriving(PartialEq)] pub struct RestrictionSet { bits: u32 } @@ -305,7 +305,7 @@ impl Repr for RestrictionSet { // Errors // Errors that can occur -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum bckerr_code { err_mutbl, err_out_of_scope(ty::Region, ty::Region), // superscope, subscope @@ -315,7 +315,7 @@ pub enum bckerr_code { // Combination of an error code and the categorization of the expression // that caused it -#[deriving(Eq)] +#[deriving(PartialEq)] pub struct BckError { span: Span, cause: euv::LoanCause, diff --git a/src/librustc/middle/borrowck/move_data.rs b/src/librustc/middle/borrowck/move_data.rs index 068f8442c51..5a95343c622 100644 --- a/src/librustc/middle/borrowck/move_data.rs +++ b/src/librustc/middle/borrowck/move_data.rs @@ -65,7 +65,7 @@ pub struct FlowedMoveData<'a> { } /// Index into `MoveData.paths`, used like a pointer -#[deriving(Eq)] +#[deriving(PartialEq)] pub struct MovePathIndex(uint); impl MovePathIndex { @@ -84,7 +84,7 @@ static InvalidMovePathIndex: MovePathIndex = MovePathIndex(uint::MAX); /// Index into `MoveData.moves`, used like a pointer -#[deriving(Eq)] +#[deriving(PartialEq)] pub struct MoveIndex(uint); impl MoveIndex { diff --git a/src/librustc/middle/check_loop.rs b/src/librustc/middle/check_loop.rs index 6e738b14308..0c677f164d4 100644 --- a/src/librustc/middle/check_loop.rs +++ b/src/librustc/middle/check_loop.rs @@ -15,7 +15,7 @@ use syntax::codemap::Span; use syntax::visit::Visitor; use syntax::visit; -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] enum Context { Normal, Loop, Closure } diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index e21c8348a8b..2053f7dd01b 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -215,7 +215,7 @@ enum useful { not_useful, } -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] enum ctor { single, variant(DefId), diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index d8fe801b395..e7ad08d4eb2 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -288,7 +288,7 @@ pub fn process_crate(krate: &ast::Crate, // FIXME (#33): this doesn't handle big integer/float literals correctly // (nor does the rest of our literal handling). -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub enum const_val { const_float(f64), const_int(i64), @@ -514,7 +514,7 @@ pub fn lit_to_const(lit: &Lit) -> const_val { } } -fn compare_vals<T: Ord>(a: T, b: T) -> Option<int> { +fn compare_vals<T: PartialOrd>(a: T, b: T) -> Option<int> { Some(if a == b { 0 } else if a < b { -1 } else { 1 }) } pub fn compare_const_vals(a: &const_val, b: &const_val) -> Option<int> { diff --git a/src/librustc/middle/effect.rs b/src/librustc/middle/effect.rs index b3b09ba631e..bc9a1c9b5fc 100644 --- a/src/librustc/middle/effect.rs +++ b/src/librustc/middle/effect.rs @@ -20,7 +20,7 @@ use syntax::codemap::Span; use syntax::visit; use syntax::visit::Visitor; -#[deriving(Eq)] +#[deriving(PartialEq)] enum UnsafeContext { SafeContext, UnsafeFn, diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 9d735dbaeae..467cd726a65 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -68,7 +68,7 @@ pub trait Delegate { mode: MutateMode); } -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum LoanCause { ClosureCapture(Span), AddrOf, @@ -78,13 +78,13 @@ pub enum LoanCause { ClosureInvocation } -#[deriving(Eq,Show)] +#[deriving(PartialEq,Show)] pub enum ConsumeMode { Copy, // reference to x where x has a type that copies Move, // reference to x where x has a type that moves } -#[deriving(Eq,Show)] +#[deriving(PartialEq,Show)] pub enum MutateMode { JustWrite, // x = y WriteAndRead, // x += y diff --git a/src/librustc/middle/graph.rs b/src/librustc/middle/graph.rs index 5773d0bafa1..cd601012708 100644 --- a/src/librustc/middle/graph.rs +++ b/src/librustc/middle/graph.rs @@ -55,11 +55,11 @@ pub struct Edge<E> { pub data: E, } -#[deriving(Eq)] +#[deriving(PartialEq)] pub struct NodeIndex(pub uint); pub static InvalidNodeIndex: NodeIndex = NodeIndex(uint::MAX); -#[deriving(Eq)] +#[deriving(PartialEq)] pub struct EdgeIndex(pub uint); pub static InvalidEdgeIndex: EdgeIndex = EdgeIndex(uint::MAX); @@ -356,7 +356,7 @@ mod test { }); } - fn test_adjacent_edges<N:Eq,E:Eq>(graph: &Graph<N,E>, + fn test_adjacent_edges<N:PartialEq,E:PartialEq>(graph: &Graph<N,E>, start_index: NodeIndex, start_data: N, expected_incoming: &[(E,N)], diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index f80c325496d..d5bd44fd27c 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -42,7 +42,7 @@ macro_rules! lets_do_this { $( $variant:ident, $name:expr, $method:ident; )* ) => { -#[deriving(FromPrimitive, Eq, TotalEq, Hash)] +#[deriving(FromPrimitive, PartialEq, TotalEq, Hash)] pub enum LangItem { $($variant),* } diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index 8cceb16b34f..7a11924800b 100644 --- a/src/librustc/middle/lint.rs +++ b/src/librustc/middle/lint.rs @@ -72,7 +72,7 @@ use syntax::parse::token; use syntax::visit::Visitor; use syntax::{ast, ast_util, visit}; -#[deriving(Clone, Show, Eq, Ord, TotalEq, TotalOrd, Hash)] +#[deriving(Clone, Show, PartialEq, PartialOrd, TotalEq, TotalOrd, Hash)] pub enum Lint { CTypes, UnusedImports, @@ -135,12 +135,12 @@ pub fn level_to_str(lv: Level) -> &'static str { } } -#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd)] +#[deriving(Clone, PartialEq, PartialOrd, TotalEq, TotalOrd)] pub enum Level { Allow, Warn, Deny, Forbid } -#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd)] +#[deriving(Clone, PartialEq, PartialOrd, TotalEq, TotalOrd)] pub struct LintSpec { pub default: Level, pub lint: Lint, @@ -150,7 +150,7 @@ pub struct LintSpec { pub type LintDict = HashMap<&'static str, LintSpec>; // this is public for the lints that run in trans -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum LintSource { Node(Span), Default, @@ -836,7 +836,7 @@ fn check_type_limits(cx: &Context, e: &ast::Expr) { _ => () }; - fn is_valid<T:cmp::Ord>(binop: ast::BinOp, v: T, + fn is_valid<T:cmp::PartialOrd>(binop: ast::BinOp, v: T, min: T, max: T) -> bool { match binop { ast::BiLt => v > min && v <= max, diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index e0d411f9f97..ce02243403f 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -123,9 +123,9 @@ use syntax::print::pprust::{expr_to_str, block_to_str}; use syntax::{visit, ast_util}; use syntax::visit::{Visitor, FnKind}; -#[deriving(Eq)] +#[deriving(PartialEq)] struct Variable(uint); -#[deriving(Eq)] +#[deriving(PartialEq)] struct LiveNode(uint); impl Variable { @@ -142,7 +142,7 @@ impl Clone for LiveNode { } } -#[deriving(Eq)] +#[deriving(PartialEq)] enum LiveNodeKind { FreeVarNode(Span), ExprNode(Span), diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 1fad7b1e60c..c8cad58a191 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -76,7 +76,7 @@ use syntax::parse::token; use std::cell::RefCell; use std::rc::Rc; -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub enum categorization { cat_rvalue(ty::Region), // temporary val, argument is its scope cat_static_item, @@ -92,14 +92,14 @@ pub enum categorization { // (*1) downcast is only required if the enum has more than one variant } -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub struct CopiedUpvar { pub upvar_id: ast::NodeId, pub onceness: ast::Onceness, } // different kinds of pointers: -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub enum PointerKind { OwnedPtr, GcPtr, @@ -109,26 +109,26 @@ pub enum PointerKind { // We use the term "interior" to mean "something reachable from the // base without a pointer dereference", e.g. a field -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub enum InteriorKind { InteriorField(FieldName), InteriorElement(ElementKind), } -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub enum FieldName { NamedField(ast::Name), PositionalField(uint) } -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub enum ElementKind { VecElement, StrElement, OtherElement, } -#[deriving(Clone, Eq, TotalEq, Hash, Show)] +#[deriving(Clone, PartialEq, TotalEq, Hash, Show)] pub enum MutabilityCategory { McImmutable, // Immutable. McDeclared, // Directly declared as mutable. @@ -149,7 +149,7 @@ pub enum MutabilityCategory { // dereference, but its type is the type *before* the dereference // (`@T`). So use `cmt.type` to find the type of the value in a consistent // fashion. For more details, see the method `cat_pattern` -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub struct cmt_ { pub id: ast::NodeId, // id of expr/pat producing this value pub span: Span, // span of same expr/pat diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 077f61a34c6..4db791ddf7b 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -87,7 +87,7 @@ pub enum PrivateDep { } // How an import is used. -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum ImportUse { Unused, // The import is not used. Used, // The import is used. @@ -102,20 +102,20 @@ impl LastPrivate { } } -#[deriving(Eq)] +#[deriving(PartialEq)] enum PatternBindingMode { RefutableMode, LocalIrrefutableMode, ArgumentIrrefutableMode, } -#[deriving(Eq, TotalEq, Hash)] +#[deriving(PartialEq, TotalEq, Hash)] enum Namespace { TypeNS, ValueNS } -#[deriving(Eq)] +#[deriving(PartialEq)] enum NamespaceError { NoError, ModuleError, @@ -288,7 +288,7 @@ enum ModulePrefixResult { PrefixFound(Rc<Module>, uint) } -#[deriving(Eq)] +#[deriving(PartialEq)] enum NameSearchType { /// We're doing a name search in order to resolve a `use` directive. ImportSearch, @@ -306,7 +306,7 @@ enum BareIdentifierPatternResolution { // Specifies how duplicates should be handled when adding a child item if // another item exists with the same name in some namespace. -#[deriving(Eq)] +#[deriving(PartialEq)] enum DuplicateCheckingMode { ForbidDuplicateModules, ForbidDuplicateTypes, @@ -435,7 +435,7 @@ enum ParentLink { } /// The type of module this is. -#[deriving(Eq)] +#[deriving(PartialEq)] enum ModuleKind { NormalModuleKind, ExternModuleKind, @@ -4900,7 +4900,7 @@ impl<'a> Resolver<'a> { } fn find_fallback_in_self_type(&mut self, name: Name) -> FallbackSuggestion { - #[deriving(Eq)] + #[deriving(PartialEq)] enum FallbackChecks { Everything, OnlyTraitAndStatics diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index 86ddd5e0e98..ddd41072c8d 100644 --- a/src/librustc/middle/trans/_match.rs +++ b/src/librustc/middle/trans/_match.rs @@ -240,7 +240,7 @@ enum Lit { ConstLit(ast::DefId), // the def ID of the constant } -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum VecLenOpt { vec_len_eq, vec_len_ge(/* length of prefix */uint) @@ -1215,7 +1215,7 @@ fn pick_col(m: &[Match]) -> uint { return best_col; } -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum branch_kind { no_branch, single, switch, compare, compare_vec_len, } // Compiles a comparison between two things. diff --git a/src/librustc/middle/trans/cabi.rs b/src/librustc/middle/trans/cabi.rs index 2c9be587eaa..02671b11866 100644 --- a/src/librustc/middle/trans/cabi.rs +++ b/src/librustc/middle/trans/cabi.rs @@ -18,7 +18,7 @@ use middle::trans::cabi_mips; use middle::trans::type_::Type; use syntax::abi::{X86, X86_64, Arm, Mips}; -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub enum ArgKind { /// Pass the argument directly using the normal converted /// LLVM type or by coercing to another specified type diff --git a/src/librustc/middle/trans/cabi_x86_64.rs b/src/librustc/middle/trans/cabi_x86_64.rs index 0ed87ef8092..9f98cf57c09 100644 --- a/src/librustc/middle/trans/cabi_x86_64.rs +++ b/src/librustc/middle/trans/cabi_x86_64.rs @@ -22,7 +22,7 @@ use middle::trans::type_::Type; use std::cmp; -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] enum RegClass { NoClass, Int, diff --git a/src/librustc/middle/trans/cleanup.rs b/src/librustc/middle/trans/cleanup.rs index 47d8ecec021..b28db3d378b 100644 --- a/src/librustc/middle/trans/cleanup.rs +++ b/src/librustc/middle/trans/cleanup.rs @@ -55,7 +55,7 @@ pub enum CleanupScopeKind<'a> { LoopScopeKind(ast::NodeId, [&'a Block<'a>, ..EXIT_MAX]) } -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum EarlyExitLabel { UnwindExit, ReturnExit, diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs index 0530e2a7463..5c24a62d2d5 100644 --- a/src/librustc/middle/trans/common.rs +++ b/src/librustc/middle/trans/common.rs @@ -722,7 +722,7 @@ pub fn expr_ty_adjusted(bcx: &Block, ex: &ast::Expr) -> ty::t { } // Key used to lookup values supplied for type parameters in an expr. -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum ExprOrMethodCall { // Type parameters for a path like `None::<int>` ExprId(ast::NodeId), diff --git a/src/librustc/middle/trans/datum.rs b/src/librustc/middle/trans/datum.rs index af9e614a17e..1ea25665c1c 100644 --- a/src/librustc/middle/trans/datum.rs +++ b/src/librustc/middle/trans/datum.rs @@ -82,7 +82,7 @@ impl Drop for Rvalue { fn drop(&mut self) { } } -#[deriving(Eq, TotalEq, Hash)] +#[deriving(PartialEq, TotalEq, Hash)] pub enum RvalueMode { /// `val` is a pointer to the actual value (and thus has type *T) ByRef, diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index 43d0d71154c..110dc3a1884 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -2403,7 +2403,7 @@ fn type_metadata(cx: &CrateContext, type_metadata } -#[deriving(Eq)] +#[deriving(PartialEq)] enum DebugLocation { KnownLocation { scope: DIScope, line: uint, col: uint }, UnknownLocation diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 1f997c36c42..6241c1222f9 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -79,7 +79,7 @@ use syntax::print::pprust::{expr_to_str}; // These are passed around by the code generating functions to track the // destination of a computation's value. -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum Dest { SaveIn(ValueRef), Ignore, @@ -1497,7 +1497,7 @@ fn float_cast(bcx: &Block, } else { llsrc }; } -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum cast_kind { cast_pointer, cast_integral, diff --git a/src/librustc/middle/trans/monomorphize.rs b/src/librustc/middle/trans/monomorphize.rs index f77cd0ee44d..683fb39c9e9 100644 --- a/src/librustc/middle/trans/monomorphize.rs +++ b/src/librustc/middle/trans/monomorphize.rs @@ -312,14 +312,14 @@ pub fn monomorphic_fn(ccx: &CrateContext, } // Used to identify cached monomorphized functions and vtables -#[deriving(Eq, TotalEq, Hash)] +#[deriving(PartialEq, TotalEq, Hash)] pub struct MonoParamId { pub subst: ty::t, // Do we really need the vtables to be hashed? Isn't the type enough? pub vtables: Vec<MonoId> } -#[deriving(Eq, TotalEq, Hash)] +#[deriving(PartialEq, TotalEq, Hash)] pub struct MonoId { pub def: ast::DefId, pub params: Vec<MonoParamId> diff --git a/src/librustc/middle/trans/type_.rs b/src/librustc/middle/trans/type_.rs index d5a80edfaed..dfe06f9ca4c 100644 --- a/src/librustc/middle/trans/type_.rs +++ b/src/librustc/middle/trans/type_.rs @@ -23,7 +23,7 @@ use std::mem; use libc::{c_uint}; -#[deriving(Clone, Eq, Show)] +#[deriving(Clone, PartialEq, Show)] pub struct Type { rf: TypeRef } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 4dc66427d7f..7d3c4beb674 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -65,7 +65,7 @@ pub static INITIAL_DISCRIMINANT_VALUE: Disr = 0; // Data types -#[deriving(Eq, TotalEq, Hash)] +#[deriving(PartialEq, TotalEq, Hash)] pub struct field { pub ident: ast::Ident, pub mt: mt @@ -121,13 +121,13 @@ impl Method { } } -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub struct mt { pub ty: t, pub mutbl: ast::Mutability, } -#[deriving(Clone, Eq, TotalEq, Hash, Encodable, Decodable, Show)] +#[deriving(Clone, PartialEq, TotalEq, Hash, Encodable, Decodable, Show)] pub enum TraitStore { /// Box<Trait> UniqTraitStore, @@ -145,7 +145,7 @@ pub struct field_ty { // Contains information needed to resolve types and (in the future) look up // the types of AST nodes. -#[deriving(Eq, TotalEq, Hash)] +#[deriving(PartialEq, TotalEq, Hash)] pub struct creader_cache_key { pub cnum: CrateNum, pub pos: uint, @@ -158,10 +158,10 @@ pub struct intern_key { sty: *sty, } -// NB: Do not replace this with #[deriving(Eq)]. The automatically-derived +// NB: Do not replace this with #[deriving(PartialEq)]. The automatically-derived // implementation will not recurse through sty and you will get stack // exhaustion. -impl cmp::Eq for intern_key { +impl cmp::PartialEq for intern_key { fn eq(&self, other: &intern_key) -> bool { unsafe { *self.sty == *other.sty @@ -185,14 +185,14 @@ pub enum ast_ty_to_ty_cache_entry { atttce_resolved(t) /* resolved to a type, irrespective of region */ } -#[deriving(Clone, Eq, Decodable, Encodable)] +#[deriving(Clone, PartialEq, Decodable, Encodable)] pub struct ItemVariances { pub self_param: Option<Variance>, pub type_params: OwnedSlice<Variance>, pub region_params: OwnedSlice<Variance> } -#[deriving(Clone, Eq, Decodable, Encodable, Show)] +#[deriving(Clone, PartialEq, Decodable, Encodable, Show)] pub enum Variance { Covariant, // T<A> <: T<B> iff A <: B -- e.g., function return type Invariant, // T<A> <: T<B> iff B == A -- e.g., type of mutable cell @@ -216,7 +216,7 @@ pub struct AutoDerefRef { pub autoref: Option<AutoRef> } -#[deriving(Clone, Decodable, Encodable, Eq, Show)] +#[deriving(Clone, Decodable, Encodable, PartialEq, Show)] pub enum AutoRef { /// Convert from T to &T AutoPtr(Region, ast::Mutability), @@ -387,7 +387,7 @@ pub struct t_box_ { enum t_opaque {} #[allow(raw_pointer_deriving)] -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub struct t { inner: *t_opaque } impl fmt::Show for t { @@ -415,14 +415,14 @@ pub fn type_needs_infer(t: t) -> bool { } pub fn type_id(t: t) -> uint { get(t).id } -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub struct BareFnTy { pub fn_style: ast::FnStyle, pub abi: abi::Abi, pub sig: FnSig, } -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub struct ClosureTy { pub fn_style: ast::FnStyle, pub onceness: ast::Onceness, @@ -443,7 +443,7 @@ pub struct ClosureTy { * - `output` is the return type. * - `variadic` indicates whether this is a varidic function. (only true for foreign fns) */ -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub struct FnSig { pub binder_id: ast::NodeId, pub inputs: Vec<t>, @@ -451,14 +451,14 @@ pub struct FnSig { pub variadic: bool } -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub struct param_ty { pub idx: uint, pub def_id: DefId } /// Representation of regions: -#[deriving(Clone, Eq, TotalEq, Hash, Encodable, Decodable, Show)] +#[deriving(Clone, PartialEq, TotalEq, Hash, Encodable, Decodable, Show)] pub enum Region { // Region bound in a type or fn declaration which will be // substituted 'early' -- that is, at the same time when type @@ -499,13 +499,13 @@ pub enum Region { * the original var id (that is, the root variable that is referenced * by the upvar) and the id of the closure expression. */ -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub struct UpvarId { pub var_id: ast::NodeId, pub closure_expr_id: ast::NodeId, } -#[deriving(Clone, Eq, TotalEq, Hash, Show)] +#[deriving(Clone, PartialEq, TotalEq, Hash, Show)] pub enum BorrowKind { /// Data must be immutable and is aliasable. ImmBorrow, @@ -600,7 +600,7 @@ pub enum BorrowKind { * the closure, so sometimes it is necessary for them to be larger * than the closure lifetime itself. */ -#[deriving(Eq, Clone)] +#[deriving(PartialEq, Clone)] pub struct UpvarBorrow { pub kind: BorrowKind, pub region: ty::Region, @@ -618,13 +618,13 @@ impl Region { } } -#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd, Hash, Encodable, Decodable, Show)] +#[deriving(Clone, PartialEq, PartialOrd, TotalEq, TotalOrd, Hash, Encodable, Decodable, Show)] pub struct FreeRegion { pub scope_id: NodeId, pub bound_region: BoundRegion } -#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd, Hash, Encodable, Decodable, Show)] +#[deriving(Clone, PartialEq, PartialOrd, TotalEq, TotalOrd, Hash, Encodable, Decodable, Show)] pub enum BoundRegion { /// An anonymous region parameter for a given fn (&T) BrAnon(uint), @@ -643,7 +643,7 @@ pub enum BoundRegion { * Represents the values to use when substituting lifetime parameters. * If the value is `ErasedRegions`, then this subst is occurring during * trans, and all region parameters will be replaced with `ty::ReStatic`. */ -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub enum RegionSubsts { ErasedRegions, NonerasedRegions(OwnedSlice<ty::Region>) @@ -666,7 +666,7 @@ pub enum RegionSubsts { * - `self_ty` is the type to which `self` should be remapped, if any. The * `self` type is rather funny in that it can only appear on traits and is * always substituted away to the implementing type for a trait. */ -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub struct substs { pub self_ty: Option<ty::t>, pub tps: Vec<t>, @@ -722,7 +722,7 @@ mod primitives { // NB: If you change this, you'll probably want to change the corresponding // AST structure in libsyntax/ast.rs as well. -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub enum sty { ty_nil, ty_bot, @@ -754,7 +754,7 @@ pub enum sty { // on non-useful type error messages) } -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub struct TyTrait { pub def_id: DefId, pub substs: substs, @@ -762,13 +762,13 @@ pub struct TyTrait { pub bounds: BuiltinBounds } -#[deriving(Eq, TotalEq, Hash)] +#[deriving(PartialEq, TotalEq, Hash)] pub struct TraitRef { pub def_id: DefId, pub substs: substs } -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub enum IntVarValue { IntType(ast::IntTy), UintType(ast::UintTy), @@ -822,7 +822,7 @@ pub enum type_err { terr_variadic_mismatch(expected_found<bool>) } -#[deriving(Eq, TotalEq, Hash)] +#[deriving(PartialEq, TotalEq, Hash)] pub struct ParamBounds { pub builtin_bounds: BuiltinBounds, pub trait_bounds: Vec<Rc<TraitRef>> @@ -830,7 +830,7 @@ pub struct ParamBounds { pub type BuiltinBounds = EnumSet<BuiltinBound>; -#[deriving(Clone, Encodable, Eq, TotalEq, Decodable, Hash, Show)] +#[deriving(Clone, Encodable, PartialEq, TotalEq, Decodable, Hash, Show)] #[repr(uint)] pub enum BuiltinBound { BoundStatic, @@ -862,21 +862,21 @@ impl CLike for BuiltinBound { } } -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub struct TyVid(pub uint); -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub struct IntVid(pub uint); -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub struct FloatVid(pub uint); -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct RegionVid { pub id: uint } -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub enum InferTy { TyVar(TyVid), IntVar(IntVid), @@ -889,7 +889,7 @@ pub enum InferRegion { ReSkolemized(uint, BoundRegion) } -impl cmp::Eq for InferRegion { +impl cmp::PartialEq for InferRegion { fn eq(&self, other: &InferRegion) -> bool { match ((*self), *other) { (ReVar(rva), ReVar(rvb)) => { @@ -2402,7 +2402,7 @@ pub fn is_instantiable(cx: &ctxt, r_ty: t) -> bool { /// distinguish between types that are recursive with themselves and types that /// contain a different recursive type. These cases can therefore be treated /// differently when reporting errors. -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum Representability { Representable, SelfRecursive, diff --git a/src/librustc/middle/typeck/check/_match.rs b/src/librustc/middle/typeck/check/_match.rs index 565b951df25..072b4ea7fe1 100644 --- a/src/librustc/middle/typeck/check/_match.rs +++ b/src/librustc/middle/typeck/check/_match.rs @@ -758,7 +758,7 @@ pub fn check_pointer_pat(pcx: &pat_ctxt, } } -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum PointerKind { Send, Borrowed, diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs index 735bec4f4db..8cea03c59e7 100644 --- a/src/librustc/middle/typeck/check/method.rs +++ b/src/librustc/middle/typeck/check/method.rs @@ -106,19 +106,19 @@ use syntax::codemap::Span; use syntax::parse::token; use syntax::owned_slice::OwnedSlice; -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum CheckTraitsFlag { CheckTraitsOnly, CheckTraitsAndInherentMethods, } -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum AutoderefReceiverFlag { AutoderefReceiver, DontAutoderefReceiver, } -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum StaticMethodsFlag { ReportStaticMethods, IgnoreStaticMethods, diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index 1987f4b0751..70d8deaf03c 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -213,7 +213,7 @@ impl FnStyleState { /// Whether `check_binop` is part of an assignment or not. /// Used to know wether we allow user overloads and to print /// better messages on error. -#[deriving(Eq)] +#[deriving(PartialEq)] enum IsBinopAssignment{ SimpleBinop, BinopAssignment, diff --git a/src/librustc/middle/typeck/infer/lattice.rs b/src/librustc/middle/typeck/infer/lattice.rs index 41a59dae740..6737a638dd8 100644 --- a/src/librustc/middle/typeck/infer/lattice.rs +++ b/src/librustc/middle/typeck/infer/lattice.rs @@ -72,19 +72,19 @@ impl LatticeValue for ty::t { pub trait CombineFieldsLatticeMethods { fn var_sub_var<T:Clone + InferStr + LatticeValue, - V:Clone + Eq + ToStr + Vid + UnifyVid<Bounds<T>>>(&self, + V:Clone + PartialEq + ToStr + Vid + UnifyVid<Bounds<T>>>(&self, a_id: V, b_id: V) -> ures; /// make variable a subtype of T fn var_sub_t<T:Clone + InferStr + LatticeValue, - V:Clone + Eq + ToStr + Vid + UnifyVid<Bounds<T>>>( + V:Clone + PartialEq + ToStr + Vid + UnifyVid<Bounds<T>>>( &self, a_id: V, b: T) -> ures; fn t_sub_var<T:Clone + InferStr + LatticeValue, - V:Clone + Eq + ToStr + Vid + UnifyVid<Bounds<T>>>( + V:Clone + PartialEq + ToStr + Vid + UnifyVid<Bounds<T>>>( &self, a: T, b_id: V) @@ -96,7 +96,7 @@ pub trait CombineFieldsLatticeMethods { lattice_op: LatticeOp<T>) -> cres<Bound<T>>; fn set_var_to_merged_bounds<T:Clone + InferStr + LatticeValue, - V:Clone+Eq+ToStr+Vid+UnifyVid<Bounds<T>>>( + V:Clone+PartialEq+ToStr+Vid+UnifyVid<Bounds<T>>>( &self, v_id: V, a: &Bounds<T>, @@ -112,7 +112,7 @@ pub trait CombineFieldsLatticeMethods { impl<'f> CombineFieldsLatticeMethods for CombineFields<'f> { fn var_sub_var<T:Clone + InferStr + LatticeValue, - V:Clone + Eq + ToStr + Vid + UnifyVid<Bounds<T>>>( + V:Clone + PartialEq + ToStr + Vid + UnifyVid<Bounds<T>>>( &self, a_id: V, b_id: V) @@ -165,7 +165,7 @@ impl<'f> CombineFieldsLatticeMethods for CombineFields<'f> { /// make variable a subtype of T fn var_sub_t<T:Clone + InferStr + LatticeValue, - V:Clone + Eq + ToStr + Vid + UnifyVid<Bounds<T>>>( + V:Clone + PartialEq + ToStr + Vid + UnifyVid<Bounds<T>>>( &self, a_id: V, b: T) @@ -189,7 +189,7 @@ impl<'f> CombineFieldsLatticeMethods for CombineFields<'f> { } fn t_sub_var<T:Clone + InferStr + LatticeValue, - V:Clone + Eq + ToStr + Vid + UnifyVid<Bounds<T>>>( + V:Clone + PartialEq + ToStr + Vid + UnifyVid<Bounds<T>>>( &self, a: T, b_id: V) @@ -238,7 +238,7 @@ impl<'f> CombineFieldsLatticeMethods for CombineFields<'f> { } fn set_var_to_merged_bounds<T:Clone + InferStr + LatticeValue, - V:Clone+Eq+ToStr+Vid+UnifyVid<Bounds<T>>>( + V:Clone+PartialEq+ToStr+Vid+UnifyVid<Bounds<T>>>( &self, v_id: V, a: &Bounds<T>, @@ -432,7 +432,7 @@ pub enum LatticeVarResult<V,T> { * return. */ pub fn lattice_vars<L:LatticeDir + Combine, T:Clone + InferStr + LatticeValue, - V:Clone + Eq + ToStr + Vid + UnifyVid<Bounds<T>>>( + V:Clone + PartialEq + ToStr + Vid + UnifyVid<Bounds<T>>>( this: &L, // defines whether we want LUB or GLB a_vid: V, // first variable b_vid: V, // second variable @@ -478,7 +478,7 @@ pub fn lattice_vars<L:LatticeDir + Combine, pub fn lattice_var_and_t<L:LatticeDir + Combine, T:Clone + InferStr + LatticeValue, - V:Clone + Eq + ToStr + Vid + UnifyVid<Bounds<T>>>( + V:Clone + PartialEq + ToStr + Vid + UnifyVid<Bounds<T>>>( this: &L, a_id: V, b: &T, diff --git a/src/librustc/middle/typeck/infer/mod.rs b/src/librustc/middle/typeck/infer/mod.rs index d560b1c9a99..fa52ef5dab6 100644 --- a/src/librustc/middle/typeck/infer/mod.rs +++ b/src/librustc/middle/typeck/infer/mod.rs @@ -456,7 +456,7 @@ trait CresCompare<T> { fn compare(&self, t: T, f: || -> ty::type_err) -> cres<T>; } -impl<T:Clone + Eq> CresCompare<T> for cres<T> { +impl<T:Clone + PartialEq> CresCompare<T> for cres<T> { fn compare(&self, t: T, f: || -> ty::type_err) -> cres<T> { (*self).clone().and_then(|s| { if s == t { diff --git a/src/librustc/middle/typeck/infer/region_inference/mod.rs b/src/librustc/middle/typeck/infer/region_inference/mod.rs index c964530a5f9..8ec4b52ffd1 100644 --- a/src/librustc/middle/typeck/infer/region_inference/mod.rs +++ b/src/librustc/middle/typeck/infer/region_inference/mod.rs @@ -31,7 +31,7 @@ use syntax::ast; mod doc; -#[deriving(Eq, TotalEq, Hash)] +#[deriving(PartialEq, TotalEq, Hash)] pub enum Constraint { ConstrainVarSubVar(RegionVid, RegionVid), ConstrainRegSubVar(Region, RegionVid), @@ -39,7 +39,7 @@ pub enum Constraint { ConstrainRegSubReg(Region, Region), } -#[deriving(Eq, TotalEq, Hash)] +#[deriving(PartialEq, TotalEq, Hash)] pub struct TwoRegions { a: Region, b: Region, @@ -759,7 +759,7 @@ impl<'a> RegionVarBindings<'a> { // ______________________________________________________________________ -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] enum Classification { Expanding, Contracting } pub enum VarValue { NoValue, Value(Region), ErrorValue } diff --git a/src/librustc/middle/typeck/infer/unify.rs b/src/librustc/middle/typeck/infer/unify.rs index 867e52056a7..653624bf8ee 100644 --- a/src/librustc/middle/typeck/infer/unify.rs +++ b/src/librustc/middle/typeck/infer/unify.rs @@ -52,7 +52,7 @@ pub trait UnifyVid<T> { pub trait UnifyInferCtxtMethods { fn get<T:Clone, - V:Clone + Eq + Vid + UnifyVid<T>>( + V:Clone + PartialEq + Vid + UnifyVid<T>>( &self, vid: V) -> Node<V, T>; @@ -71,7 +71,7 @@ pub trait UnifyInferCtxtMethods { impl<'a> UnifyInferCtxtMethods for InferCtxt<'a> { fn get<T:Clone, - V:Clone + Eq + Vid + UnifyVid<T>>( + V:Clone + PartialEq + Vid + UnifyVid<T>>( &self, vid: V) -> Node<V, T> { @@ -86,7 +86,7 @@ impl<'a> UnifyInferCtxtMethods for InferCtxt<'a> { let vb = UnifyVid::appropriate_vals_and_bindings(self); return helper(tcx, &mut *vb.borrow_mut(), vid); - fn helper<T:Clone, V:Clone+Eq+Vid>( + fn helper<T:Clone, V:Clone+PartialEq+Vid>( tcx: &ty::ctxt, vb: &mut ValsAndBindings<V,T>, vid: V) -> Node<V, T> @@ -191,15 +191,15 @@ pub fn mk_err<T:SimplyUnifiable>(a_is_expected: bool, } pub trait InferCtxtMethods { - fn simple_vars<T:Clone + Eq + InferStr + SimplyUnifiable, - V:Clone + Eq + Vid + ToStr + UnifyVid<Option<T>>>( + fn simple_vars<T:Clone + PartialEq + InferStr + SimplyUnifiable, + V:Clone + PartialEq + Vid + ToStr + UnifyVid<Option<T>>>( &self, a_is_expected: bool, a_id: V, b_id: V) -> ures; - fn simple_var_t<T:Clone + Eq + InferStr + SimplyUnifiable, - V:Clone + Eq + Vid + ToStr + UnifyVid<Option<T>>>( + fn simple_var_t<T:Clone + PartialEq + InferStr + SimplyUnifiable, + V:Clone + PartialEq + Vid + ToStr + UnifyVid<Option<T>>>( &self, a_is_expected: bool, a_id: V, @@ -208,8 +208,8 @@ pub trait InferCtxtMethods { } impl<'a> InferCtxtMethods for InferCtxt<'a> { - fn simple_vars<T:Clone + Eq + InferStr + SimplyUnifiable, - V:Clone + Eq + Vid + ToStr + UnifyVid<Option<T>>>( + fn simple_vars<T:Clone + PartialEq + InferStr + SimplyUnifiable, + V:Clone + PartialEq + Vid + ToStr + UnifyVid<Option<T>>>( &self, a_is_expected: bool, a_id: V, @@ -248,8 +248,8 @@ impl<'a> InferCtxtMethods for InferCtxt<'a> { return uok(); } - fn simple_var_t<T:Clone + Eq + InferStr + SimplyUnifiable, - V:Clone + Eq + Vid + ToStr + UnifyVid<Option<T>>>( + fn simple_var_t<T:Clone + PartialEq + InferStr + SimplyUnifiable, + V:Clone + PartialEq + Vid + ToStr + UnifyVid<Option<T>>>( &self, a_is_expected: bool, a_id: V, diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs index bfe09fdd2b2..156479dc7a3 100644 --- a/src/librustc/middle/typeck/mod.rs +++ b/src/librustc/middle/typeck/mod.rs @@ -84,7 +84,7 @@ pub mod collect; pub mod coherence; pub mod variance; -#[deriving(Clone, Encodable, Decodable, Eq, Ord)] +#[deriving(Clone, Encodable, Decodable, PartialEq, PartialOrd)] pub enum param_index { param_numbered(uint), param_self @@ -147,7 +147,7 @@ pub struct MethodCallee { pub substs: ty::substs } -#[deriving(Clone, Eq, TotalEq, Hash, Show)] +#[deriving(Clone, PartialEq, TotalEq, Hash, Show)] pub struct MethodCall { pub expr_id: ast::NodeId, pub autoderef: u32 diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 610cc992eed..5deadc88672 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -490,7 +490,7 @@ impl Clean<Option<Vec<TyParamBound>>> for ty::substs { } } -#[deriving(Clone, Encodable, Decodable, Eq)] +#[deriving(Clone, Encodable, Decodable, PartialEq)] pub struct Lifetime(String); impl Lifetime { @@ -631,7 +631,7 @@ impl Clean<Item> for ast::TypeMethod { } } -#[deriving(Clone, Encodable, Decodable, Eq)] +#[deriving(Clone, Encodable, Decodable, PartialEq)] pub enum SelfTy { SelfStatic, SelfValue, @@ -1458,7 +1458,7 @@ impl Clean<Item> for doctree::Static { } } -#[deriving(Show, Clone, Encodable, Decodable, Eq)] +#[deriving(Show, Clone, Encodable, Decodable, PartialEq)] pub enum Mutability { Mutable, Immutable, diff --git a/src/librustdoc/html/item_type.rs b/src/librustdoc/html/item_type.rs index a19d0b6fb30..0f000f4e5ae 100644 --- a/src/librustdoc/html/item_type.rs +++ b/src/librustdoc/html/item_type.rs @@ -19,7 +19,7 @@ use clean; /// discriminants. JavaScript then is used to decode them into the original value. /// Consequently, every change to this type should be synchronized to /// the `itemTypes` mapping table in `static/main.js`. -#[deriving(Eq, Clone)] +#[deriving(PartialEq, Clone)] pub enum ItemType { Module = 0, Struct = 1, diff --git a/src/librustdoc/html/toc.rs b/src/librustdoc/html/toc.rs index aa01247c1b6..2356d4c754f 100644 --- a/src/librustdoc/html/toc.rs +++ b/src/librustdoc/html/toc.rs @@ -14,7 +14,7 @@ use std::fmt; use std::string::String; /// A (recursive) table of contents -#[deriving(Eq)] +#[deriving(PartialEq)] pub struct Toc { /// The levels are strictly decreasing, i.e. /// @@ -36,7 +36,7 @@ impl Toc { } } -#[deriving(Eq)] +#[deriving(PartialEq)] pub struct TocEntry { level: u32, sec_number: String, @@ -46,7 +46,7 @@ pub struct TocEntry { } /// Progressive construction of a table of contents. -#[deriving(Eq)] +#[deriving(PartialEq)] pub struct TocBuilder { top_level: Toc, /// The current heirachy of parent headings, the levels are diff --git a/src/librustuv/timeout.rs b/src/librustuv/timeout.rs index a67b2b481e4..15add60b59c 100644 --- a/src/librustuv/timeout.rs +++ b/src/librustuv/timeout.rs @@ -34,14 +34,14 @@ pub struct Guard<'a> { pub can_timeout: bool, } -#[deriving(Eq)] +#[deriving(PartialEq)] enum TimeoutState { NoTimeout, TimeoutPending(ClientState), TimedOut, } -#[deriving(Eq)] +#[deriving(PartialEq)] enum ClientState { NoWaiter, AccessPending, diff --git a/src/librustuv/uvll.rs b/src/librustuv/uvll.rs index 6236fd0e0e5..91c68147251 100644 --- a/src/librustuv/uvll.rs +++ b/src/librustuv/uvll.rs @@ -254,7 +254,7 @@ pub type uv_shutdown_cb = extern "C" fn(req: *uv_shutdown_t, status: c_int); #[cfg(windows)] pub type uv_gid_t = libc::c_uchar; #[repr(C)] -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum uv_handle_type { UV_UNKNOWN_HANDLE, UV_ASYNC, @@ -279,7 +279,7 @@ pub enum uv_handle_type { #[repr(C)] #[cfg(unix)] -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum uv_req_type { UV_UNKNOWN_REQ, UV_REQ, @@ -297,7 +297,7 @@ pub enum uv_req_type { // See UV_REQ_TYPE_PRIVATE at libuv/include/uv-win.h #[repr(C)] #[cfg(windows)] -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum uv_req_type { UV_UNKNOWN_REQ, UV_REQ, @@ -320,7 +320,7 @@ pub enum uv_req_type { } #[repr(C)] -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum uv_membership { UV_LEAVE_GROUP, UV_JOIN_GROUP diff --git a/src/libsemver/lib.rs b/src/libsemver/lib.rs index 51dcc6d3faf..dbde1a7486d 100644 --- a/src/libsemver/lib.rs +++ b/src/libsemver/lib.rs @@ -46,14 +46,14 @@ use std::string::String; /// An identifier in the pre-release or build metadata. If the identifier can /// be parsed as a decimal value, it will be represented with `Numeric`. -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] #[allow(missing_doc)] pub enum Identifier { Numeric(uint), AlphaNumeric(String) } -impl cmp::Ord for Identifier { +impl cmp::PartialOrd for Identifier { #[inline] fn lt(&self, other: &Identifier) -> bool { match (self, other) { @@ -115,7 +115,7 @@ impl fmt::Show for Version { } } -impl cmp::Eq for Version { +impl cmp::PartialEq for Version { #[inline] fn eq(&self, other: &Version) -> bool { // We should ignore build metadata here, otherwise versions v1 and v2 @@ -128,7 +128,7 @@ impl cmp::Eq for Version { } } -impl cmp::Ord for Version { +impl cmp::PartialOrd for Version { #[inline] fn lt(&self, other: &Version) -> bool { diff --git a/src/libserialize/collection_impls.rs b/src/libserialize/collection_impls.rs index 8631fef5168..7ca0f372891 100644 --- a/src/libserialize/collection_impls.rs +++ b/src/libserialize/collection_impls.rs @@ -76,8 +76,8 @@ impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for RingBuf<T> { impl< E, S: Encoder<E>, - K: Encodable<S, E> + Eq + TotalOrd, - V: Encodable<S, E> + Eq + K: Encodable<S, E> + PartialEq + TotalOrd, + V: Encodable<S, E> + PartialEq > Encodable<S, E> for TreeMap<K, V> { fn encode(&self, e: &mut S) -> Result<(), E> { e.emit_map(self.len(), |e| { @@ -95,8 +95,8 @@ impl< impl< E, D: Decoder<E>, - K: Decodable<D, E> + Eq + TotalOrd, - V: Decodable<D, E> + Eq + K: Decodable<D, E> + PartialEq + TotalOrd, + V: Decodable<D, E> + PartialEq > Decodable<D, E> for TreeMap<K, V> { fn decode(d: &mut D) -> Result<TreeMap<K, V>, E> { d.read_map(|d, len| { @@ -114,7 +114,7 @@ impl< impl< E, S: Encoder<E>, - T: Encodable<S, E> + Eq + TotalOrd + T: Encodable<S, E> + PartialEq + TotalOrd > Encodable<S, E> for TreeSet<T> { fn encode(&self, s: &mut S) -> Result<(), E> { s.emit_seq(self.len(), |s| { @@ -131,7 +131,7 @@ impl< impl< E, D: Decoder<E>, - T: Decodable<D, E> + Eq + TotalOrd + T: Decodable<D, E> + PartialEq + TotalOrd > Decodable<D, E> for TreeSet<T> { fn decode(d: &mut D) -> Result<TreeSet<T>, E> { d.read_seq(|d, len| { diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index 09ba46bf0c7..5e23c9c3451 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -249,7 +249,7 @@ use Encodable; use collections::{HashMap, TreeMap}; /// Represents a json value -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub enum Json { Number(f64), String(String), @@ -263,7 +263,7 @@ pub type List = Vec<Json>; pub type Object = TreeMap<String, Json>; /// The errors that can arise while parsing a JSON stream. -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub enum ErrorCode { InvalidSyntax, InvalidNumber, @@ -283,7 +283,7 @@ pub enum ErrorCode { NotUtf8, } -#[deriving(Clone, Eq, Show)] +#[deriving(Clone, PartialEq, Show)] pub enum ParserError { /// msg, line, col SyntaxError(ErrorCode, uint, uint), @@ -293,7 +293,7 @@ pub enum ParserError { // Builder and Parser have the same errors. pub type BuilderError = ParserError; -#[deriving(Clone, Eq, Show)] +#[deriving(Clone, PartialEq, Show)] pub enum DecoderError { ParseError(ParserError), ExpectedError(String, String), @@ -975,7 +975,7 @@ impl Json { } /// The output of the streaming parser. -#[deriving(Eq, Clone, Show)] +#[deriving(PartialEq, Clone, Show)] pub enum JsonEvent { ObjectStart, ObjectEnd, @@ -988,7 +988,7 @@ pub enum JsonEvent { Error(ParserError), } -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] enum ParserState { // Parse a value in a list, true means first element. ParseList(bool), @@ -1017,7 +1017,7 @@ pub struct Stack { /// StackElements compose a Stack. /// For example, Key("foo"), Key("bar"), Index(3) and Key("x") are the /// StackElements compositing the stack that represents foo.bar[3].x -#[deriving(Eq, Clone, Show)] +#[deriving(PartialEq, Clone, Show)] pub enum StackElement<'l> { Index(u32), Key(&'l str), @@ -1025,7 +1025,7 @@ pub enum StackElement<'l> { // Internally, Key elements are stored as indices in a buffer to avoid // allocating a string for every member of an object. -#[deriving(Eq, Clone, Show)] +#[deriving(PartialEq, Clone, Show)] enum InternalStackElement { InternalIndex(u32), InternalKey(u16, u16), // start, size @@ -2082,7 +2082,7 @@ impl ::Decoder<DecoderError> for Decoder { } /// Test if two json values are less than one another -impl Ord for Json { +impl PartialOrd for Json { fn lt(&self, other: &Json) -> bool { match *self { Number(f0) => { @@ -2288,20 +2288,20 @@ mod tests { use std::io; use collections::TreeMap; - #[deriving(Eq, Encodable, Decodable, Show)] + #[deriving(PartialEq, Encodable, Decodable, Show)] enum Animal { Dog, Frog(String, int) } - #[deriving(Eq, Encodable, Decodable, Show)] + #[deriving(PartialEq, Encodable, Decodable, Show)] struct Inner { a: (), b: uint, c: Vec<String>, } - #[deriving(Eq, Encodable, Decodable, Show)] + #[deriving(PartialEq, Encodable, Decodable, Show)] struct Outer { inner: Vec<Inner>, } diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs index 75b31f9c354..222297aaf0e 100644 --- a/src/libstd/ascii.rs +++ b/src/libstd/ascii.rs @@ -23,7 +23,7 @@ use to_str::{IntoStr}; use vec::Vec; /// Datatype to hold one ascii character. It wraps a `u8`, with the highest bit always zero. -#[deriving(Clone, Eq, Ord, TotalOrd, TotalEq, Hash)] +#[deriving(Clone, PartialEq, PartialOrd, TotalOrd, TotalEq, Hash)] pub struct Ascii { chr: u8 } impl Ascii { diff --git a/src/libstd/bitflags.rs b/src/libstd/bitflags.rs index 6b393987281..eb8c7e7d283 100644 --- a/src/libstd/bitflags.rs +++ b/src/libstd/bitflags.rs @@ -78,7 +78,7 @@ //! //! # Derived traits //! -//! The `Eq` and `Clone` traits are automatically derived for the `struct` using +//! The `PartialEq` and `Clone` traits are automatically derived for the `struct` using //! the `deriving` attribute. Additional traits can be derived by providing an //! explicit `deriving` attribute on `flags`. //! @@ -112,7 +112,7 @@ macro_rules! bitflags( ($(#[$attr:meta])* flags $BitFlags:ident: $T:ty { $($(#[$Flag_attr:meta])* static $Flag:ident = $value:expr),+ }) => ( - #[deriving(Eq, TotalEq, Clone)] + #[deriving(PartialEq, TotalEq, Clone)] $(#[$attr])* pub struct $BitFlags { bits: $T, diff --git a/src/libstd/c_str.rs b/src/libstd/c_str.rs index 983d76a0844..4e39518deb4 100644 --- a/src/libstd/c_str.rs +++ b/src/libstd/c_str.rs @@ -66,7 +66,7 @@ fn main() { */ use clone::Clone; -use cmp::Eq; +use cmp::PartialEq; use container::Container; use iter::{Iterator, range}; use kinds::marker; @@ -109,7 +109,7 @@ impl Clone for CString { } } -impl Eq for CString { +impl PartialEq for CString { fn eq(&self, other: &CString) -> bool { if self.buf as uint == other.buf as uint { true diff --git a/src/libstd/comm/mod.rs b/src/libstd/comm/mod.rs index 18857e221fa..170618e276b 100644 --- a/src/libstd/comm/mod.rs +++ b/src/libstd/comm/mod.rs @@ -360,7 +360,7 @@ pub struct SyncSender<T> { /// This enumeration is the list of the possible reasons that try_recv could not /// return data when called. -#[deriving(Eq, Clone, Show)] +#[deriving(PartialEq, Clone, Show)] pub enum TryRecvError { /// This channel is currently empty, but the sender(s) have not yet /// disconnected, so data may yet become available. @@ -372,7 +372,7 @@ pub enum TryRecvError { /// This enumeration is the list of the possible error outcomes for the /// `SyncSender::try_send` method. -#[deriving(Eq, Clone, Show)] +#[deriving(PartialEq, Clone, Show)] pub enum TrySendError<T> { /// The data could not be sent on the channel because it would require that /// the callee block to send the data. diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index 643bc166c27..0d421760162 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -378,7 +378,7 @@ mod test { /// A type, free to create, primarily intended for benchmarking creation of /// wrappers that, just for construction, don't need a Reader/Writer that /// does anything useful. Is equivalent to `/dev/null` in semantics. - #[deriving(Clone,Eq,Ord)] + #[deriving(Clone,PartialEq,PartialOrd)] pub struct NullStream; impl Reader for NullStream { diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 4d02a470f30..78700d353af 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -285,7 +285,7 @@ pub type IoResult<T> = Result<T, IoError>; /// # FIXME /// /// Is something like this sufficient? It's kind of archaic -#[deriving(Eq, Clone)] +#[deriving(PartialEq, Clone)] pub struct IoError { /// An enumeration which can be matched against for determining the flavor /// of error. @@ -395,7 +395,7 @@ impl fmt::Show for IoError { } /// A list specifying general categories of I/O error. -#[deriving(Eq, Clone, Show)] +#[deriving(PartialEq, Clone, Show)] pub enum IoErrorKind { /// Any I/O error not part of this list. OtherIoError, @@ -1582,7 +1582,7 @@ pub enum FileAccess { } /// Different kinds of files which can be identified by a call to stat -#[deriving(Eq, Show, Hash)] +#[deriving(PartialEq, Show, Hash)] pub enum FileType { /// This is a normal file, corresponding to `S_IFREG` TypeFile, @@ -1726,7 +1726,7 @@ mod tests { use prelude::*; use uint; - #[deriving(Clone, Eq, Show)] + #[deriving(Clone, PartialEq, Show)] enum BadReaderBehavior { GoodBehavior(uint), BadBehavior(uint) diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs index 5004e8a5a07..4d0e5e7f72d 100644 --- a/src/libstd/io/net/ip.rs +++ b/src/libstd/io/net/ip.rs @@ -25,7 +25,7 @@ use slice::{MutableCloneableVector, ImmutableVector, MutableVector}; pub type Port = u16; -#[deriving(Eq, TotalEq, Clone, Hash)] +#[deriving(PartialEq, TotalEq, Clone, Hash)] pub enum IpAddr { Ipv4Addr(u8, u8, u8, u8), Ipv6Addr(u16, u16, u16, u16, u16, u16, u16, u16) @@ -56,7 +56,7 @@ impl fmt::Show for IpAddr { } } -#[deriving(Eq, TotalEq, Clone, Hash)] +#[deriving(PartialEq, TotalEq, Clone, Hash)] pub struct SocketAddr { pub ip: IpAddr, pub port: Port, diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs index 20d20a14f9a..8325ee4ccd9 100644 --- a/src/libstd/io/process.rs +++ b/src/libstd/io/process.rs @@ -317,7 +317,7 @@ impl fmt::Show for Command { } /// The output of a finished process. -#[deriving(Eq, TotalEq, Clone)] +#[deriving(PartialEq, TotalEq, Clone)] pub struct ProcessOutput { /// The status (exit code) of the process. pub status: ProcessExit, @@ -348,7 +348,7 @@ pub enum StdioContainer { /// Describes the result of a process after it has terminated. /// Note that Windows have no signals, so the result is usually ExitStatus. -#[deriving(Eq, TotalEq, Clone)] +#[deriving(PartialEq, TotalEq, Clone)] pub enum ProcessExit { /// Normal termination with an exit status. ExitStatus(int), diff --git a/src/libstd/io/signal.rs b/src/libstd/io/signal.rs index 4d294e84070..05392baff04 100644 --- a/src/libstd/io/signal.rs +++ b/src/libstd/io/signal.rs @@ -34,7 +34,7 @@ use vec::Vec; /// Signals that can be sent and received #[repr(int)] -#[deriving(Eq, Hash, Show)] +#[deriving(PartialEq, Hash, Show)] pub enum Signum { /// Equivalent to SIGBREAK, delivered when the user presses Ctrl-Break. Break = 21i, diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index 9700f8c9970..602a2240f39 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -702,7 +702,7 @@ mod tests { test_checked_next_power_of_two!(test_checked_next_power_of_two_u64, u64) test_checked_next_power_of_two!(test_checked_next_power_of_two_uint, uint) - #[deriving(Eq, Show)] + #[deriving(PartialEq, Show)] struct Value { x: int } impl ToPrimitive for Value { diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs index 20f5927c9bd..54ca5797804 100644 --- a/src/libstd/num/strconv.rs +++ b/src/libstd/num/strconv.rs @@ -20,7 +20,7 @@ use num; use ops::{Add, Sub, Mul, Div, Rem, Neg}; use option::{None, Option, Some}; use slice::{ImmutableVector, MutableVector}; -use std::cmp::{Ord, Eq}; +use std::cmp::{PartialOrd, PartialEq}; use str::StrSlice; use string::String; use vec::Vec; @@ -259,7 +259,7 @@ pub fn int_to_str_bytes_common<T: Int>(num: T, radix: uint, sign: SignFormat, f: * between digit and exponent sign `'p'`. */ #[allow(deprecated)] -pub fn float_to_str_bytes_common<T:NumCast+Zero+One+Eq+Ord+Float+ +pub fn float_to_str_bytes_common<T:NumCast+Zero+One+PartialEq+PartialOrd+Float+ Div<T,T>+Neg<T>+Rem<T,T>+Mul<T,T>>( num: T, radix: uint, negative_zero: bool, sign: SignFormat, digits: SignificantDigits, exp_format: ExponentFormat, exp_upper: bool @@ -492,7 +492,7 @@ pub fn float_to_str_bytes_common<T:NumCast+Zero+One+Eq+Ord+Float+ * `to_str_bytes_common()`, for details see there. */ #[inline] -pub fn float_to_str_common<T:NumCast+Zero+One+Eq+Ord+NumStrConv+Float+ +pub fn float_to_str_common<T:NumCast+Zero+One+PartialEq+PartialOrd+NumStrConv+Float+ Div<T,T>+Neg<T>+Rem<T,T>+Mul<T,T>>( num: T, radix: uint, negative_zero: bool, sign: SignFormat, digits: SignificantDigits, exp_format: ExponentFormat, exp_capital: bool @@ -547,7 +547,7 @@ static DIGIT_E_RADIX: uint = ('e' as uint) - ('a' as uint) + 11u; * - Fails if `radix` > 18 and `special == true` due to conflict * between digit and lowest first character in `inf` and `NaN`, the `'i'`. */ -pub fn from_str_bytes_common<T:NumCast+Zero+One+Eq+Ord+Div<T,T>+ +pub fn from_str_bytes_common<T:NumCast+Zero+One+PartialEq+PartialOrd+Div<T,T>+ Mul<T,T>+Sub<T,T>+Neg<T>+Add<T,T>+ NumStrConv+Clone>( buf: &[u8], radix: uint, negative: bool, fractional: bool, @@ -754,7 +754,7 @@ pub fn from_str_bytes_common<T:NumCast+Zero+One+Eq+Ord+Div<T,T>+ * `from_str_bytes_common()`, for details see there. */ #[inline] -pub fn from_str_common<T:NumCast+Zero+One+Eq+Ord+Div<T,T>+Mul<T,T>+ +pub fn from_str_common<T:NumCast+Zero+One+PartialEq+PartialOrd+Div<T,T>+Mul<T,T>+ Sub<T,T>+Neg<T>+Add<T,T>+NumStrConv+Clone>( buf: &str, radix: uint, negative: bool, fractional: bool, special: bool, exponent: ExponentFormat, empty_zero: bool, diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index c0c7a042f11..fbecbd7665b 100644 --- a/src/libstd/path/posix.rs +++ b/src/libstd/path/posix.rs @@ -13,7 +13,7 @@ use container::Container; use c_str::{CString, ToCStr}; use clone::Clone; -use cmp::{Eq, TotalEq}; +use cmp::{PartialEq, TotalEq}; use from_str::FromStr; use io::Writer; use iter::{DoubleEndedIterator, AdditiveIterator, Extendable, Iterator, Map}; @@ -58,7 +58,7 @@ pub fn is_sep(c: char) -> bool { c == SEP } -impl Eq for Path { +impl PartialEq for Path { #[inline] fn eq(&self, other: &Path) -> bool { self.repr == other.repr diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs index 88c3e9def8c..d46a373de4d 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -13,7 +13,7 @@ use ascii::AsciiCast; use c_str::{CString, ToCStr}; use clone::Clone; -use cmp::{Eq, TotalEq}; +use cmp::{PartialEq, TotalEq}; use container::Container; use from_str::FromStr; use io::Writer; @@ -79,7 +79,7 @@ pub struct Path { sepidx: Option<uint> // index of the final separator in the non-prefix portion of repr } -impl Eq for Path { +impl PartialEq for Path { #[inline] fn eq(&self, other: &Path) -> bool { self.repr == other.repr @@ -956,7 +956,7 @@ pub fn is_sep_byte_verbatim(u: &u8) -> bool { } /// Prefix types for Path -#[deriving(Eq, Clone)] +#[deriving(PartialEq, Clone)] pub enum PathPrefix { /// Prefix `\\?\`, uint is the length of the following component VerbatimPrefix(uint), diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs index 07aaeac64be..ac1aaa2c6ca 100644 --- a/src/libstd/prelude.rs +++ b/src/libstd/prelude.rs @@ -58,7 +58,7 @@ #[doc(no_inline)] pub use c_str::ToCStr; #[doc(no_inline)] pub use char::Char; #[doc(no_inline)] pub use clone::Clone; -#[doc(no_inline)] pub use cmp::{Eq, Ord, TotalEq, TotalOrd}; +#[doc(no_inline)] pub use cmp::{PartialEq, PartialOrd, TotalEq, TotalOrd}; #[doc(no_inline)] pub use cmp::{Ordering, Less, Equal, Greater, Equiv}; #[doc(no_inline)] pub use container::{Container, Mutable, Map, MutableMap}; #[doc(no_inline)] pub use container::{Set, MutableSet}; diff --git a/src/libstd/slice.rs b/src/libstd/slice.rs index 55bea068641..1433270346e 100644 --- a/src/libstd/slice.rs +++ b/src/libstd/slice.rs @@ -1916,7 +1916,7 @@ mod tests { assert!(values == [2, 3, 5, 6, 7]); } - #[deriving(Clone, Eq)] + #[deriving(Clone, PartialEq)] struct Foo; #[test] diff --git a/src/libstd/str.rs b/src/libstd/str.rs index 6538809c8f1..a35b4e7a151 100644 --- a/src/libstd/str.rs +++ b/src/libstd/str.rs @@ -68,7 +68,7 @@ is the same as `&[u8]`. use char::Char; use char; use clone::Clone; -use cmp::{Eq, TotalEq, Ord, TotalOrd, Equiv, Ordering}; +use cmp::{PartialEq, TotalEq, PartialOrd, TotalOrd, Equiv, Ordering}; use container::Container; use default::Default; use fmt; @@ -566,7 +566,7 @@ impl<'a> IntoMaybeOwned<'a> for MaybeOwned<'a> { fn into_maybe_owned(self) -> MaybeOwned<'a> { self } } -impl<'a> Eq for MaybeOwned<'a> { +impl<'a> PartialEq for MaybeOwned<'a> { #[inline] fn eq(&self, other: &MaybeOwned) -> bool { self.as_slice() == other.as_slice() @@ -575,7 +575,7 @@ impl<'a> Eq for MaybeOwned<'a> { impl<'a> TotalEq for MaybeOwned<'a> {} -impl<'a> Ord for MaybeOwned<'a> { +impl<'a> PartialOrd for MaybeOwned<'a> { #[inline] fn lt(&self, other: &MaybeOwned) -> bool { self.as_slice().lt(&other.as_slice()) diff --git a/src/libstd/string.rs b/src/libstd/string.rs index 0edbaf99210..29d3c718682 100644 --- a/src/libstd/string.rs +++ b/src/libstd/string.rs @@ -30,7 +30,7 @@ use str; use vec::Vec; /// A growable string stored as a UTF-8 encoded buffer. -#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd)] +#[deriving(Clone, PartialEq, PartialOrd, TotalEq, TotalOrd)] pub struct String { vec: Vec<u8>, } diff --git a/src/libstd/sync/deque.rs b/src/libstd/sync/deque.rs index 46d6129ded8..ea4c12f4401 100644 --- a/src/libstd/sync/deque.rs +++ b/src/libstd/sync/deque.rs @@ -102,7 +102,7 @@ pub struct Stealer<T> { } /// When stealing some data, this is an enumeration of the possible outcomes. -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] pub enum Stolen<T> { /// The deque was empty at the time of stealing Empty, diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index 81f6c7c7c9b..3cac6fadb94 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -12,7 +12,7 @@ use RawVec = raw::Vec; use clone::Clone; -use cmp::{Ord, Eq, Ordering, TotalEq, TotalOrd, max}; +use cmp::{PartialOrd, PartialEq, Ordering, TotalEq, TotalOrd, max}; use container::{Container, Mutable}; use default::Default; use fmt; @@ -374,14 +374,14 @@ impl<T> Extendable<T> for Vec<T> { } } -impl<T: Eq> Eq for Vec<T> { +impl<T: PartialEq> PartialEq for Vec<T> { #[inline] fn eq(&self, other: &Vec<T>) -> bool { self.as_slice() == other.as_slice() } } -impl<T: Ord> Ord for Vec<T> { +impl<T: PartialOrd> PartialOrd for Vec<T> { #[inline] fn lt(&self, other: &Vec<T>) -> bool { self.as_slice() < other.as_slice() @@ -1288,7 +1288,7 @@ impl<T> Mutable for Vec<T> { } } -impl<T:Eq> Vec<T> { +impl<T:PartialEq> Vec<T> { /// Return true if a vector contains an element with the given value /// /// # Example @@ -1315,7 +1315,7 @@ impl<T:Eq> Vec<T> { pub fn dedup(&mut self) { unsafe { // Although we have a mutable reference to `self`, we cannot make - // *arbitrary* changes. The `Eq` comparisons could fail, so we + // *arbitrary* changes. The `PartialEq` comparisons could fail, so we // must ensure that the vector is in a valid state at all time. // // The way that we handle this is by using swaps; we iterate diff --git a/src/libsync/mutex.rs b/src/libsync/mutex.rs index 54c3a9c77f8..ee7fa525e79 100644 --- a/src/libsync/mutex.rs +++ b/src/libsync/mutex.rs @@ -97,7 +97,7 @@ pub struct Mutex { lock: StaticMutex, } -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] enum Flavor { Unlocked, TryLockAcquisition, diff --git a/src/libsyntax/abi.rs b/src/libsyntax/abi.rs index 089cd772bb4..e61c1c24c2f 100644 --- a/src/libsyntax/abi.rs +++ b/src/libsyntax/abi.rs @@ -10,10 +10,10 @@ use std::fmt; -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum Os { OsWin32, OsMacos, OsLinux, OsAndroid, OsFreebsd, } -#[deriving(Eq, TotalEq, Hash, Encodable, Decodable, Clone)] +#[deriving(PartialEq, TotalEq, Hash, Encodable, Decodable, Clone)] pub enum Abi { // NB: This ordering MUST match the AbiDatas array below. // (This is ensured by the test indices_are_correct().) @@ -33,7 +33,7 @@ pub enum Abi { } #[allow(non_camel_case_types)] -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum Architecture { // NB. You cannot change the ordering of these // constants without adjusting IntelBits below. diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 656ae80e12d..5eb9308e443 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -39,7 +39,7 @@ pub fn P<T: 'static>(value: T) -> P<T> { // table) and a SyntaxContext to track renaming and // macro expansion per Flatt et al., "Macros // That Work Together" -#[deriving(Clone, Hash, Ord, TotalEq, TotalOrd, Show)] +#[deriving(Clone, Hash, PartialOrd, TotalEq, TotalOrd, Show)] pub struct Ident { pub name: Name, pub ctxt: SyntaxContext @@ -50,7 +50,7 @@ impl Ident { pub fn new(name: Name) -> Ident { Ident {name: name, ctxt: EMPTY_CTXT}} } -impl Eq for Ident { +impl PartialEq for Ident { fn eq(&self, other: &Ident) -> bool { if self.ctxt == other.ctxt { self.name == other.name @@ -114,7 +114,7 @@ impl<D:Decoder<E>, E> Decodable<D, E> for Ident { /// Function name (not all functions have names) pub type FnIdent = Option<Ident>; -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct Lifetime { pub id: NodeId, pub span: Span, @@ -122,10 +122,10 @@ pub struct Lifetime { } // a "Path" is essentially Rust's notion of a name; -// for instance: std::cmp::Eq . It's represented +// for instance: std::cmp::PartialEq . It's represented // as a sequence of identifiers, along with a bunch // of supporting information. -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct Path { pub span: Span, /// A `::foo` path, is relative to the crate root rather than current @@ -137,7 +137,7 @@ pub struct Path { /// A segment of a path: an identifier, an optional lifetime, and a set of /// types. -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct PathSegment { /// The identifier portion of this path segment. pub identifier: Ident, @@ -151,7 +151,7 @@ pub type CrateNum = u32; pub type NodeId = u32; -#[deriving(Clone, TotalEq, TotalOrd, Ord, Eq, Encodable, Decodable, Hash, Show)] +#[deriving(Clone, TotalEq, TotalOrd, PartialOrd, PartialEq, Encodable, Decodable, Hash, Show)] pub struct DefId { pub krate: CrateNum, pub node: NodeId, @@ -171,14 +171,14 @@ pub static DUMMY_NODE_ID: NodeId = -1; // typeck::collect::compute_bounds matches these against // the "special" built-in traits (see middle::lang_items) and // detects Copy, Send and Share. -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum TyParamBound { TraitTyParamBound(TraitRef), StaticRegionTyParamBound, OtherRegionTyParamBound(Span) // FIXME -- just here until work for #5723 lands } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct TyParam { pub ident: Ident, pub id: NodeId, @@ -188,7 +188,7 @@ pub struct TyParam { pub span: Span } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct Generics { pub lifetimes: Vec<Lifetime>, pub ty_params: OwnedSlice<TyParam>, @@ -206,13 +206,13 @@ impl Generics { } } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum MethodProvenance { FromTrait(DefId), FromImpl(DefId), } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum Def { DefFn(DefId, FnStyle), DefStaticMethod(/* method */ DefId, MethodProvenance, FnStyle), @@ -249,7 +249,7 @@ pub enum Def { DefMethod(DefId /* method */, Option<DefId> /* trait */), } -#[deriving(Clone, Eq, TotalEq, Hash, Encodable, Decodable, Show)] +#[deriving(Clone, PartialEq, TotalEq, Hash, Encodable, Decodable, Show)] pub enum DefRegion { DefStaticRegion, DefEarlyBoundRegion(/* index */ uint, /* lifetime decl */ NodeId), @@ -261,7 +261,7 @@ pub enum DefRegion { // used to drive conditional compilation pub type CrateConfig = Vec<@MetaItem> ; -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct Crate { pub module: Mod, pub attrs: Vec<Attribute>, @@ -279,7 +279,7 @@ pub enum MetaItem_ { } // can't be derived because the MetaList requires an unordered comparison -impl Eq for MetaItem_ { +impl PartialEq for MetaItem_ { fn eq(&self, other: &MetaItem_) -> bool { match *self { MetaWord(ref ns) => match *other { @@ -303,7 +303,7 @@ impl Eq for MetaItem_ { } } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct Block { pub view_items: Vec<ViewItem>, pub stmts: Vec<@Stmt>, @@ -313,26 +313,26 @@ pub struct Block { pub span: Span, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct Pat { pub id: NodeId, pub node: Pat_, pub span: Span, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct FieldPat { pub ident: Ident, pub pat: @Pat, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum BindingMode { BindByRef(Mutability), BindByValue(Mutability), } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum Pat_ { PatWild, PatWildMulti, @@ -358,20 +358,20 @@ pub enum Pat_ { PatMac(Mac), } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash, Show)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash, Show)] pub enum Mutability { MutMutable, MutImmutable, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum ExprVstore { ExprVstoreUniq, // ~[1,2,3,4] ExprVstoreSlice, // &[1,2,3,4] ExprVstoreMutSlice, // &mut [1,2,3,4] } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum BinOp { BiAdd, BiSub, @@ -393,7 +393,7 @@ pub enum BinOp { BiGt, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum UnOp { UnBox, UnUniq, @@ -404,7 +404,7 @@ pub enum UnOp { pub type Stmt = Spanned<Stmt_>; -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum Stmt_ { // could be an item or a local (let) binding: StmtDecl(@Decl, NodeId), @@ -421,7 +421,7 @@ pub enum Stmt_ { /// Where a local declaration came from: either a true `let ... = /// ...;`, or one desugared from the pattern of a for loop. -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum LocalSource { LocalLet, LocalFor, @@ -430,7 +430,7 @@ pub enum LocalSource { // FIXME (pending discussion of #1697, #2178...): local should really be // a refinement on pat. /// Local represents a `let` statement, e.g., `let <pat>:<ty> = <expr>;` -#[deriving(Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct Local { pub ty: P<Ty>, pub pat: @Pat, @@ -442,7 +442,7 @@ pub struct Local { pub type Decl = Spanned<Decl_>; -#[deriving(Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum Decl_ { // a local (let) binding: DeclLocal(@Local), @@ -450,7 +450,7 @@ pub enum Decl_ { DeclItem(@Item), } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct Arm { pub attrs: Vec<Attribute>, pub pats: Vec<@Pat>, @@ -458,7 +458,7 @@ pub struct Arm { pub body: @Expr, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct Field { pub ident: SpannedIdent, pub expr: @Expr, @@ -467,26 +467,26 @@ pub struct Field { pub type SpannedIdent = Spanned<Ident>; -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum BlockCheckMode { DefaultBlock, UnsafeBlock(UnsafeSource), } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum UnsafeSource { CompilerGenerated, UserProvided, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct Expr { pub id: NodeId, pub node: Expr_, pub span: Span, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum Expr_ { ExprVstore(@Expr, ExprVstore), // First expr is the place; second expr is the value. @@ -555,7 +555,7 @@ pub enum Expr_ { // else knows what to do with them, so you'll probably get a syntax // error. // -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] #[doc="For macro invocations; parsing is delegated to the macro"] pub enum TokenTree { // a single token @@ -631,7 +631,7 @@ pub enum TokenTree { // pub type Matcher = Spanned<Matcher_>; -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum Matcher_ { // match one token MatchTok(::parse::token::Token), @@ -648,12 +648,12 @@ pub type Mac = Spanned<Mac_>; // is being invoked, and the vector of token-trees contains the source // of the macro invocation. // There's only one flavor, now, so this could presumably be simplified. -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum Mac_ { MacInvocTT(Path, Vec<TokenTree> , SyntaxContext), // new macro-invocation } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum StrStyle { CookedStr, RawStr(uint) @@ -661,7 +661,7 @@ pub enum StrStyle { pub type Lit = Spanned<Lit_>; -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum Lit_ { LitStr(InternedString, StrStyle), LitBinary(Rc<Vec<u8> >), @@ -677,20 +677,20 @@ pub enum Lit_ { // NB: If you change this, you'll probably want to change the corresponding // type structure in middle/ty.rs as well. -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct MutTy { pub ty: P<Ty>, pub mutbl: Mutability, } -#[deriving(Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct TypeField { pub ident: Ident, pub mt: MutTy, pub span: Span, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct TypeMethod { pub ident: Ident, pub attrs: Vec<Attribute>, @@ -706,13 +706,13 @@ pub struct TypeMethod { // A trait method is either required (meaning it doesn't have an // implementation, just a signature) or provided (meaning it has a default // implementation). -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum TraitMethod { Required(TypeMethod), Provided(@Method), } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum IntTy { TyI, TyI8, @@ -728,7 +728,7 @@ impl fmt::Show for IntTy { } } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum UintTy { TyU, TyU8, @@ -744,7 +744,7 @@ impl fmt::Show for UintTy { } } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum FloatTy { TyF32, TyF64, @@ -757,8 +757,8 @@ impl fmt::Show for FloatTy { } } -// NB Eq method appears below. -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +// NB PartialEq method appears below. +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct Ty { pub id: NodeId, pub node: Ty_, @@ -766,7 +766,7 @@ pub struct Ty { } // Not represented directly in the AST, referred to by name through a ty_path. -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum PrimTy { TyInt(IntTy), TyUint(UintTy), @@ -776,7 +776,7 @@ pub enum PrimTy { TyChar } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum Onceness { Once, Many @@ -791,7 +791,7 @@ impl fmt::Show for Onceness { } } -#[deriving(Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct ClosureTy { pub lifetimes: Vec<Lifetime>, pub fn_style: FnStyle, @@ -804,7 +804,7 @@ pub struct ClosureTy { pub bounds: Option<OwnedSlice<TyParamBound>>, } -#[deriving(Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct BareFnTy { pub fn_style: FnStyle, pub abi: Abi, @@ -812,7 +812,7 @@ pub struct BareFnTy { pub decl: P<FnDecl> } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum Ty_ { TyNil, TyBot, /* bottom type */ @@ -833,13 +833,13 @@ pub enum Ty_ { TyInfer, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum AsmDialect { AsmAtt, AsmIntel } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct InlineAsm { pub asm: InternedString, pub asm_str_style: StrStyle, @@ -851,7 +851,7 @@ pub struct InlineAsm { pub dialect: AsmDialect } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct Arg { pub ty: P<Ty>, pub pat: @Pat, @@ -878,7 +878,7 @@ impl Arg { } } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct FnDecl { pub inputs: Vec<Arg>, pub output: P<Ty>, @@ -886,7 +886,7 @@ pub struct FnDecl { pub variadic: bool } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum FnStyle { UnsafeFn, // declared with "unsafe fn" NormalFn, // declared with "fn" @@ -901,14 +901,14 @@ impl fmt::Show for FnStyle { } } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum RetStyle { NoReturn, // functions with return type _|_ that always // raise an error or exit (i.e. never return to the caller) Return, // everything else } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum ExplicitSelf_ { SelfStatic, // no self SelfValue, // `self` @@ -918,7 +918,7 @@ pub enum ExplicitSelf_ { pub type ExplicitSelf = Spanned<ExplicitSelf_>; -#[deriving(Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct Method { pub ident: Ident, pub attrs: Vec<Attribute>, @@ -932,7 +932,7 @@ pub struct Method { pub vis: Visibility, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct Mod { /// A span from the first token past `{` to the last token until `}`. /// For `mod foo;`, the inner span ranges from the first token @@ -942,31 +942,31 @@ pub struct Mod { pub items: Vec<@Item>, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct ForeignMod { pub abi: Abi, pub view_items: Vec<ViewItem>, pub items: Vec<@ForeignItem>, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct VariantArg { pub ty: P<Ty>, pub id: NodeId, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum VariantKind { TupleVariantKind(Vec<VariantArg>), StructVariantKind(@StructDef), } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct EnumDef { pub variants: Vec<P<Variant>>, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct Variant_ { pub name: Ident, pub attrs: Vec<Attribute>, @@ -978,7 +978,7 @@ pub struct Variant_ { pub type Variant = Spanned<Variant_>; -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct PathListIdent_ { pub name: Ident, pub id: NodeId, @@ -988,7 +988,7 @@ pub type PathListIdent = Spanned<PathListIdent_>; pub type ViewPath = Spanned<ViewPath_>; -#[deriving(Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum ViewPath_ { // quux = foo::bar::baz @@ -1005,7 +1005,7 @@ pub enum ViewPath_ { ViewPathList(Path, Vec<PathListIdent> , NodeId) } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct ViewItem { pub node: ViewItem_, pub attrs: Vec<Attribute>, @@ -1013,7 +1013,7 @@ pub struct ViewItem { pub span: Span, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum ViewItem_ { // ident: name used to refer to this crate in the code // optional (InternedString,StrStyle): if present, this is a location @@ -1029,17 +1029,17 @@ pub type Attribute = Spanned<Attribute_>; // Distinguishes between Attributes that decorate items and Attributes that // are contained as statements within items. These two cases need to be // distinguished for pretty-printing. -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum AttrStyle { AttrOuter, AttrInner, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct AttrId(pub uint); // doc-comments are promoted to attributes that have is_sugared_doc = true -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct Attribute_ { pub id: AttrId, pub style: AttrStyle, @@ -1054,13 +1054,13 @@ pub struct Attribute_ { If this impl is an ItemImpl, the impl_id is redundant (it could be the same as the impl's node id). */ -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct TraitRef { pub path: Path, pub ref_id: NodeId, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum Visibility { Public, Inherited, @@ -1075,13 +1075,13 @@ impl Visibility { } } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum Sized { DynSize, StaticSize, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct StructField_ { pub kind: StructFieldKind, pub id: NodeId, @@ -1091,7 +1091,7 @@ pub struct StructField_ { pub type StructField = Spanned<StructField_>; -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum StructFieldKind { NamedField(Ident, Visibility), UnnamedField(Visibility), // element of a tuple-like struct @@ -1106,7 +1106,7 @@ impl StructFieldKind { } } -#[deriving(Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct StructDef { pub fields: Vec<StructField>, /* fields, not including ctor */ /* ID of the constructor. This is only used for tuple- or enum-like @@ -1120,7 +1120,7 @@ pub struct StructDef { FIXME (#3300): Should allow items to be anonymous. Right now we just use dummy names for anon items. */ -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct Item { pub ident: Ident, pub attrs: Vec<Attribute>, @@ -1130,7 +1130,7 @@ pub struct Item { pub span: Span, } -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum Item_ { ItemStatic(P<Ty>, Mutability, @Expr), ItemFn(P<FnDecl>, FnStyle, Abi, Generics, P<Block>), @@ -1148,7 +1148,7 @@ pub enum Item_ { ItemMac(Mac), } -#[deriving(Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct ForeignItem { pub ident: Ident, pub attrs: Vec<Attribute>, @@ -1158,7 +1158,7 @@ pub struct ForeignItem { pub vis: Visibility, } -#[deriving(Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum ForeignItem_ { ForeignItemFn(P<FnDecl>, Generics), ForeignItemStatic(P<Ty>, /* is_mutbl */ bool), @@ -1167,7 +1167,7 @@ pub enum ForeignItem_ { // The data we save and restore about an inlined item or method. This is not // part of the AST that we parse from a file, but it becomes part of the tree // that we trans. -#[deriving(Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)] pub enum InlinedItem { IIItem(@Item), IIMethod(DefId /* impl id */, bool /* is provided */, @Method), diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index 6b81f8ee2e1..9a7b4f7d949 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -24,7 +24,7 @@ use std::iter; use std::slice; use std::string::String; -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub enum PathElem { PathMod(Name), PathName(Name) diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index 527e851ae35..4a38835f86b 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -307,7 +307,7 @@ pub fn find_crateid(attrs: &[Attribute]) -> Option<CrateId> { } } -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum InlineAttr { InlineNone, InlineHint, @@ -396,7 +396,7 @@ pub struct Stability { } /// The available stability levels. -#[deriving(Eq,Ord,Clone,Show)] +#[deriving(PartialEq,PartialOrd,Clone,Show)] pub enum StabilityLevel { Deprecated, Experimental, @@ -522,7 +522,7 @@ fn int_type_of_word(s: &str) -> Option<IntType> { } } -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] pub enum ReprAttr { ReprAny, ReprInt(Span, IntType), @@ -539,7 +539,7 @@ impl ReprAttr { } } -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] pub enum IntType { SignedInt(ast::IntTy), UnsignedInt(ast::UintTy) diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 1ef7576335b..59bf9608a09 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -33,13 +33,13 @@ pub trait Pos { /// A byte offset. Keep this small (currently 32-bits), as AST contains /// a lot of them. -#[deriving(Clone, Eq, TotalEq, Hash, Ord, Show)] +#[deriving(Clone, PartialEq, TotalEq, Hash, PartialOrd, Show)] pub struct BytePos(pub u32); /// A character offset. Because of multibyte utf8 characters, a byte offset /// is not equivalent to a character offset. The CodeMap will convert BytePos /// values to CharPos values as necessary. -#[deriving(Eq, Hash, Ord, Show)] +#[deriving(PartialEq, Hash, PartialOrd, Show)] pub struct CharPos(pub uint); // FIXME: Lots of boilerplate in these impls, but so far my attempts to fix @@ -96,13 +96,13 @@ pub struct Span { pub static DUMMY_SP: Span = Span { lo: BytePos(0), hi: BytePos(0), expn_info: None }; -#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)] pub struct Spanned<T> { pub node: T, pub span: Span, } -impl Eq for Span { +impl PartialEq for Span { fn eq(&self, other: &Span) -> bool { return (*self).lo == (*other).lo && (*self).hi == (*other).hi; } diff --git a/src/libsyntax/crateid.rs b/src/libsyntax/crateid.rs index 329ddcad461..3f74598d2e5 100644 --- a/src/libsyntax/crateid.rs +++ b/src/libsyntax/crateid.rs @@ -20,7 +20,7 @@ use std::fmt; use std::from_str::FromStr; -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub struct CrateId { /// A path which represents the codes origin. By convention this is the /// URL, without `http://` or `https://` prefix, to the crate's repository diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index 49da91e1053..ee06efbec13 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -194,7 +194,7 @@ pub fn mk_handler(e: Box<Emitter:Send>) -> Handler { } } -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum Level { Bug, Fatal, diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs index 0f4af144ead..e2290129dc8 100644 --- a/src/libsyntax/ext/deriving/generic/mod.rs +++ b/src/libsyntax/ext/deriving/generic/mod.rs @@ -24,7 +24,7 @@ Supported features (fairly exhaustive): current trait as a bound. (This includes separate type parameters and lifetimes for methods.) - Additional bounds on the type parameters, e.g. the `Ord` instance - requires an explicit `Eq` bound at the + requires an explicit `PartialEq` bound at the moment. (`TraitDef.additional_bounds`) Unsupported: FIXME #6257: calling methods on reference fields, @@ -82,13 +82,13 @@ variants, it is represented as a count of 0. # Examples -The following simplified `Eq` is used for in-code examples: +The following simplified `PartialEq` is used for in-code examples: ```rust -trait Eq { +trait PartialEq { fn eq(&self, other: &Self); } -impl Eq for int { +impl PartialEq for int { fn eq(&self, other: &int) -> bool { *self == *other } @@ -96,7 +96,7 @@ impl Eq for int { ``` Some examples of the values of `SubstructureFields` follow, using the -above `Eq`, `A`, `B` and `C`. +above `PartialEq`, `A`, `B` and `C`. ## Structs @@ -645,11 +645,11 @@ impl<'a> MethodDef<'a> { /** ~~~ - #[deriving(Eq)] + #[deriving(PartialEq)] struct A { x: int, y: int } // equivalent to: - impl Eq for A { + impl PartialEq for A { fn eq(&self, __arg_1: &A) -> bool { match *self { A {x: ref __self_0_0, y: ref __self_0_1} => { @@ -750,7 +750,7 @@ impl<'a> MethodDef<'a> { /** ~~~ - #[deriving(Eq)] + #[deriving(PartialEq)] enum A { A1 A2(int) @@ -758,7 +758,7 @@ impl<'a> MethodDef<'a> { // is equivalent to (with const_nonmatching == false) - impl Eq for A { + impl PartialEq for A { fn eq(&self, __arg_1: &A) { match *self { A1 => match *__arg_1 { @@ -994,7 +994,7 @@ impl<'a> MethodDef<'a> { } } -#[deriving(Eq)] // dogfooding! +#[deriving(PartialEq)] // dogfooding! enum StructType { Unknown, Record, Tuple } diff --git a/src/libsyntax/ext/deriving/mod.rs b/src/libsyntax/ext/deriving/mod.rs index e5da7330a6c..3735248e9e2 100644 --- a/src/libsyntax/ext/deriving/mod.rs +++ b/src/libsyntax/ext/deriving/mod.rs @@ -77,10 +77,9 @@ pub fn expand_meta_deriving(cx: &mut ExtCtxt, "Encodable" => expand!(encodable::expand_deriving_encodable), "Decodable" => expand!(decodable::expand_deriving_decodable), - // NOTE this needs treatment after a stage0 snap - "PartialEq" | "Eq" => expand!(eq::expand_deriving_eq), + "PartialEq" => expand!(eq::expand_deriving_eq), "TotalEq" => expand!(totaleq::expand_deriving_totaleq), - "PartialOrd" | "Ord" => expand!(ord::expand_deriving_ord), + "PartialOrd" => expand!(ord::expand_deriving_ord), "TotalOrd" => expand!(totalord::expand_deriving_totalord), "Rand" => expand!(rand::expand_deriving_rand), diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs index c05fc8ce6d9..0d228a1146d 100644 --- a/src/libsyntax/ext/format.rs +++ b/src/libsyntax/ext/format.rs @@ -21,7 +21,7 @@ use rsparse = parse; use parse = fmt_macros; use collections::{HashMap, HashSet}; -#[deriving(Eq)] +#[deriving(PartialEq)] enum ArgumentType { Known(String), Unsigned, diff --git a/src/libsyntax/ext/mtwt.rs b/src/libsyntax/ext/mtwt.rs index fdaa3b5630a..12e314781ae 100644 --- a/src/libsyntax/ext/mtwt.rs +++ b/src/libsyntax/ext/mtwt.rs @@ -37,7 +37,7 @@ pub struct SCTable { rename_memo: RefCell<HashMap<(SyntaxContext,Ident,Name),SyntaxContext>>, } -#[deriving(Eq, Encodable, Decodable, Hash)] +#[deriving(PartialEq, Encodable, Decodable, Hash)] pub enum SyntaxContext_ { EmptyCtxt, Mark (Mrk,SyntaxContext), @@ -294,7 +294,7 @@ mod tests { // because of the SCTable, I now need a tidy way of // creating syntax objects. Sigh. - #[deriving(Clone, Eq, Show)] + #[deriving(Clone, PartialEq, Show)] enum TestSC { M(Mrk), R(Ident,Name) diff --git a/src/libsyntax/owned_slice.rs b/src/libsyntax/owned_slice.rs index f93c3576943..c04c10e0d72 100644 --- a/src/libsyntax/owned_slice.rs +++ b/src/libsyntax/owned_slice.rs @@ -113,7 +113,7 @@ impl<S: Writer, T: Hash<S>> Hash<S> for OwnedSlice<T> { } } -impl<T: Eq> Eq for OwnedSlice<T> { +impl<T: PartialEq> PartialEq for OwnedSlice<T> { fn eq(&self, other: &OwnedSlice<T>) -> bool { self.as_slice() == other.as_slice() } diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs index cc08cb429f5..622ed6b9801 100644 --- a/src/libsyntax/parse/comments.rs +++ b/src/libsyntax/parse/comments.rs @@ -22,7 +22,7 @@ use std::str; use std::string::String; use std::uint; -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub enum CommentStyle { Isolated, // No code on either side of each line of the comment Trailing, // Code exists to the left of the comment diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs index fb67a76b85b..f5386b43d51 100644 --- a/src/libsyntax/parse/lexer.rs +++ b/src/libsyntax/parse/lexer.rs @@ -34,7 +34,7 @@ pub trait Reader { fn peek(&self) -> TokenAndSpan; } -#[deriving(Clone, Eq, Show)] +#[deriving(Clone, PartialEq, Show)] pub struct TokenAndSpan { pub tok: token::Token, pub sp: Span, diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index f045a7fe120..b7121c6b32c 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -23,7 +23,7 @@ use parse::parser; use parse::token; /// The specific types of unsupported syntax -#[deriving(Eq, TotalEq, Hash)] +#[deriving(PartialEq, TotalEq, Hash)] pub enum ObsoleteSyntax { ObsoleteOwnedType, ObsoleteOwnedExpr, diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 00c07ce59f9..6c09fa20510 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -82,7 +82,7 @@ use std::rc::Rc; use std::string::String; #[allow(non_camel_case_types)] -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum restriction { UNRESTRICTED, RESTRICT_STMT_EXPR, @@ -94,7 +94,7 @@ type ItemInfo = (Ident, Item_, Option<Vec<Attribute> >); /// How to parse a path. There are four different kinds of paths, all of which /// are parsed somewhat differently. -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum PathParsingMode { /// A path with no type parameters; e.g. `foo::bar::Baz` NoTypesAllowed, diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 2c090d053a3..192adfe7829 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -24,7 +24,7 @@ use std::rc::Rc; use std::string::String; #[allow(non_camel_case_types)] -#[deriving(Clone, Encodable, Decodable, Eq, TotalEq, Hash, Show)] +#[deriving(Clone, Encodable, Decodable, PartialEq, TotalEq, Hash, Show)] pub enum BinOp { PLUS, MINUS, @@ -39,7 +39,7 @@ pub enum BinOp { } #[allow(non_camel_case_types)] -#[deriving(Clone, Encodable, Decodable, Eq, TotalEq, Hash, Show)] +#[deriving(Clone, Encodable, Decodable, PartialEq, TotalEq, Hash, Show)] pub enum Token { /* Expression-operator symbols. */ EQ, @@ -102,7 +102,7 @@ pub enum Token { EOF, } -#[deriving(Clone, Encodable, Decodable, Eq, TotalEq, Hash)] +#[deriving(Clone, Encodable, Decodable, PartialEq, TotalEq, Hash)] /// For interpolation during macro expansion. pub enum Nonterminal { NtItem(@ast::Item), @@ -552,7 +552,7 @@ pub fn get_ident_interner() -> Rc<IdentInterner> { /// destroyed. In particular, they must not access string contents. This can /// be fixed in the future by just leaking all strings until task death /// somehow. -#[deriving(Clone, Eq, Hash, Ord, TotalEq, TotalOrd)] +#[deriving(Clone, PartialEq, Hash, PartialOrd, TotalEq, TotalOrd)] pub struct InternedString { string: RcStr, } diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index 669378b313a..ec9ca655064 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -64,7 +64,7 @@ use std::io; use std::string::String; -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub enum Breaks { Consistent, Inconsistent, diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs index 72600921ba9..d2361810a24 100644 --- a/src/libsyntax/util/interner.rs +++ b/src/libsyntax/util/interner.rs @@ -90,7 +90,7 @@ impl<T: TotalEq + Hash + Clone + 'static> Interner<T> { } } -#[deriving(Clone, Eq, Hash, Ord)] +#[deriving(Clone, PartialEq, Hash, PartialOrd)] pub struct RcStr { string: Rc<String>, } diff --git a/src/libterm/terminfo/parm.rs b/src/libterm/terminfo/parm.rs index 3da8d7672f5..6795b10f4c7 100644 --- a/src/libterm/terminfo/parm.rs +++ b/src/libterm/terminfo/parm.rs @@ -13,7 +13,7 @@ use std::char; use std::mem::replace; -#[deriving(Eq)] +#[deriving(PartialEq)] enum States { Nothing, Percent, @@ -30,7 +30,7 @@ enum States { SeekIfEndPercent(int) } -#[deriving(Eq)] +#[deriving(PartialEq)] enum FormatState { FormatStateFlags, FormatStateWidth, @@ -434,7 +434,7 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables) Ok(output) } -#[deriving(Eq)] +#[deriving(PartialEq)] struct Flags { width: uint, precision: uint, diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index 1de7f90c806..bc69dc442dc 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -83,7 +83,7 @@ pub mod stats; // colons. This way if some test runner wants to arrange the tests // hierarchically it may. -#[deriving(Clone, Eq, TotalEq, Hash)] +#[deriving(Clone, PartialEq, TotalEq, Hash)] pub enum TestName { StaticTestName(&'static str), DynTestName(String) @@ -183,7 +183,7 @@ pub struct Bencher { // The definition of a single test. A test runner will run a list of // these. -#[deriving(Clone, Show, Eq, TotalEq, Hash)] +#[deriving(Clone, Show, PartialEq, TotalEq, Hash)] pub struct TestDesc { pub name: TestName, pub ignore: bool, @@ -196,7 +196,7 @@ pub struct TestDescAndFn { pub testfn: TestFn, } -#[deriving(Clone, Encodable, Decodable, Eq, Show)] +#[deriving(Clone, Encodable, Decodable, PartialEq, Show)] pub struct Metric { value: f64, noise: f64 @@ -208,7 +208,7 @@ impl Metric { } } -#[deriving(Eq)] +#[deriving(PartialEq)] pub struct MetricMap(TreeMap<String,Metric>); impl Clone for MetricMap { @@ -219,7 +219,7 @@ impl Clone for MetricMap { } /// Analysis of a single change in metric -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] pub enum MetricChange { LikelyNoise, MetricAdded, @@ -444,13 +444,13 @@ pub fn opt_shard(maybestr: Option<String>) -> Option<(uint,uint)> { } -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub struct BenchSamples { ns_iter_summ: stats::Summary<f64>, mb_s: uint, } -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub enum TestResult { TrOk, TrFailed, diff --git a/src/libtest/stats.rs b/src/libtest/stats.rs index 77b1eae0a56..16a96d9f606 100644 --- a/src/libtest/stats.rs +++ b/src/libtest/stats.rs @@ -126,7 +126,7 @@ pub trait Stats <T: FloatMath + FromPrimitive>{ } /// Extracted collection of all the summary statistics of a sample set. -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] #[allow(missing_doc)] pub struct Summary<T> { pub sum: T, diff --git a/src/libtime/lib.rs b/src/libtime/lib.rs index e9b20c0117d..91e608360bc 100644 --- a/src/libtime/lib.rs +++ b/src/libtime/lib.rs @@ -74,7 +74,7 @@ mod imp { } /// A record specifying a time value in seconds and nanoseconds. -#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Encodable, Decodable, Show)] +#[deriving(Clone, PartialEq, TotalEq, PartialOrd, TotalOrd, Encodable, Decodable, Show)] pub struct Timespec { pub sec: i64, pub nsec: i32 } /* * Timespec assumes that pre-epoch Timespecs have negative sec and positive @@ -202,7 +202,7 @@ pub fn tzset() { /// Holds a calendar date and time broken down into its components (year, month, day, and so on), /// also called a broken-down time value. -#[deriving(Clone, Eq, Show)] +#[deriving(Clone, PartialEq, Show)] pub struct Tm { /// Seconds after the minute – [0, 60] pub tm_sec: i32, diff --git a/src/liburl/lib.rs b/src/liburl/lib.rs index b049246ca18..2120bc10dab 100644 --- a/src/liburl/lib.rs +++ b/src/liburl/lib.rs @@ -22,7 +22,7 @@ extern crate collections; use collections::HashMap; -use std::cmp::Eq; +use std::cmp::PartialEq; use std::fmt; use std::from_str::FromStr; use std::hash::Hash; @@ -48,7 +48,7 @@ use std::uint; /// fragment: Some("quz".to_string()) }; /// // https://username@example.com:8080/foo/bar?baz=qux#quz /// ``` -#[deriving(Clone, Eq, TotalEq)] +#[deriving(Clone, PartialEq, TotalEq)] pub struct Url { /// The scheme part of a URL, such as `https` in the above example. pub scheme: String, @@ -68,7 +68,7 @@ pub struct Url { pub fragment: Option<String> } -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] pub struct Path { /// The path component of a URL, for example `/foo/bar`. pub path: String, @@ -81,7 +81,7 @@ pub struct Path { } /// An optional subcomponent of a URI authority component. -#[deriving(Clone, Eq, TotalEq)] +#[deriving(Clone, PartialEq, TotalEq)] pub struct UserInfo { /// The user name. pub user: String, @@ -515,7 +515,7 @@ pub fn get_scheme(rawurl: &str) -> Result<(String, String), String> { return Err("url: Scheme must be terminated with a colon.".to_string()); } -#[deriving(Clone, Eq)] +#[deriving(Clone, PartialEq)] enum Input { Digit, // all digits Hex, // digits and letters a-f diff --git a/src/libuuid/lib.rs b/src/libuuid/lib.rs index c157d83ced1..a5b28b73023 100644 --- a/src/libuuid/lib.rs +++ b/src/libuuid/lib.rs @@ -87,7 +87,7 @@ use serialize::{Encoder, Encodable, Decoder, Decodable}; pub type UuidBytes = [u8, ..16]; /// The version of the UUID, denoting the generating algorithm -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum UuidVersion { /// Version 1: MAC address Version1Mac = 1, @@ -102,7 +102,7 @@ pub enum UuidVersion { } /// The reserved variants of UUIDs -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum UuidVariant { /// Reserved by the NCS for backward compatibility VariantNCS, @@ -481,7 +481,7 @@ impl fmt::Show for Uuid { /// Test two UUIDs for equality /// /// UUIDs are equal only when they are byte-for-byte identical -impl Eq for Uuid { +impl PartialEq for Uuid { fn eq(&self, other: &Uuid) -> bool { self.bytes == other.bytes } diff --git a/src/libworkcache/lib.rs b/src/libworkcache/lib.rs index 064979fa277..7c3fc18dd04 100644 --- a/src/libworkcache/lib.rs +++ b/src/libworkcache/lib.rs @@ -99,7 +99,7 @@ use std::str; use std::io; use std::io::{File, MemWriter}; -#[deriving(Clone, Eq, Encodable, Decodable, Ord, TotalOrd, TotalEq)] +#[deriving(Clone, PartialEq, Encodable, Decodable, PartialOrd, TotalOrd, TotalEq)] struct WorkKey { kind: String, name: String @@ -116,10 +116,10 @@ impl WorkKey { // FIXME #8883: The key should be a WorkKey and not a String. // This is working around some JSON weirdness. -#[deriving(Clone, Eq, Encodable, Decodable)] +#[deriving(Clone, PartialEq, Encodable, Decodable)] struct WorkMap(TreeMap<String, KindMap>); -#[deriving(Clone, Eq, Encodable, Decodable)] +#[deriving(Clone, PartialEq, Encodable, Decodable)] struct KindMap(TreeMap<String, String>); impl WorkMap { diff --git a/src/test/auxiliary/crateresolve5-1.rs b/src/test/auxiliary/crateresolve5-1.rs index 7cfb1dda4b9..de48981ed3e 100644 --- a/src/test/auxiliary/crateresolve5-1.rs +++ b/src/test/auxiliary/crateresolve5-1.rs @@ -26,7 +26,7 @@ pub fn nominal() -> e { e_val } pub fn nominal_eq(_e1: e, _e2: e) -> bool { true } -impl Eq for e { +impl PartialEq for e { fn eq(&self, other: &e) -> bool { nominal_eq(*self, *other) } fn ne(&self, other: &e) -> bool { !nominal_eq(*self, *other) } } diff --git a/src/test/auxiliary/crateresolve5-2.rs b/src/test/auxiliary/crateresolve5-2.rs index 566c4385f3c..f8727605c3d 100644 --- a/src/test/auxiliary/crateresolve5-2.rs +++ b/src/test/auxiliary/crateresolve5-2.rs @@ -21,7 +21,7 @@ pub enum e { e_val } -impl Eq for e { +impl PartialEq for e { fn eq(&self, other: &e) -> bool { !nominal_neq(*self, *other) } fn ne(&self, other: &e) -> bool { nominal_neq(*self, *other) } } diff --git a/src/test/auxiliary/impl_privacy_xc_2.rs b/src/test/auxiliary/impl_privacy_xc_2.rs index 9b9379e19e5..4d4b1bcc4cb 100644 --- a/src/test/auxiliary/impl_privacy_xc_2.rs +++ b/src/test/auxiliary/impl_privacy_xc_2.rs @@ -16,7 +16,7 @@ pub struct Fish { mod unexported { use super::Fish; - impl Eq for Fish { + impl PartialEq for Fish { fn eq(&self, _: &Fish) -> bool { true } fn ne(&self, _: &Fish) -> bool { false } } diff --git a/src/test/auxiliary/overloaded_autoderef_xc.rs b/src/test/auxiliary/overloaded_autoderef_xc.rs index 850050fe3a5..dbb978a0b4e 100644 --- a/src/test/auxiliary/overloaded_autoderef_xc.rs +++ b/src/test/auxiliary/overloaded_autoderef_xc.rs @@ -31,7 +31,7 @@ impl<T, H: Helper<T>> Deref<T> for DerefWithHelper<H, T> { } // Test cross-crate autoderef + vtable. -pub fn check<T: Eq>(x: T, y: T) -> bool { +pub fn check<T: PartialEq>(x: T, y: T) -> bool { let d: DerefWithHelper<Option<T>, T> = DerefWithHelper { helper: Some(x) }; d.eq(&y) } diff --git a/src/test/auxiliary/trait_inheritance_overloading_xc.rs b/src/test/auxiliary/trait_inheritance_overloading_xc.rs index 4b7a72f5043..95bdecd7760 100644 --- a/src/test/auxiliary/trait_inheritance_overloading_xc.rs +++ b/src/test/auxiliary/trait_inheritance_overloading_xc.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::cmp::Eq; +use std::cmp::PartialEq; -pub trait MyNum : Add<Self,Self> + Sub<Self,Self> + Mul<Self,Self> + Eq { +pub trait MyNum : Add<Self,Self> + Sub<Self,Self> + Mul<Self,Self> + PartialEq { } #[deriving(Show)] @@ -30,7 +30,7 @@ impl Mul<MyInt, MyInt> for MyInt { fn mul(&self, other: &MyInt) -> MyInt { mi(self.val * other.val) } } -impl Eq for MyInt { +impl PartialEq for MyInt { fn eq(&self, other: &MyInt) -> bool { self.val == other.val } fn ne(&self, other: &MyInt) -> bool { !self.eq(other) } diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs index 4b561def720..45cd93188b2 100644 --- a/src/test/bench/shootout-k-nucleotide.rs +++ b/src/test/bench/shootout-k-nucleotide.rs @@ -30,7 +30,7 @@ static OCCURRENCES: [&'static str, ..5] = [ // Code implementation -#[deriving(Eq, Ord, TotalOrd, TotalEq)] +#[deriving(PartialEq, PartialOrd, TotalOrd, TotalEq)] struct Code(u64); impl Code { diff --git a/src/test/compile-fail/deriving-no-inner-impl-error-message.rs b/src/test/compile-fail/deriving-no-inner-impl-error-message.rs index 604aa0dd06a..58593869d74 100644 --- a/src/test/compile-fail/deriving-no-inner-impl-error-message.rs +++ b/src/test/compile-fail/deriving-no-inner-impl-error-message.rs @@ -10,7 +10,7 @@ struct NoCloneOrEq; -#[deriving(Eq)] +#[deriving(PartialEq)] struct E { x: NoCloneOrEq //~ ERROR does not implement any method in scope named `eq` //~^ ERROR does not implement any method in scope named `ne` diff --git a/src/test/compile-fail/deriving-span-Clone-enum-struct-variant.rs b/src/test/compile-fail/deriving-span-Clone-enum-struct-variant.rs index 7babb8ea1b9..58a9c72b8b1 100644 --- a/src/test/compile-fail/deriving-span-Clone-enum-struct-variant.rs +++ b/src/test/compile-fail/deriving-span-Clone-enum-struct-variant.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-Clone-enum.rs b/src/test/compile-fail/deriving-span-Clone-enum.rs index 65404f155f1..cf8345dbe7b 100644 --- a/src/test/compile-fail/deriving-span-Clone-enum.rs +++ b/src/test/compile-fail/deriving-span-Clone-enum.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-Clone-struct.rs b/src/test/compile-fail/deriving-span-Clone-struct.rs index 0ca429e07e9..cd53f5a1e8f 100644 --- a/src/test/compile-fail/deriving-span-Clone-struct.rs +++ b/src/test/compile-fail/deriving-span-Clone-struct.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-Clone-tuple-struct.rs b/src/test/compile-fail/deriving-span-Clone-tuple-struct.rs index e78e59baf1b..95798af49b2 100644 --- a/src/test/compile-fail/deriving-span-Clone-tuple-struct.rs +++ b/src/test/compile-fail/deriving-span-Clone-tuple-struct.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-Default-struct.rs b/src/test/compile-fail/deriving-span-Default-struct.rs index 95132d9a5c7..90d567bfd5d 100644 --- a/src/test/compile-fail/deriving-span-Default-struct.rs +++ b/src/test/compile-fail/deriving-span-Default-struct.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-Default-tuple-struct.rs b/src/test/compile-fail/deriving-span-Default-tuple-struct.rs index 670f6e8ea52..cf0d9fb7443 100644 --- a/src/test/compile-fail/deriving-span-Default-tuple-struct.rs +++ b/src/test/compile-fail/deriving-span-Default-tuple-struct.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-Hash-enum-struct-variant.rs b/src/test/compile-fail/deriving-span-Hash-enum-struct-variant.rs index 745ef501021..49b4840ff8e 100644 --- a/src/test/compile-fail/deriving-span-Hash-enum-struct-variant.rs +++ b/src/test/compile-fail/deriving-span-Hash-enum-struct-variant.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-Hash-enum.rs b/src/test/compile-fail/deriving-span-Hash-enum.rs index 3cd867d1186..653dabfbc13 100644 --- a/src/test/compile-fail/deriving-span-Hash-enum.rs +++ b/src/test/compile-fail/deriving-span-Hash-enum.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-Hash-struct.rs b/src/test/compile-fail/deriving-span-Hash-struct.rs index e26bdd8d089..46234f6e724 100644 --- a/src/test/compile-fail/deriving-span-Hash-struct.rs +++ b/src/test/compile-fail/deriving-span-Hash-struct.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-Hash-tuple-struct.rs b/src/test/compile-fail/deriving-span-Hash-tuple-struct.rs index 7554db6dae3..5dbf4a0376a 100644 --- a/src/test/compile-fail/deriving-span-Hash-tuple-struct.rs +++ b/src/test/compile-fail/deriving-span-Hash-tuple-struct.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-Eq-enum-struct-variant.rs b/src/test/compile-fail/deriving-span-PartialEq-enum-struct-variant.rs index 9e23493e37f..566585aa065 100644 --- a/src/test/compile-fail/deriving-span-Eq-enum-struct-variant.rs +++ b/src/test/compile-fail/deriving-span-PartialEq-enum-struct-variant.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; @@ -16,7 +16,7 @@ extern crate rand; struct Error; -#[deriving(Eq)] +#[deriving(PartialEq)] enum Enum { A { x: Error //~ ERROR diff --git a/src/test/compile-fail/deriving-span-Eq-enum.rs b/src/test/compile-fail/deriving-span-PartialEq-enum.rs index d4962c8a76b..8a9771a0509 100644 --- a/src/test/compile-fail/deriving-span-Eq-enum.rs +++ b/src/test/compile-fail/deriving-span-PartialEq-enum.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; @@ -16,7 +16,7 @@ extern crate rand; struct Error; -#[deriving(Eq)] +#[deriving(PartialEq)] enum Enum { A( Error //~ ERROR diff --git a/src/test/compile-fail/deriving-span-Eq-struct.rs b/src/test/compile-fail/deriving-span-PartialEq-struct.rs index 39c9c23e8f5..de39e9bacd5 100644 --- a/src/test/compile-fail/deriving-span-Eq-struct.rs +++ b/src/test/compile-fail/deriving-span-PartialEq-struct.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; @@ -16,7 +16,7 @@ extern crate rand; struct Error; -#[deriving(Eq)] +#[deriving(PartialEq)] struct Struct { x: Error //~ ERROR //~^ ERROR diff --git a/src/test/compile-fail/deriving-span-Eq-tuple-struct.rs b/src/test/compile-fail/deriving-span-PartialEq-tuple-struct.rs index a9a9a1b3071..101461e39b7 100644 --- a/src/test/compile-fail/deriving-span-Eq-tuple-struct.rs +++ b/src/test/compile-fail/deriving-span-PartialEq-tuple-struct.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; @@ -16,7 +16,7 @@ extern crate rand; struct Error; -#[deriving(Eq)] +#[deriving(PartialEq)] struct Struct( Error //~ ERROR //~^ ERROR diff --git a/src/test/compile-fail/deriving-span-Ord-enum-struct-variant.rs b/src/test/compile-fail/deriving-span-PartialOrd-enum-struct-variant.rs index 900fa0dcb6c..077286eef49 100644 --- a/src/test/compile-fail/deriving-span-Ord-enum-struct-variant.rs +++ b/src/test/compile-fail/deriving-span-PartialOrd-enum-struct-variant.rs @@ -8,15 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; -#[deriving(Eq)] +#[deriving(PartialEq)] struct Error; -#[deriving(Eq, Ord)] +#[deriving(PartialOrd,PartialEq)] enum Enum { A { x: Error //~ ERROR diff --git a/src/test/compile-fail/deriving-span-Ord-enum.rs b/src/test/compile-fail/deriving-span-PartialOrd-enum.rs index feb97dee79b..8fd4ba6053e 100644 --- a/src/test/compile-fail/deriving-span-Ord-enum.rs +++ b/src/test/compile-fail/deriving-span-PartialOrd-enum.rs @@ -8,15 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; -#[deriving(Eq)] +#[deriving(PartialEq)] struct Error; -#[deriving(Eq, Ord)] +#[deriving(PartialOrd,PartialEq)] enum Enum { A( Error //~ ERROR diff --git a/src/test/compile-fail/deriving-span-Ord-struct.rs b/src/test/compile-fail/deriving-span-PartialOrd-struct.rs index c0396b0822e..3a198a542e4 100644 --- a/src/test/compile-fail/deriving-span-Ord-struct.rs +++ b/src/test/compile-fail/deriving-span-PartialOrd-struct.rs @@ -8,15 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; -#[deriving(Eq)] +#[deriving(PartialEq)] struct Error; -#[deriving(Eq, Ord)] +#[deriving(PartialOrd,PartialEq)] struct Struct { x: Error //~ ERROR //~^ ERROR diff --git a/src/test/compile-fail/deriving-span-Ord-tuple-struct.rs b/src/test/compile-fail/deriving-span-PartialOrd-tuple-struct.rs index 26610d7e1fa..2de3c18425b 100644 --- a/src/test/compile-fail/deriving-span-Ord-tuple-struct.rs +++ b/src/test/compile-fail/deriving-span-PartialOrd-tuple-struct.rs @@ -8,15 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; -#[deriving(Eq)] +#[deriving(PartialEq)] struct Error; -#[deriving(Eq, Ord)] +#[deriving(PartialOrd,PartialEq)] struct Struct( Error //~ ERROR //~^ ERROR diff --git a/src/test/compile-fail/deriving-span-Rand-enum-struct-variant.rs b/src/test/compile-fail/deriving-span-Rand-enum-struct-variant.rs index e1b112bb023..79c38dcb4cc 100644 --- a/src/test/compile-fail/deriving-span-Rand-enum-struct-variant.rs +++ b/src/test/compile-fail/deriving-span-Rand-enum-struct-variant.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-Rand-enum.rs b/src/test/compile-fail/deriving-span-Rand-enum.rs index 746a2aac88e..1e153a772c7 100644 --- a/src/test/compile-fail/deriving-span-Rand-enum.rs +++ b/src/test/compile-fail/deriving-span-Rand-enum.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-Rand-struct.rs b/src/test/compile-fail/deriving-span-Rand-struct.rs index 397b2adfcc8..2c223918773 100644 --- a/src/test/compile-fail/deriving-span-Rand-struct.rs +++ b/src/test/compile-fail/deriving-span-Rand-struct.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-Rand-tuple-struct.rs b/src/test/compile-fail/deriving-span-Rand-tuple-struct.rs index be6b7dcbb8f..5d5a1372c13 100644 --- a/src/test/compile-fail/deriving-span-Rand-tuple-struct.rs +++ b/src/test/compile-fail/deriving-span-Rand-tuple-struct.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-Show-enum-struct-variant.rs b/src/test/compile-fail/deriving-span-Show-enum-struct-variant.rs index d50f1c69278..93f53dc73f7 100644 --- a/src/test/compile-fail/deriving-span-Show-enum-struct-variant.rs +++ b/src/test/compile-fail/deriving-span-Show-enum-struct-variant.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-Show-enum.rs b/src/test/compile-fail/deriving-span-Show-enum.rs index ada1abe8fbb..e61a62c2f6d 100644 --- a/src/test/compile-fail/deriving-span-Show-enum.rs +++ b/src/test/compile-fail/deriving-span-Show-enum.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-Show-struct.rs b/src/test/compile-fail/deriving-span-Show-struct.rs index 8d74af6ad0b..3a48b3334b7 100644 --- a/src/test/compile-fail/deriving-span-Show-struct.rs +++ b/src/test/compile-fail/deriving-span-Show-struct.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-Show-tuple-struct.rs b/src/test/compile-fail/deriving-span-Show-tuple-struct.rs index 6e421ca58f5..54806f322b3 100644 --- a/src/test/compile-fail/deriving-span-Show-tuple-struct.rs +++ b/src/test/compile-fail/deriving-span-Show-tuple-struct.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-TotalEq-enum-struct-variant.rs b/src/test/compile-fail/deriving-span-TotalEq-enum-struct-variant.rs index 8880d04ce41..07fc3d5c5d9 100644 --- a/src/test/compile-fail/deriving-span-TotalEq-enum-struct-variant.rs +++ b/src/test/compile-fail/deriving-span-TotalEq-enum-struct-variant.rs @@ -8,15 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; -#[deriving(Eq)] +#[deriving(PartialEq)] struct Error; -#[deriving(Eq, TotalEq)] +#[deriving(TotalEq,PartialEq)] enum Enum { A { x: Error //~ ERROR diff --git a/src/test/compile-fail/deriving-span-TotalEq-enum.rs b/src/test/compile-fail/deriving-span-TotalEq-enum.rs index d0d8ef62f1e..e25ebaf7f1b 100644 --- a/src/test/compile-fail/deriving-span-TotalEq-enum.rs +++ b/src/test/compile-fail/deriving-span-TotalEq-enum.rs @@ -8,15 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; -#[deriving(Eq)] +#[deriving(PartialEq)] struct Error; -#[deriving(Eq, TotalEq)] +#[deriving(TotalEq,PartialEq)] enum Enum { A( Error //~ ERROR diff --git a/src/test/compile-fail/deriving-span-TotalEq-struct.rs b/src/test/compile-fail/deriving-span-TotalEq-struct.rs index 53d7e0cbe3a..b9b50e5d60b 100644 --- a/src/test/compile-fail/deriving-span-TotalEq-struct.rs +++ b/src/test/compile-fail/deriving-span-TotalEq-struct.rs @@ -8,15 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; -#[deriving(Eq)] +#[deriving(PartialEq)] struct Error; -#[deriving(Eq, TotalEq)] +#[deriving(TotalEq,PartialEq)] struct Struct { x: Error //~ ERROR } diff --git a/src/test/compile-fail/deriving-span-TotalEq-tuple-struct.rs b/src/test/compile-fail/deriving-span-TotalEq-tuple-struct.rs index 538ffdcd770..b6123df4506 100644 --- a/src/test/compile-fail/deriving-span-TotalEq-tuple-struct.rs +++ b/src/test/compile-fail/deriving-span-TotalEq-tuple-struct.rs @@ -8,15 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; -#[deriving(Eq)] +#[deriving(PartialEq)] struct Error; -#[deriving(Eq, TotalEq)] +#[deriving(TotalEq,PartialEq)] struct Struct( Error //~ ERROR ); diff --git a/src/test/compile-fail/deriving-span-TotalOrd-enum-struct-variant.rs b/src/test/compile-fail/deriving-span-TotalOrd-enum-struct-variant.rs index d0adb542fc5..a8116a817a8 100644 --- a/src/test/compile-fail/deriving-span-TotalOrd-enum-struct-variant.rs +++ b/src/test/compile-fail/deriving-span-TotalOrd-enum-struct-variant.rs @@ -8,15 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; -#[deriving(Eq, Ord, TotalEq)] +#[deriving(TotalEq,PartialOrd,PartialEq)] struct Error; -#[deriving(Eq, Ord, TotalOrd,TotalEq)] +#[deriving(TotalOrd,TotalEq,PartialOrd,PartialEq)] enum Enum { A { x: Error //~ ERROR diff --git a/src/test/compile-fail/deriving-span-TotalOrd-enum.rs b/src/test/compile-fail/deriving-span-TotalOrd-enum.rs index 0fc204f6101..0e1dc003fbb 100644 --- a/src/test/compile-fail/deriving-span-TotalOrd-enum.rs +++ b/src/test/compile-fail/deriving-span-TotalOrd-enum.rs @@ -8,15 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; -#[deriving(Eq, Ord, TotalEq)] +#[deriving(TotalEq,PartialOrd,PartialEq)] struct Error; -#[deriving(Eq, Ord, TotalOrd,TotalEq)] +#[deriving(TotalOrd,TotalEq,PartialOrd,PartialEq)] enum Enum { A( Error //~ ERROR diff --git a/src/test/compile-fail/deriving-span-TotalOrd-struct.rs b/src/test/compile-fail/deriving-span-TotalOrd-struct.rs index 69cf5d2d8ef..af6f09c4a2c 100644 --- a/src/test/compile-fail/deriving-span-TotalOrd-struct.rs +++ b/src/test/compile-fail/deriving-span-TotalOrd-struct.rs @@ -8,15 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; -#[deriving(Eq, Ord, TotalEq)] +#[deriving(TotalEq,PartialOrd,PartialEq)] struct Error; -#[deriving(Eq, Ord, TotalOrd,TotalEq)] +#[deriving(TotalOrd,TotalEq,PartialOrd,PartialEq)] struct Struct { x: Error //~ ERROR } diff --git a/src/test/compile-fail/deriving-span-TotalOrd-tuple-struct.rs b/src/test/compile-fail/deriving-span-TotalOrd-tuple-struct.rs index 230e5b7ed99..b58dc56a261 100644 --- a/src/test/compile-fail/deriving-span-TotalOrd-tuple-struct.rs +++ b/src/test/compile-fail/deriving-span-TotalOrd-tuple-struct.rs @@ -8,15 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; -#[deriving(Eq, Ord, TotalEq)] +#[deriving(TotalEq,PartialOrd,PartialEq)] struct Error; -#[deriving(Eq, Ord, TotalOrd,TotalEq)] +#[deriving(TotalOrd,TotalEq,PartialOrd,PartialEq)] struct Struct( Error //~ ERROR ); diff --git a/src/test/compile-fail/deriving-span-Zero-struct.rs b/src/test/compile-fail/deriving-span-Zero-struct.rs index f32db20ef3f..ee3a82f7f6d 100644 --- a/src/test/compile-fail/deriving-span-Zero-struct.rs +++ b/src/test/compile-fail/deriving-span-Zero-struct.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/deriving-span-Zero-tuple-struct.rs b/src/test/compile-fail/deriving-span-Zero-tuple-struct.rs index 66488b0ac66..21dc0cabdc8 100644 --- a/src/test/compile-fail/deriving-span-Zero-tuple-struct.rs +++ b/src/test/compile-fail/deriving-span-Zero-tuple-struct.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py' +// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py' #![feature(struct_variant)] extern crate rand; diff --git a/src/test/compile-fail/issue-3344.rs b/src/test/compile-fail/issue-3344.rs index e79a5871e70..d6fe83a7703 100644 --- a/src/test/compile-fail/issue-3344.rs +++ b/src/test/compile-fail/issue-3344.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[deriving(Eq)] +#[deriving(PartialEq)] struct thing(uint); -impl Ord for thing { //~ ERROR not all trait methods implemented, missing: `lt` +impl PartialOrd for thing { //~ ERROR not all trait methods implemented, missing: `lt` fn le(&self, other: &thing) -> bool { true } fn ge(&self, other: &thing) -> bool { true } } diff --git a/src/test/compile-fail/issue-3953.rs b/src/test/compile-fail/issue-3953.rs index cfb10d39201..4484a004251 100644 --- a/src/test/compile-fail/issue-3953.rs +++ b/src/test/compile-fail/issue-3953.rs @@ -8,23 +8,25 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::cmp::Eq; +// ignore-tidy-linelength -trait Hahaha: Eq + Eq + Eq + Eq + Eq + //~ ERROR duplicate supertrait - Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + - Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + - Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + - Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + - Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + - Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + - Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + Eq + - Eq {} +use std::cmp::PartialEq; + +trait Hahaha: PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + //~ ERROR duplicate supertrait + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + PartialEq + + PartialEq {} struct Lol(int); impl Hahaha for Lol { } -impl Eq for Lol { +impl PartialEq for Lol { fn eq(&self, other: &Lol) -> bool { **self != **other } fn ne(&self, other: &Lol) -> bool { **self == **other } } diff --git a/src/test/compile-fail/lint-unused-imports.rs b/src/test/compile-fail/lint-unused-imports.rs index 3a4844301d6..cb05c283334 100644 --- a/src/test/compile-fail/lint-unused-imports.rs +++ b/src/test/compile-fail/lint-unused-imports.rs @@ -51,7 +51,7 @@ mod foo { mod bar { // Don't ignore on 'pub use' because we're not sure if it's used or not - pub use std::cmp::Eq; + pub use std::cmp::PartialEq; pub mod c { use foo::Point; @@ -61,7 +61,7 @@ mod bar { #[allow(unused_imports)] mod foo { - use std::cmp::Eq; + use std::cmp::PartialEq; } } diff --git a/src/test/run-make/rustdoc-hidden-line/foo.rs b/src/test/run-make/rustdoc-hidden-line/foo.rs index 8128ba05885..26546cef0f0 100644 --- a/src/test/run-make/rustdoc-hidden-line/foo.rs +++ b/src/test/run-make/rustdoc-hidden-line/foo.rs @@ -16,10 +16,10 @@ /// ```rust /// mod to_make_deriving_work { // FIXME #4913 /// -/// # #[deriving(Eq)] // invisible +/// # #[deriving(PartialEq)] // invisible /// # struct Foo; // invisible /// -/// #[deriving(Eq)] // Bar +/// #[deriving(PartialEq)] // Bar /// struct Bar(Foo); /// /// fn test() { diff --git a/src/test/run-pass-fulldeps/macro-crate.rs b/src/test/run-pass-fulldeps/macro-crate.rs index 0c086ae99f7..3c620c5e572 100644 --- a/src/test/run-pass-fulldeps/macro-crate.rs +++ b/src/test/run-pass-fulldeps/macro-crate.rs @@ -17,7 +17,7 @@ extern crate macro_crate_test; #[into_foo] -#[deriving(Eq, Clone, Show)] +#[deriving(PartialEq, Clone, Show)] fn foo() -> AFakeTypeThatHadBetterGoAway {} pub fn main() { @@ -28,4 +28,4 @@ pub fn main() { test(None::<Foo>); } -fn test<T: Eq+Clone>(_: Option<T>) {} +fn test<T: PartialEq+Clone>(_: Option<T>) {} diff --git a/src/test/run-pass/assert-eq-macro-success.rs b/src/test/run-pass/assert-eq-macro-success.rs index 4adf10636e6..34f7bf6f0e7 100644 --- a/src/test/run-pass/assert-eq-macro-success.rs +++ b/src/test/run-pass/assert-eq-macro-success.rs @@ -10,7 +10,7 @@ #![feature(managed_boxes)] -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct Point { x : int } pub fn main() { diff --git a/src/test/run-pass/binops.rs b/src/test/run-pass/binops.rs index 69705996fad..3ac3ac2b4f1 100644 --- a/src/test/run-pass/binops.rs +++ b/src/test/run-pass/binops.rs @@ -65,7 +65,7 @@ fn test_ptr() { } } -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct p { x: int, y: int, diff --git a/src/test/run-pass/builtin-superkinds-capabilities-xc.rs b/src/test/run-pass/builtin-superkinds-capabilities-xc.rs index f52993f8559..d52da212400 100644 --- a/src/test/run-pass/builtin-superkinds-capabilities-xc.rs +++ b/src/test/run-pass/builtin-superkinds-capabilities-xc.rs @@ -17,7 +17,7 @@ extern crate trait_superkinds_in_metadata; use trait_superkinds_in_metadata::{RequiresRequiresShareAndSend, RequiresShare}; -#[deriving(Eq)] +#[deriving(PartialEq)] struct X<T>(T); impl <T: Share> RequiresShare for X<T> { } diff --git a/src/test/run-pass/class-impl-very-parameterized-trait.rs b/src/test/run-pass/class-impl-very-parameterized-trait.rs index 285566570b1..865984844c0 100644 --- a/src/test/run-pass/class-impl-very-parameterized-trait.rs +++ b/src/test/run-pass/class-impl-very-parameterized-trait.rs @@ -14,7 +14,7 @@ use std::cmp; #[deriving(Show)] enum cat_type { tuxedo, tabby, tortoiseshell } -impl cmp::Eq for cat_type { +impl cmp::PartialEq for cat_type { fn eq(&self, other: &cat_type) -> bool { ((*self) as uint) == ((*other) as uint) } diff --git a/src/test/run-pass/cmp-default.rs b/src/test/run-pass/cmp-default.rs index 2ab6a70839f..7805a2bb49e 100644 --- a/src/test/run-pass/cmp-default.rs +++ b/src/test/run-pass/cmp-default.rs @@ -8,11 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// Test default methods in Ord and Eq +// Test default methods in PartialOrd and PartialEq // struct Fool(bool); -impl Eq for Fool { +impl PartialEq for Fool { fn eq(&self, other: &Fool) -> bool { let Fool(this) = *self; let Fool(other) = *other; @@ -22,7 +22,7 @@ impl Eq for Fool { struct Int(int); -impl Eq for Int { +impl PartialEq for Int { fn eq(&self, other: &Int) -> bool { let Int(this) = *self; let Int(other) = *other; @@ -30,7 +30,7 @@ impl Eq for Int { } } -impl Ord for Int { +impl PartialOrd for Int { fn lt(&self, other: &Int) -> bool { let Int(this) = *self; let Int(other) = *other; @@ -40,7 +40,7 @@ impl Ord for Int { struct RevInt(int); -impl Eq for RevInt { +impl PartialEq for RevInt { fn eq(&self, other: &RevInt) -> bool { let RevInt(this) = *self; let RevInt(other) = *other; @@ -48,7 +48,7 @@ impl Eq for RevInt { } } -impl Ord for RevInt { +impl PartialOrd for RevInt { fn lt(&self, other: &RevInt) -> bool { let RevInt(this) = *self; let RevInt(other) = *other; diff --git a/src/test/run-pass/coerce-to-closure-and-proc.rs b/src/test/run-pass/coerce-to-closure-and-proc.rs index 075709b1c36..15870b627b2 100644 --- a/src/test/run-pass/coerce-to-closure-and-proc.rs +++ b/src/test/run-pass/coerce-to-closure-and-proc.rs @@ -12,10 +12,10 @@ fn id<T>(x: T) -> T { x } -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct Foo<T>(T); -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] enum Bar<T> { Bar(T) } diff --git a/src/test/run-pass/coherence-impl-in-fn.rs b/src/test/run-pass/coherence-impl-in-fn.rs index 707a7bf4076..51cd62677ca 100644 --- a/src/test/run-pass/coherence-impl-in-fn.rs +++ b/src/test/run-pass/coherence-impl-in-fn.rs @@ -10,7 +10,7 @@ pub fn main() { enum x { foo } - impl ::std::cmp::Eq for x { + impl ::std::cmp::PartialEq for x { fn eq(&self, other: &x) -> bool { (*self) as int == (*other) as int } diff --git a/src/test/run-pass/const-struct.rs b/src/test/run-pass/const-struct.rs index 4508295b1cc..0a83d007a06 100644 --- a/src/test/run-pass/const-struct.rs +++ b/src/test/run-pass/const-struct.rs @@ -13,7 +13,7 @@ use std::cmp; #[deriving(Show)] struct foo { a: int, b: int, c: int } -impl cmp::Eq for foo { +impl cmp::PartialEq for foo { fn eq(&self, other: &foo) -> bool { (*self).a == (*other).a && (*self).b == (*other).b && diff --git a/src/test/run-pass/deriving-cmp-generic-enum.rs b/src/test/run-pass/deriving-cmp-generic-enum.rs index 5d41e275cd3..e280da10990 100644 --- a/src/test/run-pass/deriving-cmp-generic-enum.rs +++ b/src/test/run-pass/deriving-cmp-generic-enum.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[deriving(Eq, TotalEq, Ord, TotalOrd)] +#[deriving(PartialEq, TotalEq, PartialOrd, TotalOrd)] enum E<T> { E0, E1(T), @@ -22,7 +22,7 @@ pub fn main() { let e21 = E2(1, 1); let e22 = E2(1, 2); - // in order for both Ord and TotalOrd + // in order for both PartialOrd and TotalOrd let es = [e0, e11, e12, e21, e22]; for (i, e1) in es.iter().enumerate() { @@ -35,11 +35,11 @@ pub fn main() { let gt = i > j; let ge = i >= j; - // Eq + // PartialEq assert_eq!(*e1 == *e2, eq); assert_eq!(*e1 != *e2, !eq); - // Ord + // PartialOrd assert_eq!(*e1 < *e2, lt); assert_eq!(*e1 > *e2, gt); diff --git a/src/test/run-pass/deriving-cmp-generic-struct-enum.rs b/src/test/run-pass/deriving-cmp-generic-struct-enum.rs index 9dc5bcc0f02..a6040049a2f 100644 --- a/src/test/run-pass/deriving-cmp-generic-struct-enum.rs +++ b/src/test/run-pass/deriving-cmp-generic-struct-enum.rs @@ -10,7 +10,7 @@ #![feature(struct_variant)] -#[deriving(Eq, TotalEq, Ord, TotalOrd)] +#[deriving(PartialEq, TotalEq, PartialOrd, TotalOrd)] enum ES<T> { ES1 { x: T }, ES2 { x: T, y: T } @@ -20,7 +20,7 @@ enum ES<T> { pub fn main() { let (es11, es12, es21, es22) = (ES1 {x: 1}, ES1 {x: 2}, ES2 {x: 1, y: 1}, ES2 {x: 1, y: 2}); - // in order for both Ord and TotalOrd + // in order for both PartialOrd and TotalOrd let ess = [es11, es12, es21, es22]; for (i, es1) in ess.iter().enumerate() { @@ -31,11 +31,11 @@ pub fn main() { let (lt, le) = (i < j, i <= j); let (gt, ge) = (i > j, i >= j); - // Eq + // PartialEq assert_eq!(*es1 == *es2, eq); assert_eq!(*es1 != *es2, !eq); - // Ord + // PartialOrd assert_eq!(*es1 < *es2, lt); assert_eq!(*es1 > *es2, gt); diff --git a/src/test/run-pass/deriving-cmp-generic-struct.rs b/src/test/run-pass/deriving-cmp-generic-struct.rs index 4f62d1fa631..36ec0e834ba 100644 --- a/src/test/run-pass/deriving-cmp-generic-struct.rs +++ b/src/test/run-pass/deriving-cmp-generic-struct.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[deriving(Eq, TotalEq, Ord, TotalOrd)] +#[deriving(PartialEq, TotalEq, PartialOrd, TotalOrd)] struct S<T> { x: T, y: T @@ -18,7 +18,7 @@ pub fn main() { let s1 = S {x: 1, y: 1}; let s2 = S {x: 1, y: 2}; - // in order for both Ord and TotalOrd + // in order for both PartialOrd and TotalOrd let ss = [s1, s2]; for (i, s1) in ss.iter().enumerate() { @@ -31,11 +31,11 @@ pub fn main() { let gt = i > j; let ge = i >= j; - // Eq + // PartialEq assert_eq!(*s1 == *s2, eq); assert_eq!(*s1 != *s2, !eq); - // Ord + // PartialOrd assert_eq!(*s1 < *s2, lt); assert_eq!(*s1 > *s2, gt); diff --git a/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs b/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs index b8ba4c64616..b67da8940ff 100644 --- a/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs +++ b/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[deriving(Eq, TotalEq, Ord, TotalOrd)] +#[deriving(PartialEq, TotalEq, PartialOrd, TotalOrd)] struct TS<T>(T,T); @@ -16,7 +16,7 @@ pub fn main() { let ts1 = TS(1, 1); let ts2 = TS(1, 2); - // in order for both Ord and TotalOrd + // in order for both PartialOrd and TotalOrd let tss = [ts1, ts2]; for (i, ts1) in tss.iter().enumerate() { @@ -29,11 +29,11 @@ pub fn main() { let gt = i > j; let ge = i >= j; - // Eq + // PartialEq assert_eq!(*ts1 == *ts2, eq); assert_eq!(*ts1 != *ts2, !eq); - // Ord + // PartialOrd assert_eq!(*ts1 < *ts2, lt); assert_eq!(*ts1 > *ts2, gt); diff --git a/src/test/run-pass/deriving-cmp-shortcircuit.rs b/src/test/run-pass/deriving-cmp-shortcircuit.rs index 03e6d04d87f..45beda9684d 100644 --- a/src/test/run-pass/deriving-cmp-shortcircuit.rs +++ b/src/test/run-pass/deriving-cmp-shortcircuit.rs @@ -13,11 +13,11 @@ // second element, so this passes iff the instances shortcircuit. pub struct FailCmp; -impl Eq for FailCmp { +impl PartialEq for FailCmp { fn eq(&self, _: &FailCmp) -> bool { fail!("eq") } } -impl Ord for FailCmp { +impl PartialOrd for FailCmp { fn lt(&self, _: &FailCmp) -> bool { fail!("lt") } } @@ -27,7 +27,7 @@ impl TotalOrd for FailCmp { fn cmp(&self, _: &FailCmp) -> Ordering { fail!("cmp") } } -#[deriving(Eq,Ord,TotalEq,TotalOrd)] +#[deriving(PartialEq,PartialOrd,TotalEq,TotalOrd)] struct ShortCircuit { x: int, y: FailCmp diff --git a/src/test/run-pass/deriving-enum-single-variant.rs b/src/test/run-pass/deriving-enum-single-variant.rs index 075a9431b19..fc03763a3b7 100644 --- a/src/test/run-pass/deriving-enum-single-variant.rs +++ b/src/test/run-pass/deriving-enum-single-variant.rs @@ -10,7 +10,7 @@ type task_id = int; -#[deriving(Eq)] +#[deriving(PartialEq)] pub enum Task { TaskHandle(task_id) } diff --git a/src/test/run-pass/deriving-global.rs b/src/test/run-pass/deriving-global.rs index cbf6a1c50df..1f9a5cab3b7 100644 --- a/src/test/run-pass/deriving-global.rs +++ b/src/test/run-pass/deriving-global.rs @@ -15,21 +15,21 @@ mod submod { // if any of these are implemented without global calls for any // function calls, then being in a submodule will (correctly) // cause errors about unrecognised module `std` (or `extra`) - #[deriving(Eq, Ord, TotalEq, TotalOrd, + #[deriving(PartialEq, PartialOrd, TotalEq, TotalOrd, Hash, Clone, Show, Rand, Encodable, Decodable)] enum A { A1(uint), A2(int) } - #[deriving(Eq, Ord, TotalEq, TotalOrd, + #[deriving(PartialEq, PartialOrd, TotalEq, TotalOrd, Hash, Clone, Show, Rand, Encodable, Decodable)] struct B { x: uint, y: int } - #[deriving(Eq, Ord, TotalEq, TotalOrd, + #[deriving(PartialEq, PartialOrd, TotalEq, TotalOrd, Hash, Clone, Show, Rand, diff --git a/src/test/run-pass/deriving-in-macro.rs b/src/test/run-pass/deriving-in-macro.rs index b4ff97912a1..218216e3a34 100644 --- a/src/test/run-pass/deriving-in-macro.rs +++ b/src/test/run-pass/deriving-in-macro.rs @@ -13,7 +13,7 @@ macro_rules! define_vec ( () => ( mod foo { - #[deriving(Eq)] + #[deriving(PartialEq)] pub struct bar; } ) diff --git a/src/test/run-pass/deriving-meta-multiple.rs b/src/test/run-pass/deriving-meta-multiple.rs index 1eb7631da04..61df7bf5088 100644 --- a/src/test/run-pass/deriving-meta-multiple.rs +++ b/src/test/run-pass/deriving-meta-multiple.rs @@ -11,7 +11,7 @@ use std::hash::hash; -#[deriving(Eq, Clone, Hash)] +#[deriving(PartialEq, Clone, Hash)] struct Foo { bar: uint, baz: int @@ -20,7 +20,7 @@ struct Foo { pub fn main() { let a = Foo {bar: 4, baz: -3}; - a == a; // check for Eq impl w/o testing its correctness + a == a; // check for PartialEq impl w/o testing its correctness a.clone(); // check for Clone impl w/o testing its correctness hash(&a); // check for Hash impl w/o testing its correctness } diff --git a/src/test/run-pass/deriving-meta.rs b/src/test/run-pass/deriving-meta.rs index 1eb7631da04..61df7bf5088 100644 --- a/src/test/run-pass/deriving-meta.rs +++ b/src/test/run-pass/deriving-meta.rs @@ -11,7 +11,7 @@ use std::hash::hash; -#[deriving(Eq, Clone, Hash)] +#[deriving(PartialEq, Clone, Hash)] struct Foo { bar: uint, baz: int @@ -20,7 +20,7 @@ struct Foo { pub fn main() { let a = Foo {bar: 4, baz: -3}; - a == a; // check for Eq impl w/o testing its correctness + a == a; // check for PartialEq impl w/o testing its correctness a.clone(); // check for Clone impl w/o testing its correctness hash(&a); // check for Hash impl w/o testing its correctness } diff --git a/src/test/run-pass/deriving-primitive.rs b/src/test/run-pass/deriving-primitive.rs index e90d7c803aa..22d40f30dc8 100644 --- a/src/test/run-pass/deriving-primitive.rs +++ b/src/test/run-pass/deriving-primitive.rs @@ -11,7 +11,7 @@ use std::num::FromPrimitive; use std::int; -#[deriving(Eq, FromPrimitive, Show)] +#[deriving(PartialEq, FromPrimitive, Show)] enum A { Foo = int::MAX, Bar = 1, diff --git a/src/test/run-pass/deriving-via-extension-c-enum.rs b/src/test/run-pass/deriving-via-extension-c-enum.rs index 8fbff8f8f31..3665a0a79fa 100644 --- a/src/test/run-pass/deriving-via-extension-c-enum.rs +++ b/src/test/run-pass/deriving-via-extension-c-enum.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] enum Foo { Bar, Baz, diff --git a/src/test/run-pass/deriving-via-extension-enum.rs b/src/test/run-pass/deriving-via-extension-enum.rs index 74d530b93ff..d34b17923c5 100644 --- a/src/test/run-pass/deriving-via-extension-enum.rs +++ b/src/test/run-pass/deriving-via-extension-enum.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] enum Foo { Bar(int, int), Baz(f64, f64) diff --git a/src/test/run-pass/deriving-via-extension-struct-empty.rs b/src/test/run-pass/deriving-via-extension-struct-empty.rs index f7c711e27d0..ab1a67f7e12 100644 --- a/src/test/run-pass/deriving-via-extension-struct-empty.rs +++ b/src/test/run-pass/deriving-via-extension-struct-empty.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct Foo; pub fn main() { diff --git a/src/test/run-pass/deriving-via-extension-struct-like-enum-variant.rs b/src/test/run-pass/deriving-via-extension-struct-like-enum-variant.rs index 3e22db301d3..b8cc6ccb69c 100644 --- a/src/test/run-pass/deriving-via-extension-struct-like-enum-variant.rs +++ b/src/test/run-pass/deriving-via-extension-struct-like-enum-variant.rs @@ -10,7 +10,7 @@ #![feature(struct_variant)] -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] enum S { X { x: int, y: int }, Y diff --git a/src/test/run-pass/deriving-via-extension-struct-tuple.rs b/src/test/run-pass/deriving-via-extension-struct-tuple.rs index edb0272dfee..8a6aa0fad93 100644 --- a/src/test/run-pass/deriving-via-extension-struct-tuple.rs +++ b/src/test/run-pass/deriving-via-extension-struct-tuple.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct Foo(int, int, String); pub fn main() { diff --git a/src/test/run-pass/deriving-via-extension-struct.rs b/src/test/run-pass/deriving-via-extension-struct.rs index db366231860..18d207d75d4 100644 --- a/src/test/run-pass/deriving-via-extension-struct.rs +++ b/src/test/run-pass/deriving-via-extension-struct.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct Foo { x: int, y: int, diff --git a/src/test/run-pass/deriving-via-extension-type-params.rs b/src/test/run-pass/deriving-via-extension-type-params.rs index 42915d8119d..1af39da5202 100644 --- a/src/test/run-pass/deriving-via-extension-type-params.rs +++ b/src/test/run-pass/deriving-via-extension-type-params.rs @@ -9,7 +9,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[deriving(Eq, Hash, Show)] +#[deriving(PartialEq, Hash, Show)] struct Foo<T> { x: int, y: T, diff --git a/src/test/run-pass/empty-tag.rs b/src/test/run-pass/empty-tag.rs index b79de737ce0..64571be3418 100644 --- a/src/test/run-pass/empty-tag.rs +++ b/src/test/run-pass/empty-tag.rs @@ -11,7 +11,7 @@ #[deriving(Show)] enum chan { chan_t, } -impl Eq for chan { +impl PartialEq for chan { fn eq(&self, other: &chan) -> bool { ((*self) as uint) == ((*other) as uint) } diff --git a/src/test/run-pass/export-unexported-dep.rs b/src/test/run-pass/export-unexported-dep.rs index 004761479f3..49709fa72c6 100644 --- a/src/test/run-pass/export-unexported-dep.rs +++ b/src/test/run-pass/export-unexported-dep.rs @@ -15,7 +15,7 @@ mod foo { // not exported enum t { t1, t2, } - impl Eq for t { + impl PartialEq for t { fn eq(&self, other: &t) -> bool { ((*self) as uint) == ((*other) as uint) } diff --git a/src/test/run-pass/expr-if-struct.rs b/src/test/run-pass/expr-if-struct.rs index 58e8a35fbfc..b0cc991f667 100644 --- a/src/test/run-pass/expr-if-struct.rs +++ b/src/test/run-pass/expr-if-struct.rs @@ -24,7 +24,7 @@ fn test_rec() { #[deriving(Show)] enum mood { happy, sad, } -impl Eq for mood { +impl PartialEq for mood { fn eq(&self, other: &mood) -> bool { ((*self) as uint) == ((*other) as uint) } diff --git a/src/test/run-pass/expr-match-struct.rs b/src/test/run-pass/expr-match-struct.rs index 93f0575b5a0..3d01c6653a7 100644 --- a/src/test/run-pass/expr-match-struct.rs +++ b/src/test/run-pass/expr-match-struct.rs @@ -23,7 +23,7 @@ fn test_rec() { #[deriving(Show)] enum mood { happy, sad, } -impl Eq for mood { +impl PartialEq for mood { fn eq(&self, other: &mood) -> bool { ((*self) as uint) == ((*other) as uint) } diff --git a/src/test/run-pass/extern-pass-TwoU16s.rs b/src/test/run-pass/extern-pass-TwoU16s.rs index 0eb7eabe747..aace680bea0 100644 --- a/src/test/run-pass/extern-pass-TwoU16s.rs +++ b/src/test/run-pass/extern-pass-TwoU16s.rs @@ -11,7 +11,7 @@ // Test a foreign function that accepts and returns a struct // by value. -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct TwoU16s { one: u16, two: u16 } diff --git a/src/test/run-pass/extern-pass-TwoU32s.rs b/src/test/run-pass/extern-pass-TwoU32s.rs index ea093f1daaa..fb2188fb6df 100644 --- a/src/test/run-pass/extern-pass-TwoU32s.rs +++ b/src/test/run-pass/extern-pass-TwoU32s.rs @@ -11,7 +11,7 @@ // Test a foreign function that accepts and returns a struct // by value. -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct TwoU32s { one: u32, two: u32 } diff --git a/src/test/run-pass/extern-pass-TwoU64s.rs b/src/test/run-pass/extern-pass-TwoU64s.rs index a716e038507..a6cb44b9c10 100644 --- a/src/test/run-pass/extern-pass-TwoU64s.rs +++ b/src/test/run-pass/extern-pass-TwoU64s.rs @@ -13,7 +13,7 @@ // ignore-win32 #9205 -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct TwoU64s { one: u64, two: u64 } diff --git a/src/test/run-pass/extern-pass-TwoU8s.rs b/src/test/run-pass/extern-pass-TwoU8s.rs index b5c99d55a8e..0d5b1b789c6 100644 --- a/src/test/run-pass/extern-pass-TwoU8s.rs +++ b/src/test/run-pass/extern-pass-TwoU8s.rs @@ -11,7 +11,7 @@ // Test a foreign function that accepts and returns a struct // by value. -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct TwoU8s { one: u8, two: u8 } diff --git a/src/test/run-pass/fixed_length_vec_glue.rs b/src/test/run-pass/fixed_length_vec_glue.rs index a40ab713c2d..62cfd10dbfb 100644 --- a/src/test/run-pass/fixed_length_vec_glue.rs +++ b/src/test/run-pass/fixed_length_vec_glue.rs @@ -8,8 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +extern crate debug; -use std::repr; +use debug::repr; struct Struc { a: u8, b: [int, ..3], c: int } diff --git a/src/test/run-pass/generic-default-type-params.rs b/src/test/run-pass/generic-default-type-params.rs index 4cf9ea3ee5a..b7706088b62 100644 --- a/src/test/run-pass/generic-default-type-params.rs +++ b/src/test/run-pass/generic-default-type-params.rs @@ -49,10 +49,10 @@ fn default_foo(x: Foo) { assert_eq!(x.baz(), (1, 'a')); } -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct BazHelper<T>(T); -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] // Ensure that we can use previous type parameters in defaults. struct Baz<T, U = BazHelper<T>, V = Option<U>>(T, U, V); diff --git a/src/test/run-pass/issue-12860.rs b/src/test/run-pass/issue-12860.rs index 187a45e6543..863245d42f0 100644 --- a/src/test/run-pass/issue-12860.rs +++ b/src/test/run-pass/issue-12860.rs @@ -13,7 +13,7 @@ extern crate collections; use collections::HashSet; -#[deriving(Eq, TotalEq, Hash)] +#[deriving(PartialEq, TotalEq, Hash)] struct XYZ { x: int, y: int, diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs index 9636a61269c..5f180f13ffa 100644 --- a/src/test/run-pass/issue-2718.rs +++ b/src/test/run-pass/issue-2718.rs @@ -25,7 +25,7 @@ pub mod pipes { payload: Option<T> } - #[deriving(Eq, Show)] + #[deriving(PartialEq, Show)] #[repr(int)] pub enum state { empty, diff --git a/src/test/run-pass/issue-3935.rs b/src/test/run-pass/issue-3935.rs index 0237a56fd17..e616c784f4d 100644 --- a/src/test/run-pass/issue-3935.rs +++ b/src/test/run-pass/issue-3935.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[deriving(Eq)] +#[deriving(PartialEq)] struct Bike { name: String, } diff --git a/src/test/run-pass/issue-5554.rs b/src/test/run-pass/issue-5554.rs index 3ae4e9c6da4..9151fb2b764 100644 --- a/src/test/run-pass/issue-5554.rs +++ b/src/test/run-pass/issue-5554.rs @@ -17,7 +17,7 @@ pub struct X<T> { } // reordering these bounds stops the ICE -impl<T: Default + Eq + Default> Default for X<T> { +impl<T: Default + PartialEq + Default> Default for X<T> { fn default() -> X<T> { X { a: Default::default() } } diff --git a/src/test/run-pass/issue-5572.rs b/src/test/run-pass/issue-5572.rs index d71e30eb64a..4e57ed94991 100644 --- a/src/test/run-pass/issue-5572.rs +++ b/src/test/run-pass/issue-5572.rs @@ -8,6 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn foo<T: ::std::cmp::Eq>(_t: T) { } +fn foo<T: ::std::cmp::PartialEq>(_t: T) { } pub fn main() { } diff --git a/src/test/run-pass/issue-6341.rs b/src/test/run-pass/issue-6341.rs index 3859d155851..e82448a4420 100644 --- a/src/test/run-pass/issue-6341.rs +++ b/src/test/run-pass/issue-6341.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[deriving(Eq)] +#[deriving(PartialEq)] struct A { x: uint } impl Drop for A { diff --git a/src/test/run-pass/monomorphize-abi-alignment.rs b/src/test/run-pass/monomorphize-abi-alignment.rs index 58d4d6a3dba..2233a5c3ea7 100644 --- a/src/test/run-pass/monomorphize-abi-alignment.rs +++ b/src/test/run-pass/monomorphize-abi-alignment.rs @@ -20,9 +20,9 @@ struct S<T> { i:u8, t:T } impl<T> S<T> { fn unwrap(self) -> T { self.t } } -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct A((u32, u32)); -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct B(u64); pub fn main() { diff --git a/src/test/run-pass/multiple-trait-bounds.rs b/src/test/run-pass/multiple-trait-bounds.rs index fc052b6a389..7ce1afb52a2 100644 --- a/src/test/run-pass/multiple-trait-bounds.rs +++ b/src/test/run-pass/multiple-trait-bounds.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn f<T:Eq + Ord>(_: T) { +fn f<T:PartialEq + PartialOrd>(_: T) { } pub fn main() { diff --git a/src/test/run-pass/newtype-temporary.rs b/src/test/run-pass/newtype-temporary.rs index 1ed93dd278b..b38bc9b6946 100644 --- a/src/test/run-pass/newtype-temporary.rs +++ b/src/test/run-pass/newtype-temporary.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct Foo(uint); fn foo() -> Foo { diff --git a/src/test/run-pass/operator-overloading.rs b/src/test/run-pass/operator-overloading.rs index 66783ad78e5..00e19b8481f 100644 --- a/src/test/run-pass/operator-overloading.rs +++ b/src/test/run-pass/operator-overloading.rs @@ -48,7 +48,7 @@ impl ops::Index<bool,int> for Point { } } -impl cmp::Eq for Point { +impl cmp::PartialEq for Point { fn eq(&self, other: &Point) -> bool { (*self).x == (*other).x && (*self).y == (*other).y } diff --git a/src/test/run-pass/overload-index-operator.rs b/src/test/run-pass/overload-index-operator.rs index 1727de79c78..6ac079f4616 100644 --- a/src/test/run-pass/overload-index-operator.rs +++ b/src/test/run-pass/overload-index-operator.rs @@ -30,7 +30,7 @@ impl<K,V> AssociationList<K,V> { } } -impl<K:Eq,V:Clone> Index<K,V> for AssociationList<K,V> { +impl<K:PartialEq,V:Clone> Index<K,V> for AssociationList<K,V> { fn index(&self, index: &K) -> V { for pair in self.pairs.iter() { if pair.key == *index { diff --git a/src/test/run-pass/overloaded-autoderef-count.rs b/src/test/run-pass/overloaded-autoderef-count.rs index 00877e7c2c9..6fdbd17c21b 100644 --- a/src/test/run-pass/overloaded-autoderef-count.rs +++ b/src/test/run-pass/overloaded-autoderef-count.rs @@ -11,7 +11,7 @@ use std::cell::Cell; use std::ops::{Deref, DerefMut}; -#[deriving(Eq)] +#[deriving(PartialEq)] struct DerefCounter<T> { count_imm: Cell<uint>, count_mut: uint, @@ -46,7 +46,7 @@ impl<T> DerefMut<T> for DerefCounter<T> { } } -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct Point { x: int, y: int diff --git a/src/test/run-pass/overloaded-autoderef.rs b/src/test/run-pass/overloaded-autoderef.rs index c9d5d02c247..782cea2979f 100644 --- a/src/test/run-pass/overloaded-autoderef.rs +++ b/src/test/run-pass/overloaded-autoderef.rs @@ -12,7 +12,7 @@ use std::cell::RefCell; use std::rc::Rc; use std::string::String; -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct Point { x: int, y: int diff --git a/src/test/run-pass/overloaded-deref.rs b/src/test/run-pass/overloaded-deref.rs index b28494109de..17cd9f8ef05 100644 --- a/src/test/run-pass/overloaded-deref.rs +++ b/src/test/run-pass/overloaded-deref.rs @@ -12,7 +12,7 @@ use std::cell::RefCell; use std::rc::Rc; use std::string::String; -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct Point { x: int, y: int diff --git a/src/test/run-pass/packed-struct-vec.rs b/src/test/run-pass/packed-struct-vec.rs index 94e4e3c6bef..8309e95820c 100644 --- a/src/test/run-pass/packed-struct-vec.rs +++ b/src/test/run-pass/packed-struct-vec.rs @@ -13,7 +13,7 @@ use std::mem; #[packed] -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct Foo { bar: u8, baz: u64 diff --git a/src/test/run-pass/regions-lifetime-static-items-enclosing-scopes.rs b/src/test/run-pass/regions-lifetime-static-items-enclosing-scopes.rs index 9e0ca203698..d61d7089d89 100644 --- a/src/test/run-pass/regions-lifetime-static-items-enclosing-scopes.rs +++ b/src/test/run-pass/regions-lifetime-static-items-enclosing-scopes.rs @@ -11,9 +11,9 @@ // This test verifies that temporary lifetime is correctly computed // for static objects in enclosing scopes. -use std::cmp::Eq; +use std::cmp::PartialEq; -fn f<T:Eq>(o: &mut Option<T>) { +fn f<T:PartialEq>(o: &mut Option<T>) { assert!(*o == None); } diff --git a/src/test/run-pass/regions-mock-tcx.rs b/src/test/run-pass/regions-mock-tcx.rs index 7e071177ff9..1d7521b7450 100644 --- a/src/test/run-pass/regions-mock-tcx.rs +++ b/src/test/run-pass/regions-mock-tcx.rs @@ -30,7 +30,7 @@ enum TypeStructure<'tcx> { TypeInt, TypeFunction(Type<'tcx>, Type<'tcx>), } -impl<'tcx> Eq for TypeStructure<'tcx> { +impl<'tcx> PartialEq for TypeStructure<'tcx> { fn eq(&self, other: &TypeStructure<'tcx>) -> bool { match (*self, *other) { (TypeInt, TypeInt) => true, @@ -86,7 +86,7 @@ impl<'tcx,'ast> TypeContext<'tcx, 'ast> { } } -#[deriving(Eq, TotalEq, Hash)] +#[deriving(PartialEq, TotalEq, Hash)] struct NodeId { id: uint } diff --git a/src/test/run-pass/small-enums-with-fields.rs b/src/test/run-pass/small-enums-with-fields.rs index e7d4e25c2bb..7cc6725a509 100644 --- a/src/test/run-pass/small-enums-with-fields.rs +++ b/src/test/run-pass/small-enums-with-fields.rs @@ -14,7 +14,7 @@ extern crate debug; use std::mem::size_of; -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] enum Either<T, U> { Left(T), Right(U) } macro_rules! check { diff --git a/src/test/run-pass/struct-lit-functional-no-fields.rs b/src/test/run-pass/struct-lit-functional-no-fields.rs index e8c18607f95..9212a72e5d4 100644 --- a/src/test/run-pass/struct-lit-functional-no-fields.rs +++ b/src/test/run-pass/struct-lit-functional-no-fields.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[deriving(Show,Eq,Clone)] +#[deriving(Show,PartialEq,Clone)] struct Foo<T> { bar: T, baz: T diff --git a/src/test/run-pass/structured-compare.rs b/src/test/run-pass/structured-compare.rs index b21c7684f69..f6b5531770b 100644 --- a/src/test/run-pass/structured-compare.rs +++ b/src/test/run-pass/structured-compare.rs @@ -13,7 +13,7 @@ #[deriving(Show)] enum foo { large, small, } -impl Eq for foo { +impl PartialEq for foo { fn eq(&self, other: &foo) -> bool { ((*self) as uint) == ((*other) as uint) } diff --git a/src/test/run-pass/tag-variant-disr-val.rs b/src/test/run-pass/tag-variant-disr-val.rs index 914904f2070..191a6a9c7e2 100644 --- a/src/test/run-pass/tag-variant-disr-val.rs +++ b/src/test/run-pass/tag-variant-disr-val.rs @@ -19,7 +19,7 @@ enum color { orange = 8 >> 1 } -impl Eq for color { +impl PartialEq for color { fn eq(&self, other: &color) -> bool { ((*self) as uint) == ((*other) as uint) } diff --git a/src/test/run-pass/tag.rs b/src/test/run-pass/tag.rs index 989f911134b..91c8b433b4e 100644 --- a/src/test/run-pass/tag.rs +++ b/src/test/run-pass/tag.rs @@ -11,7 +11,7 @@ enum colour { red(int, int), green, } -impl Eq for colour { +impl PartialEq for colour { fn eq(&self, other: &colour) -> bool { match *self { red(a0, b0) => { diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs index 18336a60318..9263cd1d485 100644 --- a/src/test/run-pass/task-comm-16.rs +++ b/src/test/run-pass/task-comm-16.rs @@ -52,7 +52,7 @@ enum t { tag3(int, u8, char) } -impl cmp::Eq for t { +impl cmp::PartialEq for t { fn eq(&self, other: &t) -> bool { match *self { tag1 => { diff --git a/src/test/run-pass/trait-inheritance-num.rs b/src/test/run-pass/trait-inheritance-num.rs index a611a55896e..8cf83fdf2d0 100644 --- a/src/test/run-pass/trait-inheritance-num.rs +++ b/src/test/run-pass/trait-inheritance-num.rs @@ -9,10 +9,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::cmp::{Eq, Ord}; +use std::cmp::{PartialEq, PartialOrd}; use std::num::NumCast; -pub trait NumExt: Num + NumCast + Eq + Ord {} +pub trait NumExt: Num + NumCast + PartialEq + PartialOrd {} pub trait FloatExt: NumExt {} diff --git a/src/test/run-pass/trait-inheritance-num1.rs b/src/test/run-pass/trait-inheritance-num1.rs index 28abae175cd..379acf26c19 100644 --- a/src/test/run-pass/trait-inheritance-num1.rs +++ b/src/test/run-pass/trait-inheritance-num1.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::cmp::Ord; +use std::cmp::PartialOrd; use std::num::NumCast; -pub trait NumExt: Num + NumCast + Ord { } +pub trait NumExt: Num + NumCast + PartialOrd { } fn greater_than_one<T:NumExt>(n: &T) -> bool { *n > NumCast::from(1).unwrap() diff --git a/src/test/run-pass/trait-inheritance-num2.rs b/src/test/run-pass/trait-inheritance-num2.rs index 3edf0c52619..b3f769798b3 100644 --- a/src/test/run-pass/trait-inheritance-num2.rs +++ b/src/test/run-pass/trait-inheritance-num2.rs @@ -11,7 +11,7 @@ // A more complex example of numeric extensions -use std::cmp::{Eq, Ord}; +use std::cmp::{PartialEq, PartialOrd}; pub trait TypeExt {} @@ -32,7 +32,7 @@ impl TypeExt for f32 {} impl TypeExt for f64 {} -pub trait NumExt: TypeExt + Eq + Ord + Num + NumCast {} +pub trait NumExt: TypeExt + PartialEq + PartialOrd + Num + NumCast {} impl NumExt for u8 {} impl NumExt for u16 {} diff --git a/src/test/run-pass/trait-inheritance-num3.rs b/src/test/run-pass/trait-inheritance-num3.rs index 7909f015912..fc17aa11340 100644 --- a/src/test/run-pass/trait-inheritance-num3.rs +++ b/src/test/run-pass/trait-inheritance-num3.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::cmp::{Eq, Ord}; +use std::cmp::{PartialEq, PartialOrd}; use std::num::NumCast; -pub trait NumExt: Eq + Ord + Num + NumCast {} +pub trait NumExt: PartialEq + PartialOrd + Num + NumCast {} impl NumExt for f32 {} diff --git a/src/test/run-pass/trait-inheritance-num5.rs b/src/test/run-pass/trait-inheritance-num5.rs index 0310dde2a6d..3a0605302a2 100644 --- a/src/test/run-pass/trait-inheritance-num5.rs +++ b/src/test/run-pass/trait-inheritance-num5.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::cmp::Eq; +use std::cmp::PartialEq; use std::num::NumCast; -pub trait NumExt: Eq + Num + NumCast {} +pub trait NumExt: PartialEq + Num + NumCast {} impl NumExt for f32 {} impl NumExt for int {} diff --git a/src/test/run-pass/trait-inheritance-overloading-simple.rs b/src/test/run-pass/trait-inheritance-overloading-simple.rs index 13cfb08e81b..bd9bc9e9b88 100644 --- a/src/test/run-pass/trait-inheritance-overloading-simple.rs +++ b/src/test/run-pass/trait-inheritance-overloading-simple.rs @@ -8,14 +8,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::cmp::Eq; +use std::cmp::PartialEq; -trait MyNum : Eq { } +trait MyNum : PartialEq { } #[deriving(Show)] struct MyInt { val: int } -impl Eq for MyInt { +impl PartialEq for MyInt { fn eq(&self, other: &MyInt) -> bool { self.val == other.val } fn ne(&self, other: &MyInt) -> bool { !self.eq(other) } } diff --git a/src/test/run-pass/trait-inheritance-overloading.rs b/src/test/run-pass/trait-inheritance-overloading.rs index f7c124b945a..b13ea7ae0ba 100644 --- a/src/test/run-pass/trait-inheritance-overloading.rs +++ b/src/test/run-pass/trait-inheritance-overloading.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::cmp::Eq; +use std::cmp::PartialEq; -trait MyNum : Add<Self,Self> + Sub<Self,Self> + Mul<Self,Self> + Eq { } +trait MyNum : Add<Self,Self> + Sub<Self,Self> + Mul<Self,Self> + PartialEq { } #[deriving(Show)] struct MyInt { val: int } @@ -27,7 +27,7 @@ impl Mul<MyInt, MyInt> for MyInt { fn mul(&self, other: &MyInt) -> MyInt { mi(self.val * other.val) } } -impl Eq for MyInt { +impl PartialEq for MyInt { fn eq(&self, other: &MyInt) -> bool { self.val == other.val } fn ne(&self, other: &MyInt) -> bool { !self.eq(other) } } diff --git a/src/test/run-pass/tuple-struct-constructor-pointer.rs b/src/test/run-pass/tuple-struct-constructor-pointer.rs index 77bfa439063..281ea39084f 100644 --- a/src/test/run-pass/tuple-struct-constructor-pointer.rs +++ b/src/test/run-pass/tuple-struct-constructor-pointer.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct Foo(int); -#[deriving(Eq, Show)] +#[deriving(PartialEq, Show)] struct Bar(int, int); pub fn main() { diff --git a/src/test/run-pass/unique-kinds.rs b/src/test/run-pass/unique-kinds.rs index 6d088a1f6d4..65a8314fe8e 100644 --- a/src/test/run-pass/unique-kinds.rs +++ b/src/test/run-pass/unique-kinds.rs @@ -8,15 +8,15 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::cmp::Eq; +use std::cmp::PartialEq; fn sendable() { - fn f<T:Send + Eq>(i: T, j: T) { + fn f<T:Send + PartialEq>(i: T, j: T) { assert!(i == j); } - fn g<T:Send + Eq>(i: T, j: T) { + fn g<T:Send + PartialEq>(i: T, j: T) { assert!(i != j); } @@ -30,11 +30,11 @@ fn sendable() { fn copyable() { - fn f<T:Eq>(i: T, j: T) { + fn f<T:PartialEq>(i: T, j: T) { assert!(i == j); } - fn g<T:Eq>(i: T, j: T) { + fn g<T:PartialEq>(i: T, j: T) { assert!(i != j); } @@ -48,11 +48,11 @@ fn copyable() { fn noncopyable() { - fn f<T:Eq>(i: T, j: T) { + fn f<T:PartialEq>(i: T, j: T) { assert!(i == j); } - fn g<T:Eq>(i: T, j: T) { + fn g<T:PartialEq>(i: T, j: T) { assert!(i != j); } diff --git a/src/test/run-pass/vector-sort-failure-safe.rs b/src/test/run-pass/vector-sort-failure-safe.rs index e5f1c48464d..e4e419e4988 100644 --- a/src/test/run-pass/vector-sort-failure-safe.rs +++ b/src/test/run-pass/vector-sort-failure-safe.rs @@ -15,7 +15,7 @@ static MAX_LEN: uint = 20; static mut drop_counts: [uint, .. MAX_LEN] = [0, .. MAX_LEN]; static mut clone_count: uint = 0; -#[deriving(Rand, Eq, Ord, TotalEq, TotalOrd)] +#[deriving(Rand, PartialEq, PartialOrd, TotalEq, TotalOrd)] struct DropCounter { x: uint, clone_num: uint } impl Clone for DropCounter { diff --git a/src/test/run-pass/while-prelude-drop.rs b/src/test/run-pass/while-prelude-drop.rs index b66a2f1d1de..28fbab41d95 100644 --- a/src/test/run-pass/while-prelude-drop.rs +++ b/src/test/run-pass/while-prelude-drop.rs @@ -10,7 +10,7 @@ use std::string::String; -#[deriving(Eq)] +#[deriving(PartialEq)] enum t { a, b(String), } fn make(i: int) -> t { |