Fixed PartialEq and Eq bounds generation.

Also added tests to catch these cases. Issue mcarton#25
kankri · Oct 18, 2018 · 12e4bd1 · 12e4bd1
1 parent 442c695
commit 12e4bd1
Show file tree

Hide file tree

Showing 2 changed files with 42 additions and 18 deletions.
diff --git a/src/cmp.rs b/src/cmp.rs
@@ -3,6 +3,7 @@
 use proc_macro2;
 
 use ast;
+use attr;
 use matcher;
 use syn;
 use utils;
@@ -15,7 +16,7 @@ pub fn derive_eq(input: &ast::Input) -> proc_macro2::TokenStream {
     let generics = utils::build_impl_generics(
         input,
         &eq_trait_path,
-        |attrs| attrs.eq_bound().is_none(),
+        needs_eq_bound,
         |field| field.eq_bound(),
         |input| input.eq_bound(),
     );
@@ -79,7 +80,7 @@ pub fn derive_partial_eq(input: &ast::Input) -> Result<proc_macro2::TokenStream,
     let generics = utils::build_impl_generics(
         input,
         &partial_eq_trait_path,
-        |attrs| attrs.partial_eq_bound().is_none(),
+        needs_partial_eq_bound,
         |field| field.partial_eq_bound(),
         |input| input.partial_eq_bound(),
     );
@@ -97,6 +98,14 @@ pub fn derive_partial_eq(input: &ast::Input) -> Result<proc_macro2::TokenStream,
     })
 }
 
+fn needs_partial_eq_bound(attrs: &attr::Field) -> bool {
+    !attrs.ignore_partial_eq() && attrs.partial_eq_bound().is_none()
+}
+
+fn needs_eq_bound(attrs: &attr::Field) -> bool {
+    !attrs.ignore_partial_eq() && attrs.eq_bound().is_none()
+}
+
 /// Return the path of the `Eq` trait, that is `::std::cmp::Eq`.
 fn eq_trait_path() -> syn::Path {
     parse_quote!(::std::cmp::Eq)

diff --git a/tests/derive-partial-eq.rs b/tests/derive-partial-eq.rs
@@ -1,14 +1,16 @@
+use std::marker::PhantomData;
+
 #[macro_use]
 extern crate derivative;
 
 #[derive(Derivative)]
 #[derivative(PartialEq)]
 struct Foo {
-    foo: u8
+    foo: u8,
 }
 
 #[derive(Derivative)]
-#[derivative(PartialEq="feature_allow_slow_enum")]
+#[derivative(PartialEq = "feature_allow_slow_enum")]
 enum Option<T> {
     Some(T),
     None,
@@ -17,8 +19,8 @@ enum Option<T> {
 #[derive(Derivative)]
 #[derivative(PartialEq)]
 struct WithPtr<T: ?Sized> {
-    #[derivative(PartialEq(bound=""))]
-    foo: *const T
+    #[derivative(PartialEq(bound = ""))]
+    foo: *const T,
 }
 
 #[derive(Derivative)]
@@ -28,44 +30,48 @@ struct Empty;
 #[derive(Derivative)]
 #[derivative(PartialEq)]
 struct AllIgnored {
-    #[derivative(PartialEq="ignore")]
+    #[derivative(PartialEq = "ignore")]
     foo: u8,
 }
 
 #[derive(Derivative)]
 #[derivative(PartialEq)]
 struct OneIgnored {
-    #[derivative(PartialEq="ignore")]
+    #[derivative(PartialEq = "ignore")]
     foo: u8,
     bar: u8,
 }
 
 #[derive(Derivative)]
 #[derivative(PartialEq)]
-struct Parity(
-    #[derivative(PartialEq(compare_with="same_parity"))]
-    u8,
-);
+struct Parity(#[derivative(PartialEq(compare_with = "same_parity"))] u8);
 
 fn same_parity(lhs: &u8, rhs: &u8) -> bool {
     lhs % 2 == rhs % 2
 }
 
 #[derive(Derivative)]
 #[derivative(PartialEq)]
-struct Generic<T>(
-    #[derivative(PartialEq(compare_with="dummy_cmp", bound=""))]
-    T,
-);
+struct Generic<T>(#[derivative(PartialEq(compare_with = "dummy_cmp", bound = ""))] T);
 
 fn dummy_cmp<T>(_: &T, _: &T) -> bool {
     true
 }
 
+struct NonPartialEq;
+
+#[derive(Derivative)]
+#[derivative(PartialEq, Eq)]
+struct GenericIgnore<T> {
+    f: u32,
+    #[derivative(PartialEq = "ignore")]
+    t: PhantomData<T>,
+}
+
 trait SomeTrait {}
 struct SomeType {
     #[allow(dead_code)]
-    foo: u8
+    foo: u8,
 }
 impl SomeTrait for SomeType {}
 
@@ -95,5 +101,14 @@ fn main() {
     assert!(Parity(3) != Parity(42));
     assert!(Parity(2) != Parity(7));
 
-    assert!(Generic(SomeType { foo: 0 }) == Generic(SomeType{ foo: 0 }));
+    assert!(Generic(SomeType { foo: 0 }) == Generic(SomeType { foo: 0 }));
+    assert!(
+        GenericIgnore {
+            f: 123,
+            t: PhantomData::<NonPartialEq>::default()
+        } == GenericIgnore {
+            f: 123,
+            t: PhantomData::<NonPartialEq>::default()
+        }
+    );
 }