Improve type parameter parsing (#12)

Author: bobozaur

CHANGELOG.md

@@ -1,40 +1,52 @@
-
 # Change Log
+
 All notable changes to this project will be documented in this file.
- 
+
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [1.1.0] - 2025-03-13
+
+### Changed
+
+- Allow more complex types in the macro attribute's type path.
+
+### Added
+
+- [#12](https://github.com/bobozaur/transitive/pull/12): Improves type parameters parsing to allow complex types,
+  such as the ones with generics.
+
 ## [1.0.1] - 2024-05-02
 
 ### Changed
-  
+
 - Clear out derive macro documentation.
 
 ## [1.0.0] - 2024-05-02
 
 ### Added
- - [#6](https://github.com/bobozaur/transitive/issues/6): Added generics support on the derived type.
+
+- [#6](https://github.com/bobozaur/transitive/issues/6): Added generics support on the derived type.
 
 ### Changed
-  
+
 - Updated dependencies.
 - Removed usage of `darling`.
 - Improved path direction parsing.
- 
+
 ## [0.5.0] - 2023-07-03
- 
+
 ### Added
- 
+
 - [#8](https://github.com/bobozaur/transitive/issues/8): Added the ability to specify custom error types for fallible conversions.
 
 ### Changed
-  
+
 - Updated dependencies.
 - Refactored library using `darling`.
 - Merged the two `TransitiveFrom` and `TransitiveTryFrom` derive macros into a single `Transitive` macro (the behavior is now controlled through the attribute modifiers).
 - Dropped the `all` macro attribute modifier.
- 
+
 ## [0.4.3] - 2023-03-09
 
-First "feature complete" release.
+First "feature complete" release.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "transitive"
-version = "1.0.1"
+version = "1.1.0"
 edition = "2021"
 authors = ["bobozaur"]
 description = "Transitive derive macros for Rust."
@@ -16,6 +16,6 @@ proc-macro = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-proc-macro2 = "1.0.81"
-quote = "1.0.36"
-syn = "2.0.60"
+proc-macro2 = "1"
+quote = "1"
+syn = "2"

src/transitive/fallible/mod.rs

@@ -2,52 +2,71 @@ mod try_from;
 mod try_into;
 
 use syn::{
-    parse::{Parse, ParseStream},
+    parse::{discouraged::Speculative, Parse, ParseStream},
     punctuated::Punctuated,
-    spanned::Spanned,
-    Error as SynError, Expr, Meta, Path, Result as SynResult, Token,
+    Error as SynError, Ident, Result as SynResult, Token, Type,
 };
 pub use try_from::TryTransitionFrom;
 pub use try_into::TryTransitionInto;
 
 /// A path list that may contain a custom error type.
 pub struct FalliblePathList {
-    path_list: Vec<Path>,
-    error: Option<Path>,
+    type_list: Vec<Type>,
+    error: Option<Type>,
 }
 
 impl Parse for FalliblePathList {
     fn parse(input: ParseStream) -> SynResult<Self> {
-        let meta_list = Punctuated::<Meta, Token![,]>::parse_terminated(input)?;
+        let attr_list = Punctuated::<Item, Token![,]>::parse_terminated(input)?;
 
-        let mut path_list = Vec::with_capacity(meta_list.len());
+        let mut type_list = Vec::with_capacity(attr_list.len());
         let mut error = None;
 
-        let mut iter = meta_list.into_iter().peekable();
-
-        while let Some(meta) = iter.next() {
-            // If this is not the last element then it's definitely part of the path list
-            if iter.peek().is_some() {
-                match meta {
-                    Meta::Path(path) => path_list.push(path),
-                    _ => return Err(SynError::new(meta.span(), "invalid value in path list")),
-                };
-            } else {
-                // We reached the last element which could be the custom error type
-                match meta {
-                    // Just a regular type path in the conversion path
-                    Meta::Path(p) => path_list.push(p),
-                    // Custom error, but must check that it's a type path
-                    Meta::NameValue(n) if n.path.is_ident("error") => match n.value {
-                        Expr::Path(p) => error = Some(p.path),
-                        _ => return Err(SynError::new(n.value.span(), "error must be a type")),
-                    },
-                    _ => return Err(SynError::new(meta.span(), "invalid value in path list")),
+        for attr in attr_list {
+            match attr {
+                Item::Type(ty) if error.is_some() => {
+                    let msg = "types not allowed after 'error'";
+                    return Err(SynError::new_spanned(ty, msg));
                 }
+                // Just a regular type path in the conversion path
+                Item::Type(ty) => type_list.push(ty),
+                Item::Error(err) if error.is_some() => {
+                    let msg = "'error' not allowed multiple times";
+                    return Err(SynError::new_spanned(err, msg));
+                }
+                // Custom error, but must check that it's a type path
+                Item::Error(err) => error = Some(err),
             }
         }
 
-        let output = Self { path_list, error };
+        let output = Self { type_list, error };
+
         Ok(output)
     }
 }
+
+/// An item in the parameters list of an attribute.
+pub enum Item {
+    Type(Type),
+    Error(Type),
+}
+
+impl Parse for Item {
+    fn parse(input: ParseStream) -> SynResult<Self> {
+        let fork = input.fork();
+        // Parse the ident name and the equal sign after it
+        let res = fork
+            .parse::<Ident>()
+            .and_then(|ident| fork.parse::<Token![=]>().map(|_| ident));
+
+        match res {
+            // We got an `error = MyType` argument
+            Ok(path) if path == "error" => {
+                input.advance_to(&fork);
+                input.parse().map(Self::Error)
+            }
+            // Try to parse anything else as a type in the path list
+            _ => input.parse().map(Self::Type),
+        }
+    }
+}

src/transitive/fallible/try_from.rs

@@ -23,13 +23,13 @@ impl ToTokens for TokenizablePath<'_, &TryTransitionFrom> {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let name = self.ident;
         let (impl_generics, ty_generics, where_clause) = self.generics.split_for_impl();
-        let first = self.path.0.path_list.first();
-        let last = self.path.0.path_list.last();
+        let first = self.path.0.type_list.first();
+        let last = self.path.0.type_list.last();
 
         let stmts = self
             .path
             .0
-            .path_list
+            .type_list
             .iter()
             .skip(1)
             .map(|ty| quote! {let val: #ty = core::convert::TryFrom::try_from(val)?;})

src/transitive/fallible/try_into.rs

@@ -21,15 +21,15 @@ impl ToTokens for TokenizablePath<'_, &TryTransitionInto> {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let name = self.ident;
         let (impl_generics, ty_generics, where_clause) = self.generics.split_for_impl();
-        let last = self.path.0.path_list.last();
-        let second_last = self.path.0.path_list.get(self.path.0.path_list.len() - 2);
+        let last = self.path.0.type_list.last();
+        let second_last = self.path.0.type_list.get(self.path.0.type_list.len() - 2);
 
         let stmts = self
             .path
             .0
-            .path_list
+            .type_list
             .iter()
-            .take(self.path.0.path_list.len() - 1)
+            .take(self.path.0.type_list.len() - 1)
             .map(|ty| quote! {let val: #ty = core::convert::TryFrom::try_from(val)?;});
 
         let error = self

src/transitive/infallible/from.rs

@@ -5,13 +5,13 @@ use quote::{quote, ToTokens};
 use syn::{
     parse::{Parse, ParseStream},
     punctuated::Punctuated,
-    Path, Result as SynResult, Token,
+    Result as SynResult, Token, Type,
 };
 
 use crate::transitive::TokenizablePath;
 
 /// Path corresponding to a [`#[transitive(from(..))`] path.
-pub struct TransitionFrom(Punctuated<Path, Token![,]>);
+pub struct TransitionFrom(Punctuated<Type, Token![,]>);
 
 impl Parse for TransitionFrom {
     fn parse(input: ParseStream) -> SynResult<Self> {

src/transitive/infallible/into.rs

@@ -3,13 +3,13 @@ use quote::{quote, ToTokens};
 use syn::{
     parse::{Parse, ParseStream},
     punctuated::Punctuated,
-    Path, Result as SynResult, Token,
+    Result as SynResult, Token, Type,
 };
 
 use crate::transitive::TokenizablePath;
 
 /// Path corresponding to a [`#[transitive(into(..))`] path.
-pub struct TransitionInto(Punctuated<Path, Token![,]>);
+pub struct TransitionInto(Punctuated<Type, Token![,]>);
 
 impl Parse for TransitionInto {
     fn parse(input: ParseStream) -> SynResult<Self> {

tests/combined.rs

@@ -3,8 +3,8 @@ mod macros;
 use transitive::Transitive;
 
 #[derive(Transitive)]
-// impl From<D>for A and impl From<C> for A
-#[transitive(from(D, C, B), from(C, B))]
+#[allow(clippy::duplicated_attributes)]
+#[transitive(from(D, C, B), from(C, B))] // impl From<D>for A and impl From<C> for A
 #[transitive(try_into(B, C, D))] // impl TryFrom<A> for D
 struct A;
 struct B;

tests/from.rs

@@ -18,6 +18,7 @@ impl_from!(B to A);
 impl_from!(C to B);
 impl_from!(D to C);
 
+#[allow(clippy::duplicated_attributes)]
 #[derive(Transitive)]
 #[transitive(from(D, C, B, A))] // impl From<D> for Z<T>
 #[transitive(from(C, B))] // impl From<D> for Z<T>
@@ -39,7 +40,7 @@ impl<T> From<B> for Z<T> {
 #[transitive(from(D, C, B, A))] // impl From<D> for Y<'a>
 struct Y<'a>(PhantomData<&'a ()>);
 
-impl<'a> From<A> for Y<'a> {
+impl From<A> for Y<'_> {
     fn from(_value: A) -> Self {
         Self(PhantomData)
     }
@@ -57,14 +58,11 @@ impl<const N: usize> From<A> for W<N> {
 
 #[derive(Transitive)]
 #[transitive(from(D, C, B, A))] // impl From<D> for Q<'a, 'b, N, T, U>
-struct Q<'a, 'b: 'a, const N: usize, T: 'a + Send, U: 'b = &'b str>(PhantomData<(&'a T, &'b U)>)
-where
-    T: Sync;
+struct Q<'a, 'b: 'a, const N: usize, T: 'a + Send + Sync, U: 'b = &'b str>(
+    PhantomData<(&'a T, &'b U)>,
+);
 
-impl<'a, 'b: 'a, const N: usize, T: 'a + Send, U: 'b> From<A> for Q<'a, 'b, N, T, U>
-where
-    T: Sync,
-{
+impl<'a, 'b: 'a, const N: usize, T: 'a + Send + Sync, U: 'b> From<A> for Q<'a, 'b, N, T, U> {
     fn from(_value: A) -> Self {
         Self(PhantomData)
     }

tests/into.rs

@@ -50,14 +50,11 @@ impl<const N: usize> From<W<N>> for A {
 
 #[derive(Transitive)]
 #[transitive(into(A, B, C, D))] // impl From<Q<'a, 'b, N, T, U>> for D
-struct Q<'a, 'b: 'a, const N: usize, T: 'a + Send, U: 'b = &'b str>(PhantomData<(&'a T, &'b U)>)
-where
-    T: Sync;
+struct Q<'a, 'b: 'a, const N: usize, T: 'a + Send + Sync, U: 'b = &'b str>(
+    PhantomData<(&'a T, &'b U)>,
+);
 
-impl<'a, 'b: 'a, const N: usize, T: 'a + Send, U: 'b> From<Q<'a, 'b, N, T, U>> for A
-where
-    T: Sync,
-{
+impl<'a, 'b: 'a, const N: usize, T: 'a + Send + Sync, U: 'b> From<Q<'a, 'b, N, T, U>> for A {
     fn from(_value: Q<'a, 'b, N, T, U>) -> Self {
         Self
     }