Fix FromStr generics check (#476)

Follows #468

## Synopsis

In #468, the `FromStr` derive was reworked. However, the check for
inferring trait bounds for the inner type was simplified to
`!generics.params.is_empty()`, which is not a very correct assumption,
because applies the redundant bounds for cases like these:
```rust
#[derive(FromStr)]
struct Int<const N: usize>(i32);
```
```rust
impl<const N: usize> derive_more::core::str::FromStr for Int<N>
where 
    i32: derive_more::core::str::FromStr
{ /* ... */}
```

## Solution

Use `utils::GenericSearch` machinery as a common mechanism for this
purpose.

## Additionally

Refactored `utils::GenericSearch` to use `Vec` instead `HashSet`,
because in the majority of cases there won't be any duplicates in
generic parameters and their number won't be big enough for a `HashSet`
to make a positive performance benefit. At the same moment, `HashSet`
requires `Hash` implementation of `syn::Ident` which is gated by the
`syn/extra-traits` feature, and thus we can lift it requirement for
`utils::GenericSearch` usage.

Author: tyranron

impl/Cargo.toml

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

impl/src/from_str.rs

@@ -10,7 +10,7 @@ use syn::{parse_quote, spanned::Spanned as _};
 
 use crate::utils::{
     attr::{self, ParseMultiple as _},
-    Either, Spanning,
+    Either, GenericsSearch, Spanning,
 };
 
 /// Expands a [`FromStr`] derive macro.
@@ -88,8 +88,9 @@ impl ToTokens for ForwardExpansion<'_> {
         let inner_ty = &self.inner.ty;
         let ty = self.self_ty.0;
 
+        let generics_search = GenericsSearch::from(self.self_ty.1);
         let mut generics = self.self_ty.1.clone();
-        if !generics.params.is_empty() {
+        if generics_search.any_in(inner_ty) {
             generics.make_where_clause().predicates.push(parse_quote! {
                 #inner_ty: derive_more::core::str::FromStr
             });

impl/src/utils.rs

@@ -24,7 +24,7 @@ use syn::{
 pub(crate) use self::either::Either;
 #[cfg(any(feature = "from", feature = "into"))]
 pub(crate) use self::fields_ext::FieldsExt;
-#[cfg(any(feature = "as_ref", feature = "eq"))]
+#[cfg(any(feature = "as_ref", feature = "eq", feature = "from_str"))]
 pub(crate) use self::generics_search::GenericsSearch;
 #[cfg(any(
     feature = "as_ref",
@@ -2381,23 +2381,21 @@ mod fields_ext {
     impl<T: Len + ?Sized> FieldsExt for T {}
 }
 
-#[cfg(any(feature = "as_ref", feature = "eq"))]
+#[cfg(any(feature = "as_ref", feature = "eq", feature = "from_str"))]
 mod generics_search {
     use syn::visit::Visit;
 
-    use super::HashSet;
-
     /// Search of whether some generics (type parameters, lifetime parameters or const parameters)
     /// are present in some [`syn::Type`].
     pub(crate) struct GenericsSearch<'s> {
         /// Type parameters to look for.
-        pub(crate) types: HashSet<&'s syn::Ident>,
+        pub(crate) types: Vec<&'s syn::Ident>,
 
         /// Lifetime parameters to look for.
-        pub(crate) lifetimes: HashSet<&'s syn::Ident>,
+        pub(crate) lifetimes: Vec<&'s syn::Ident>,
 
         /// Const parameters to look for.
-        pub(crate) consts: HashSet<&'s syn::Ident>,
+        pub(crate) consts: Vec<&'s syn::Ident>,
     }
 
     impl<'s> From<&'s syn::Generics> for GenericsSearch<'s> {
@@ -2436,15 +2434,15 @@ mod generics_search {
             self.found |= ep
                 .path
                 .get_ident()
-                .is_some_and(|ident| self.search.consts.contains(ident));
+                .is_some_and(|ident| self.search.consts.contains(&ident));
 
             if !self.found {
                 syn::visit::visit_expr_path(self, ep);
             }
         }
 
         fn visit_lifetime(&mut self, lf: &'ast syn::Lifetime) {
-            self.found |= self.search.lifetimes.contains(&lf.ident);
+            self.found |= self.search.lifetimes.contains(&&lf.ident);
 
             if !self.found {
                 syn::visit::visit_lifetime(self, lf);
@@ -2453,14 +2451,15 @@ mod generics_search {
 
         fn visit_type_path(&mut self, tp: &'ast syn::TypePath) {
             self.found |= tp.path.get_ident().is_some_and(|ident| {
-                self.search.types.contains(ident) || self.search.consts.contains(ident)
+                self.search.types.contains(&ident)
+                    || self.search.consts.contains(&ident)
             });
 
             if !self.found {
                 // `TypeParam::AssocType` case.
                 self.found |= tp.path.segments.first().is_some_and(|segment| {
                     matches!(segment.arguments, syn::PathArguments::None)
-                        && self.search.types.contains(&segment.ident)
+                        && self.search.types.contains(&&segment.ident)
                 });
             }
 

tests/from_str.rs

@@ -6,8 +6,17 @@ extern crate alloc;
 
 #[cfg(not(feature = "std"))]
 use alloc::string::ToString;
+use core::{convert::Infallible, marker::PhantomData};
 
-use derive_more::FromStr;
+use derive_more::with_trait::FromStr;
+
+trait Some {
+    type Assoc;
+}
+
+impl<T> Some for T {
+    type Assoc = i32;
+}
 
 mod structs {
     use super::*;
@@ -135,6 +144,116 @@ mod structs {
                     "invalid digit found in string",
                 );
             }
+
+            #[test]
+            fn assoc() {
+                #[derive(Debug, Eq, FromStr, PartialEq)]
+                struct Point1D<I: Some> {
+                    x: I::Assoc,
+                }
+
+                assert_eq!("3".parse::<Point1D<()>>().unwrap(), Point1D { x: 3 });
+                assert_eq!("0".parse::<Point1D<()>>().unwrap(), Point1D { x: 0 });
+                assert_eq!(
+                    "2147483647".parse::<Point1D<()>>().unwrap(),
+                    Point1D { x: i32::MAX },
+                );
+                assert_eq!(
+                    "-2147483648".parse::<Point1D<()>>().unwrap(),
+                    Point1D { x: i32::MIN },
+                );
+
+                assert_eq!(
+                    "2147483648".parse::<Point1D<()>>().unwrap_err().to_string(),
+                    "number too large to fit in target type",
+                );
+                assert_eq!(
+                    "-2147483649"
+                        .parse::<Point1D<()>>()
+                        .unwrap_err()
+                        .to_string(),
+                    "number too small to fit in target type",
+                );
+                assert_eq!(
+                    "wow".parse::<Point1D<()>>().unwrap_err().to_string(),
+                    "invalid digit found in string",
+                );
+            }
+
+            #[test]
+            fn lifetime() {
+                #[derive(Debug, Eq, PartialEq)]
+                struct Empty<'a>(PhantomData<&'a i32>);
+
+                impl FromStr for Empty<'_> {
+                    type Err = Infallible;
+
+                    fn from_str(_: &str) -> Result<Self, Self::Err> {
+                        Ok(Self(PhantomData))
+                    }
+                }
+
+                #[derive(Debug, Eq, FromStr, PartialEq)]
+                struct Wrapper<'a>(Empty<'a>);
+
+                assert_eq!(
+                    "3".parse::<Wrapper>().unwrap(),
+                    Wrapper(Empty(PhantomData)),
+                );
+            }
+
+            #[test]
+            fn const_param() {
+                #[derive(Debug, Eq, FromStr, PartialEq)]
+                struct Int<const N: usize>(i32);
+
+                #[derive(Debug, Eq, FromStr, PartialEq)]
+                struct Point1D<const N: usize> {
+                    x: Int<N>,
+                }
+
+                assert_eq!("3".parse::<Int<1>>().unwrap(), Int(3));
+                assert_eq!("0".parse::<Int<1>>().unwrap(), Int(0));
+                assert_eq!("2147483647".parse::<Int<1>>().unwrap(), Int(i32::MAX));
+                assert_eq!("-2147483648".parse::<Int<1>>().unwrap(), Int(i32::MIN));
+
+                assert_eq!(
+                    "2147483648".parse::<Int<1>>().unwrap_err().to_string(),
+                    "number too large to fit in target type",
+                );
+                assert_eq!(
+                    "-2147483649".parse::<Int<1>>().unwrap_err().to_string(),
+                    "number too small to fit in target type",
+                );
+                assert_eq!(
+                    "wow".parse::<Int<1>>().unwrap_err().to_string(),
+                    "invalid digit found in string",
+                );
+
+                assert_eq!("3".parse::<Point1D<3>>().unwrap(), Point1D { x: Int(3) });
+                assert_eq!("0".parse::<Point1D<3>>().unwrap(), Point1D { x: Int(0) });
+                assert_eq!(
+                    "2147483647".parse::<Point1D<3>>().unwrap(),
+                    Point1D { x: Int(i32::MAX) },
+                );
+                assert_eq!(
+                    "-2147483648".parse::<Point1D<3>>().unwrap(),
+                    Point1D { x: Int(i32::MIN) },
+                );
+
+                assert_eq!(
+                    "2147483648".parse::<Point1D<3>>().unwrap_err().to_string(),
+                    "number too large to fit in target type",
+                );
+                assert_eq!(
+                    "-2147483649".parse::<Point1D<3>>().unwrap_err().to_string(),
+                    "number too small to fit in target type",
+                );
+                assert_eq!(
+                    "wow".parse::<Point1D<3>>().unwrap_err().to_string(),
+                    "invalid digit found in string",
+                );
+            }
         }
     }