support syn::ExprCall and syn::ExprClosure in with attribute

Author: fredszaq

CHANGELOG.md

@@ -13,6 +13,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
   ([#532](https://github.com/JelteF/derive_more/pull/532))
 - Add support for custom eq functions in `PartialEq`/`Eq` derive.
   ([#535](https://github.com/JelteF/derive_more/pull/535))
+- Support `syn::ExprCall` and `syn::ExprClosure` (function call expressions and
+  closures) in addition to `syn::Path` in `#[hash(with(...))]`,
+  `#[partial_eq(with(...))]` and `#[eq(with(...))]` attributes.
 
 ### Fixed
 

impl/Cargo.toml

@@ -57,11 +57,11 @@ debug = ["syn/extra-traits", "dep:unicode-ident"]
 deref = []
 deref_mut = []
 display = ["syn/extra-traits", "dep:unicode-ident", "dep:convert_case"]
-eq = ["syn/extra-traits", "syn/visit"]
+eq = ["syn/extra-traits", "syn/full", "syn/visit"]
 error = ["syn/extra-traits"]
 from = ["syn/extra-traits"]
 from_str = ["syn/full", "syn/visit", "dep:convert_case"]
-hash = ["syn/extra-traits", "syn/visit"]
+hash = ["syn/extra-traits", "syn/full", "syn/visit"]
 index = []
 index_mut = []
 into = ["syn/extra-traits", "syn/visit-mut"]

impl/doc/eq.md

@@ -341,3 +341,14 @@ impl PartialEq for Foo {
     }
 }
 ```
+
+A closure or a function call expression returning a callable can be used in place of a path too:
+
+```rust
+# use derive_more::PartialEq;
+#[derive(Debug, PartialEq)]
+struct Foo(#[partial_eq(with(|a: &i32, b: &i32| a % 10 == b % 10))] i32);
+
+assert_eq!(Foo(12), Foo(42));
+assert_ne!(Foo(12), Foo(13));
+```

impl/doc/hash.md

@@ -272,3 +272,15 @@ impl Hash for Foo {
 
 This is useful for types that don't implement `Hash` but can be hashed in a custom way, or when you need different
 hashing behavior than the default.
+
+A closure or a function call expression returning a callable can be used in place of a path too:
+
+```rust
+# use derive_more::Hash;
+# use core::hash::Hasher;
+#[derive(Hash)]
+struct Foo {
+    #[hash(with(|value: &i32, state: &mut _| Hasher::write_i32(state, value.abs())))]
+    value: i32,
+}
+```

impl/src/cmp/partial_eq.rs

@@ -124,9 +124,9 @@ pub fn expand(input: &syn::DeriveInput, _: &'static str) -> syn::Result<TokenStr
 /// Indices of [`syn::Field`]s marked with an [`attr::Skip`].
 type SkippedFields = HashSet<usize>;
 
-/// Mapping from [`syn::Field`] marked with an [`attr::With`] to the [`syn::Path`] of the alternate
-/// eq function.
-type FieldsWithAlternateEqFunction = HashMap<usize, syn::Path>;
+/// Mapping from [`syn::Field`] marked with an [`attr::With`] to the alternate eq function
+/// expression.
+type FieldsWithAlternateEqFunction = HashMap<usize, attr::Callable>;
 
 /// Expansion of a macro for generating a structural [`PartialEq`] implementation of an enum or a
 /// struct.
@@ -213,7 +213,7 @@ impl StructuralExpansion<'_> {
                             .get(&num)
                             .map(|eq_fn| {
                                 let maybe_not = (!eq).then(|| quote! {!});
-                                quote! { #maybe_not #eq_fn(#self_val, #other_val) }
+                                quote! { #maybe_not (#eq_fn)(#self_val, #other_val) }
                             }
                             ).unwrap_or_else(|| quote! { #self_val #cmp #other_val }
                         );

impl/src/hash.rs

@@ -138,9 +138,9 @@ pub fn expand(input: &syn::DeriveInput, _: &'static str) -> syn::Result<TokenStr
 /// Indices of [`syn::Field`]s marked with an [`attr::Skip`].
 type SkippedFields = HashSet<usize>;
 
-/// Mapping from [`syn::Field`] marked with an [`attr::With`] to the [`syn::Path`] of the alternate
-/// hash function.
-type FieldsWithAlternateHashFunction = HashMap<usize, syn::Path>;
+/// Mapping from [`syn::Field`] marked with an [`attr::With`] to the alternate hash function
+/// expression.
+type FieldsWithAlternateHashFunction = HashMap<usize, attr::Callable>;
 
 /// Expansion of a macro for generating a structural [`Hash`] implementation of an enum or a struct.
 struct StructuralExpansion<'i> {
@@ -205,9 +205,9 @@ impl StructuralExpansion<'_> {
                             let self_val = format_ident!("__self_{num}");
                             let hash_function = alternate_hash_functions
                                 .get(&num)
-                                .map(|it| quote! {#it})
+                                .map(|it| quote! { (#it) })
                                 .unwrap_or_else(
-                                    || quote! {derive_more::core::hash::Hash::hash},
+                                    || quote! { derive_more::core::hash::Hash::hash },
                                 );
 
                             punctuated::Pair::Punctuated(

impl/src/utils.rs

@@ -1575,6 +1575,17 @@ pub(crate) mod attr {
     #[cfg(feature = "try_from")]
     pub(crate) use self::{repr_conversion::ReprConversion, repr_int::ReprInt};
 
+    /// A callable expression accepted as an attribute argument: a function call
+    /// (`foo(arg)`), a path to a function (`foo::bar`), or a closure (`|x| ...`).
+    #[cfg(any(
+        feature = "eq",
+        feature = "from_str",
+        feature = "hash",
+        feature = "try_into",
+    ))]
+    pub(crate) type Callable =
+        Either<syn::ExprCall, Either<syn::Path, syn::ExprClosure>>;
+
     /// [`Parse`]ing with additional state or metadata.
     pub(crate) trait Parser {
         /// [`Parse`]s an item, using additional state or metadata.
@@ -2173,10 +2184,10 @@ pub(crate) mod attr {
     pub(crate) mod error {
         use syn::parse::{Parse, ParseStream};
 
-        use super::{Either, ParseMultiple};
+        use super::{Callable, ParseMultiple};
 
         /// Representation of an attribute, specifying the error type and, optionally, a
-        /// [`Conversion`] from a built-in error type.
+        /// [`Callable`] conversion from a built-in error type.
         ///
         /// ```rust,ignore
         /// #[<attribute>(error(<ty>))]
@@ -2189,7 +2200,7 @@ pub(crate) mod attr {
             /// Custom conversion.
             ///
             /// If [`None`], then [`Into`] conversion should be applied.
-            pub(crate) conv: Option<Conversion>,
+            pub(crate) conv: Option<Callable>,
         }
 
         impl Parse for Error {
@@ -2212,7 +2223,7 @@ pub(crate) mod attr {
 
                 _ = syn::token::Comma::parse(&inner)?;
 
-                let conv = Conversion::parse(&inner)?;
+                let conv = Callable::parse(&inner)?;
                 if inner.is_empty() {
                     Ok(Self {
                         ty,
@@ -2228,12 +2239,6 @@ pub(crate) mod attr {
         }
 
         impl ParseMultiple for Error {}
-
-        /// Possible conversions of an [`attr::Error`].
-        ///
-        /// [`attr::Error`]: Error
-        pub(crate) type Conversion =
-            Either<syn::ExprCall, Either<syn::Path, syn::ExprClosure>>;
     }
 
     #[cfg(feature = "try_from")]
@@ -2411,16 +2416,16 @@ pub(crate) mod attr {
         use syn::parenthesized;
         use syn::parse::{Parse, ParseStream};
 
-        use crate::utils::attr::ParseMultiple;
+        use crate::utils::attr::{Callable, ParseMultiple};
 
         /// Representation of an attribute, specifying a custom function for a trait method.
         ///
         /// ```rust,ignore
-        /// #[<attribute>(with(<path>))]
+        /// #[<attribute>(with(<func>))]
         /// ```
         pub(crate) struct With {
             /// Custom function.
-            pub(crate) func: syn::Path, // TODO: Support `syn::ExprCall` and `syn::ExprClosure` too.
+            pub(crate) func: Callable,
         }
 
         impl Parse for With {
@@ -2432,9 +2437,9 @@ pub(crate) mod attr {
                         "unknown attribute argument, expected `with(...)` argument here",
                     ));
                 }
-                let path_and_parents;
-                parenthesized!(path_and_parents in input);
-                let func = path_and_parents.parse::<syn::Path>()?;
+                let func_tokens;
+                parenthesized!(func_tokens in input);
+                let func = func_tokens.parse::<Callable>()?;
                 Ok(Self { func })
             }
         }

tests/compile_fail/partial_eq/unknown_with_function.stderr

@@ -1,9 +1,15 @@
-error[E0425]: cannot find function `unknown` in this scope
+error[E0425]: cannot find value `unknown` in this scope
  --> tests/compile_fail/partial_eq/unknown_with_function.rs:2:30
   |
 2 | struct Foo(#[partial_eq(with(unknown))] i32);
   |                              ^^^^^^^ not found in this scope
 
+error[E0425]: cannot find value `unknown` in this scope
+  --> tests/compile_fail/partial_eq/unknown_with_function.rs:11:29
+   |
+11 |     Bar { #[partial_eq(with(unknown))] i: i32 },
+   |                             ^^^^^^^ not found in this scope
+
 error[E0061]: this function takes 1 argument but 2 arguments were supplied
  --> tests/compile_fail/partial_eq/unknown_with_function.rs:7:30
   |
@@ -34,12 +40,6 @@ error[E0308]: mismatched types
   |
   = note: this error originates in the derive macro `derive_more::PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0425]: cannot find function `unknown` in this scope
-  --> tests/compile_fail/partial_eq/unknown_with_function.rs:11:29
-   |
-11 |     Bar { #[partial_eq(with(unknown))] i: i32 },
-   |                             ^^^^^^^ not found in this scope
-
 error[E0061]: this function takes 1 argument but 2 arguments were supplied
   --> tests/compile_fail/partial_eq/unknown_with_function.rs:12:29
    |

tests/eq.rs

@@ -218,6 +218,37 @@ mod structs {
 
                 let _: AssertParamIsEq<Bar>;
             }
+
+            #[test]
+            fn closure() {
+                #[derive(Eq, PartialEq)]
+                struct Foo(
+                    #[partial_eq(with(|_: &NotPartialEq, _: &NotPartialEq| true))]
+                    NotPartialEq,
+                );
+                #[derive(Eq, PartialEq)]
+                struct Bar(
+                    #[eq(with(|_: &NotPartialEq, _: &NotPartialEq| true))] NotPartialEq,
+                );
+
+                let _: AssertParamIsEq<Foo>;
+                let _: AssertParamIsEq<Bar>;
+            }
+
+            #[test]
+            fn fn_call() {
+                fn make_eq_fn() -> fn(&NotPartialEq, &NotPartialEq) -> bool {
+                    |_, _| true
+                }
+
+                #[derive(Eq, PartialEq)]
+                struct Foo(#[partial_eq(with(make_eq_fn()))] NotPartialEq);
+                #[derive(Eq, PartialEq)]
+                struct Bar(#[eq(with(make_eq_fn()))] NotPartialEq);
+
+                let _: AssertParamIsEq<Foo>;
+                let _: AssertParamIsEq<Bar>;
+            }
         }
 
         mod generic {
@@ -664,6 +695,40 @@ mod enums {
                 let _: AssertParamIsEq<E>;
             }
 
+            #[test]
+            fn closure() {
+                #[derive(Eq, PartialEq)]
+                enum E {
+                    Foo(
+                        #[partial_eq(with(|_: &NotPartialEq, _: &NotPartialEq| true))]
+                        NotPartialEq,
+                    ),
+                    Bar(
+                        #[eq(with(|_: &NotPartialEq, _: &NotPartialEq| true))]
+                        NotPartialEq,
+                    ),
+                    Baz,
+                }
+
+                let _: AssertParamIsEq<E>;
+            }
+
+            #[test]
+            fn fn_call() {
+                fn make_eq_fn() -> fn(&NotPartialEq, &NotPartialEq) -> bool {
+                    |_, _| true
+                }
+
+                #[derive(Eq, PartialEq)]
+                enum E {
+                    Foo(#[partial_eq(with(make_eq_fn()))] NotPartialEq),
+                    Bar(#[eq(with(make_eq_fn()))] NotPartialEq),
+                    Baz,
+                }
+
+                let _: AssertParamIsEq<E>;
+            }
+
             #[test]
             fn multi_variant() {
                 #[derive(Eq, PartialEq)]

tests/hash.rs

@@ -39,6 +39,13 @@ pub mod utils {
         state.write_u32(42);
         state.write_u32(*value)
     }
+
+    pub fn make_u32_hash_function() -> fn(&u32, &mut dyn core::hash::Hasher) {
+        |value, state| {
+            state.write_u32(1337);
+            state.write_u32(*value);
+        }
+    }
 }
 
 mod structs {
@@ -99,6 +106,23 @@ mod structs {
             c: bool,
         }
 
+        #[derive(Hash)]
+        struct StructWithClosureHashFunction {
+            #[hash(with(|value: &u32, state: &mut _| {
+                core::hash::Hasher::write_u32(state, 42);
+                core::hash::Hasher::write_u32(state, *value);
+            }))]
+            a: u32,
+            b: &'static str,
+        }
+
+        #[derive(Hash)]
+        struct StructWithCallExprHashFunction {
+            #[hash(with(utils::make_u32_hash_function()))]
+            a: u32,
+            b: &'static str,
+        }
+
         #[derive(Hash)]
         struct MixedSkip {
             field1: i32,
@@ -135,6 +159,14 @@ mod structs {
                 }),
                 do_hash(&(42, 42, "test", true))
             );
+            assert_eq!(
+                do_hash(&StructWithClosureHashFunction { a: 42, b: "test" }),
+                do_hash(&(42, 42, "test"))
+            );
+            assert_eq!(
+                do_hash(&StructWithCallExprHashFunction { a: 42, b: "test" }),
+                do_hash(&(1337, 42, "test"))
+            );
             assert_eq!(
                 do_hash(&MixedSkip {
                     field1: 42,
@@ -231,6 +263,14 @@ mod enums {
         #[hash(skip)]
         #[allow(unused)]
         C(i32),
+        D(
+            #[hash(with(|value: &u32, state: &mut _| {
+                core::hash::Hasher::write_u32(state, 7);
+                core::hash::Hasher::write_u32(state, *value);
+            }))]
+            u32,
+        ),
+        E(#[hash(with(utils::make_u32_hash_function()))] u32),
     }
 
     #[test]
@@ -294,6 +334,18 @@ mod enums {
 
         let wc = WithAndSkip::C(42);
         assert_eq!(do_hash(&wc), do_hash(&core::mem::discriminant(&wc)));
+
+        let wd = WithAndSkip::D(42);
+        assert_eq!(
+            do_hash(&wd),
+            do_hash(&(core::mem::discriminant(&wd), 7, 42)),
+        );
+
+        let we = WithAndSkip::E(42);
+        assert_eq!(
+            do_hash(&we),
+            do_hash(&(core::mem::discriminant(&we), 1337, 42)),
+        );
     }
 }