rustc: work around #[deriving(PartialEq)] messing up due to method lookup.

Author: eddyb

src/librustc/middle/mem_categorization.rs

@@ -163,7 +163,7 @@ pub enum Note {
 // dereference, but its type is the type *before* the dereference
 // (`@T`). So use `cmt.ty` to find the type of the value in a consistent
 // fashion. For more details, see the method `cat_pattern`
-#[deriving(Clone, PartialEq, Show)]
+#[deriving(Clone, Show)]
 pub struct cmt_<'tcx> {
     pub id: ast::NodeId,           // id of expr/pat producing this value
     pub span: Span,                // span of same expr/pat
@@ -173,6 +173,19 @@ pub struct cmt_<'tcx> {
     pub note: Note,                // Note about the provenance of this cmt
 }
 
+// FIXME(#15689) #[deriving(PartialEq)] fails with Ty (&TyS) because of method lookup.
+impl<'tcx> PartialEq for cmt_<'tcx> {
+    fn eq(&self, other: &cmt_<'tcx>) -> bool {
+        let (a, b) = (self, other);
+        a.id == b.id &&
+        a.span == b.span &&
+        a.cat == b.cat &&
+        a.mutbl == b.mutbl &&
+        a.ty == b.ty &&
+        a.note == b.note
+    }
+}
+
 pub type cmt<'tcx> = Rc<cmt_<'tcx>>;
 
 // We pun on *T to mean both actual deref of a ptr as well

src/librustc/middle/trans/adt.rs

@@ -71,7 +71,7 @@ type Hint = attr::ReprAttr;
 
 
 /// Representations.
-#[deriving(Eq, PartialEq, Show)]
+#[deriving(Eq, Show)]
 pub enum Repr<'tcx> {
     /// C-like enums; basically an int.
     CEnum(IntType, Disr, Disr), // discriminant range (signedness based on the IntType)
@@ -123,6 +123,34 @@ pub enum Repr<'tcx> {
     }
 }
 
+// FIXME(#15689) #[deriving(PartialEq)] fails with Ty (&TyS) because of method lookup.
+impl<'tcx> PartialEq for Repr<'tcx> {
+    fn eq(&self, other: &Repr<'tcx>) -> bool {
+        match (self, other) {
+            (&CEnum(a_ty, a_start, a_end), &CEnum(b_ty, b_start, b_end)) => {
+                a_ty == b_ty && a_start == b_start && a_end == b_end
+            }
+            (&Univariant(ref a_struct, a_dtor), &Univariant(ref b_struct, b_dtor)) => {
+                a_struct == b_struct && a_dtor == b_dtor
+            }
+            (&General(a_discr, ref a_tys, a_dtor), &General(b_discr, ref b_tys, b_dtor)) => {
+                a_discr == b_discr && a_tys == b_tys && a_dtor == b_dtor
+            }
+            (&RawNullablePointer { nndiscr: a_discr, nnty: a_ty, nullfields: ref a_fields},
+             &RawNullablePointer { nndiscr: b_discr, nnty: b_ty, nullfields: ref b_fields}) => {
+                a_discr == b_discr && a_ty == b_ty && a_fields == b_fields
+            }
+            (&StructWrappedNullablePointer { nonnull: ref a_struct, nndiscr: a_discr,
+                                             ptrfield: a_ptr, nullfields: ref a_fields},
+             &StructWrappedNullablePointer { nonnull: ref b_struct, nndiscr: b_discr,
+                                             ptrfield: b_ptr, nullfields: ref b_fields}) => {
+                a_struct == b_struct && a_discr == b_discr && a_ptr == b_ptr && a_fields == b_fields
+            }
+            _ => false
+        }
+    }
+}
+
 /// For structs, and struct-like parts of anything fancier.
 #[deriving(Eq, PartialEq, Show)]
 pub struct Struct<'tcx> {

src/librustc/middle/trans/base.rs

@@ -1823,7 +1823,7 @@ pub fn trans_closure<'a, 'b, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
     let fcx = new_fn_ctxt(ccx,
                           llfndecl,
                           fn_ast_id,
-                          closure_env.kind != closure::NotClosure,
+                          closure_env.is_closure(),
                           output_type,
                           param_substs,
                           Some(body.span),

src/librustc/middle/trans/closure.rs

@@ -344,7 +344,6 @@ fn fill_fn_pair(bcx: Block, pair: ValueRef, llfn: ValueRef, llenvptr: ValueRef)
     Store(bcx, llenvptr, GEPi(bcx, pair, [0u, abi::fn_field_box]));
 }
 
-#[deriving(PartialEq)]
 pub enum ClosureKind<'tcx> {
     NotClosure,
     // See load_environment.
@@ -384,6 +383,13 @@ impl<'a, 'tcx> ClosureEnv<'a, 'tcx> {
             }
         }
     }
+
+    pub fn is_closure(&self) -> bool {
+        match self.kind {
+            NotClosure => false,
+            BoxedClosure(..) | UnboxedClosure(..) => true
+        }
+    }
 }
 
 pub fn trans_expr_fn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,

src/librustc/middle/ty.rs

@@ -196,12 +196,19 @@ pub struct AssociatedType {
     pub container: ImplOrTraitItemContainer,
 }
 
-#[deriving(Clone, PartialEq, Eq, Hash, Show)]
+#[deriving(Clone, Eq, Hash, Show)]
 pub struct mt<'tcx> {
     pub ty: Ty<'tcx>,
     pub mutbl: ast::Mutability,
 }
 
+// FIXME(#15689) #[deriving(PartialEq)] fails with Ty (&TyS) because of method lookup.
+impl<'tcx> PartialEq for mt<'tcx> {
+    fn eq(&self, other: &mt<'tcx>) -> bool {
+        self.ty == other.ty && self.mutbl == other.mutbl
+    }
+}
+
 #[deriving(Clone, PartialEq, Eq, Hash, Encodable, Decodable, Show)]
 pub enum TraitStore {
     /// Box<Trait>
@@ -254,7 +261,7 @@ pub enum AutoAdjustment<'tcx> {
     AdjustDerefRef(AutoDerefRef<'tcx>)
 }
 
-#[deriving(Clone, PartialEq, Show)]
+#[deriving(Clone, Show)]
 pub enum UnsizeKind<'tcx> {
     // [T, ..n] -> [T], the uint field is n.
     UnsizeLength(uint),
@@ -264,6 +271,22 @@ pub enum UnsizeKind<'tcx> {
     UnsizeVtable(TyTrait<'tcx>, /* the self type of the trait */ Ty<'tcx>)
 }
 
+// FIXME(#15689) #[deriving(PartialEq)] fails with Ty (&TyS) because of method lookup.
+impl<'tcx> PartialEq for UnsizeKind<'tcx> {
+    fn eq(&self, other: &UnsizeKind<'tcx>) -> bool {
+        match (self, other) {
+            (&UnsizeLength(a), &UnsizeLength(b)) => a == b,
+            (&UnsizeStruct(ref a_kind, a_idx), &UnsizeStruct(ref b_kind, b_idx)) => {
+                a_kind == b_kind && a_idx == b_idx
+            }
+            (&UnsizeVtable(ref a_trait, a_self), &UnsizeVtable(ref b_trait, b_self)) => {
+                a_trait == b_trait && a_self == b_self
+            }
+            _ => false
+        }
+    }
+}
+
 #[deriving(Clone, Show)]
 pub struct AutoDerefRef<'tcx> {
     pub autoderefs: uint,
@@ -603,7 +626,7 @@ impl<'tcx, S: Writer> Hash<S> for TyS<'tcx> {
 pub type Ty<'tcx> = &'tcx TyS<'tcx>;
 
 /// An entry in the type interner.
-struct InternedTy<'tcx> {
+pub struct InternedTy<'tcx> {
     ty: Ty<'tcx>
 }
 
@@ -666,12 +689,23 @@ pub struct ClosureTy<'tcx> {
     pub abi: abi::Abi,
 }
 
-#[deriving(Clone, PartialEq, Eq, Hash)]
+#[deriving(Clone, Eq, Hash)]
 pub enum FnOutput<'tcx> {
     FnConverging(Ty<'tcx>),
     FnDiverging
 }
 
+// FIXME(#15689) #[deriving(PartialEq)] fails with Ty (&TyS) because of method lookup.
+impl<'tcx> PartialEq for FnOutput<'tcx> {
+    fn eq(&self, other: &FnOutput<'tcx>) -> bool {
+        match (*self, *other) {
+            (FnConverging(a), FnConverging(b)) => a == b,
+            (FnDiverging, FnDiverging) => true,
+            _ => false
+        }
+    }
+}
+
 impl<'tcx> FnOutput<'tcx> {
     pub fn unwrap(self) -> Ty<'tcx> {
         match self {
@@ -693,14 +727,25 @@ impl<'tcx> FnOutput<'tcx> {
  * - `output` is the return type.
  * - `variadic` indicates whether this is a varidic function. (only true for foreign fns)
  */
-#[deriving(Clone, PartialEq, Eq, Hash)]
+#[deriving(Clone, Eq, Hash)]
 pub struct FnSig<'tcx> {
     pub binder_id: ast::NodeId,
     pub inputs: Vec<Ty<'tcx>>,
     pub output: FnOutput<'tcx>,
     pub variadic: bool
 }
 
+// FIXME(#15689) #[deriving(PartialEq)] fails with Ty (&TyS) because of method lookup.
+impl<'tcx> PartialEq for FnSig<'tcx> {
+    fn eq(&self, other: &FnSig<'tcx>) -> bool {
+        let (a, b) = (self, other);
+        a.binder_id == b.binder_id &&
+        a.inputs == b.inputs &&
+        a.output == b.output &&
+        a.variadic == b.variadic
+    }
+}
+
 #[deriving(Clone, PartialEq, Eq, Hash, Show)]
 pub struct ParamTy {
     pub space: subst::ParamSpace,
@@ -939,7 +984,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, PartialEq, Eq, Hash, Show)]
+#[deriving(Clone, Eq, Hash, Show)]
 pub enum sty<'tcx> {
     ty_nil,
     ty_bool,
@@ -980,6 +1025,46 @@ pub enum sty<'tcx> {
             // on non-useful type error messages)
 }
 
+// FIXME(#15689) #[deriving(PartialEq)] fails with Ty (&TyS) because of method lookup.
+impl<'tcx> PartialEq for sty<'tcx> {
+    fn eq(&self, other: &sty<'tcx>) -> bool {
+        match (self, other) {
+            (&ty_nil, &ty_nil) |
+            (&ty_bool, &ty_bool) |
+            (&ty_char, &ty_char) |
+            (&ty_str, &ty_str) |
+            (&ty_err, &ty_err) => true,
+            (&ty_int(a), &ty_int(b)) => a == b,
+            (&ty_uint(a), &ty_uint(b)) => a == b,
+            (&ty_float(a), &ty_float(b)) => a == b,
+            (&ty_uniq(a), &ty_uniq(b)) |
+            (&ty_open(a), &ty_open(b)) => a == b,
+            (&ty_enum(a_def, ref a_substs), &ty_enum(b_def, ref b_substs)) |
+            (&ty_struct(a_def, ref a_substs), &ty_struct(b_def, ref b_substs)) => {
+                a_def == b_def && a_substs == b_substs
+            }
+            (&ty_vec(a_ty, a_len), &ty_vec(b_ty, b_len)) => {
+                a_ty == b_ty && a_len == b_len
+            }
+            (&ty_ptr(a), &ty_ptr(b)) => a == b,
+            (&ty_rptr(a_lt, a_ty), &ty_rptr(b_lt, b_ty)) => {
+                a_lt == b_lt && a_ty == b_ty
+            }
+            (&ty_bare_fn(ref a), &ty_bare_fn(ref b)) => a == b,
+            (&ty_closure(ref a), &ty_closure(ref b)) => a == b,
+            (&ty_trait(ref a), &ty_trait(ref b)) => a == b,
+            (&ty_unboxed_closure(a_def, a_lt, ref a_substs),
+             &ty_unboxed_closure(b_def, b_lt, ref b_substs)) => {
+                a_def == b_def && a_lt == b_lt && a_substs == b_substs
+            }
+            (&ty_tup(ref a), &ty_tup(ref b)) => a == b,
+            (&ty_param(a), &ty_param(b)) => a == b,
+            (&ty_infer(a), &ty_infer(b)) => a == b,
+            _ => false
+        }
+    }
+}
+
 #[deriving(Clone, PartialEq, Eq, Hash, Show)]
 pub struct TyTrait<'tcx> {
     pub def_id: DefId,