Replace `deluxe` because it's unmaintained

[TGRCdev]

deluxe has a bug that causes parsing to hiccup with angle brackets. The crate has been unmaintained for at least 2 years, so it does not look like the fix I provided will be included any time soon.

I tried to mitigate this issue by vendoring deluxe including my fix, but that itself is a hacked together fix that broke the CI. In the end, all the work I put into not having to think about macro parsing has totally backfired, and has reduced my willingness to work on this project even more than before.

All the structures will have to be ported to use darling, and I need to think of a way of using AngleBracketedGenericArguments such that I can derive FromMeta on an attribute schema containing it and not have to hand-roll the parsing every time.

[jwright159]

Right, so, for documentation purposes, here's what I've found:

FromMeta just will not parse AngleBracketedGenericArguments, thanks to the requirement on syn::Meta. So if we DO move to darling, we'll have to change how generics are written, because yeah hand-rolling that sounds like a bad idea.

[StrikeForceZero]

Potential workaround:

Usage Example:

I'm mixing proc_macro2 context in here to keep it brief.
ok_or_compile_error! is just a macro that matches the result, and if Err returns a compiler error in token stream format.

Probably better ways to do some of this, but I hope it highlights the idea.

#[proc_macro_attribute]
fn my_attr(attr: TokenStream, input: TokenStream) -> TokenStream {
   let attr = rewrite_generics_angles(attr, "generics");
   let your_struct = {
     // #[darling(derive_syn_parse)] or manual `impl syn::Parse`
     ok_or_compile_error!(syn::parse2::<YourStruct>()); 
     // or #[derive(FromMeta)]
     let attr: Attribute = parse_qoute!(attr);
     ok_or_compile_error!(YourStruct::from_meta(&attr.meta))
  };
  // do stuff
}

fn rewrite_generics_angles

Click to implementation

use proc_macro2::{Delimiter, Group, Punct, Spacing, TokenStream, TokenTree};

/// Rewrite `field_name = <...>` to `field_name(T1, T2, ...)`
pub fn rewrite_generics_angles(mut ts: TokenStream, field_name: &str) -> TokenStream {
    // Treat ANY '<' / '>' as an angle while capturing (Spacing can be Joint in types).
    fn is_lt_any(p: &Punct) -> bool {
        p.as_char() == '<'
    }
    fn is_gt_any(p: &Punct) -> bool {
        p.as_char() == '>'
    }

    // Recursive pass that processes groups and rewrites at top level & inside groups.
    // `prev_colon_run` tracks how many consecutive ':' were just seen (to detect '::').
    fn pass(tokens: TokenStream, field: &str, mut prev_colon_run: u8) -> TokenStream {
        let mut out = Vec::<TokenTree>::new();
        let mut it = tokens.into_iter().peekable();

        // Peek helper: are the next TWO tokens '::'?
        let next_is_colon_colon = |iter: &std::iter::Peekable<_>| -> bool {
            let mut look = iter.clone();
            matches!(look.next(), Some(TokenTree::Punct(p)) if p.as_char() == ':')
                && matches!(look.next(), Some(TokenTree::Punct(p)) if p.as_char() == ':')
        };

        while let Some(tt) = it.next() {
            match tt {
                TokenTree::Group(g) => {
                    // Recurse inside any (), {}, [] groups; colon run doesn't cross groups.
                    let inner = pass(g.stream(), field, 0);
                    let mut ng = Group::new(g.delimiter(), inner);
                    ng.set_span(g.span());
                    out.push(TokenTree::Group(ng));
                    prev_colon_run = 0;
                }

                TokenTree::Ident(id) if id == field => {
                    // PATH GUARD:
                    //  - do NOT match if previous tokens ended with '::'
                    //  - do NOT match if following tokens start with '::'
                    let prev_was_path_sep = prev_colon_run >= 2;
                    let next_starts_with_path_sep = next_is_colon_colon(&it);

                    if prev_was_path_sep || next_starts_with_path_sep {
                        // Leave as-is.
                        out.push(TokenTree::Ident(id));
                        prev_colon_run = 0;
                        continue;
                    }

                    // Require '=' immediately after the ident
                    let mut saw_equals = false;
                    if let Some(TokenTree::Punct(p)) = it.peek() {
                        if p.as_char() == '=' {
                            saw_equals = true;
                            it.next(); // consume '='
                        }
                    }
                    if !saw_equals {
                        // Leave bare `field<...>` (no rewrite allowed).
                        out.push(TokenTree::Ident(id));
                        prev_colon_run = 0;
                        continue;
                    }

                    // Now require '<' to trigger rewrite; otherwise put '=' back.
                    let has_angle =
                        matches!(it.peek(), Some(TokenTree::Punct(p)) if p.as_char() == '<');
                    if !has_angle {
                        out.push(TokenTree::Ident(id));
                        out.push(TokenTree::Punct(Punct::new('=', Spacing::Alone)));
                        prev_colon_run = 0;
                        continue;
                    }

                    // Consume first '<' and capture until matching outer '>'
                    it.next(); // drop outer '<'
                    let mut captured = Vec::<TokenTree>::new();
                    let mut depth: usize = 0;

                    for next in it.by_ref() {
                        match next {
                            TokenTree::Punct(p) if is_lt_any(&p) => {
                                depth += 1;
                                captured.push(TokenTree::Punct(p)); // keep inner '<'
                            }
                            TokenTree::Punct(p) if is_gt_any(&p) => {
                                if depth == 0 {
                                    // close outer; do not push this '>'
                                    break;
                                } else {
                                    depth -= 1;
                                    captured.push(TokenTree::Punct(p)); // keep inner '>'
                                }
                            }
                            TokenTree::Group(g) => {
                                // Recurse inside nested groups within the capture
                                let inner = pass(g.stream(), field, 0);
                                let mut ng = Group::new(g.delimiter(), inner);
                                ng.set_span(g.span());
                                captured.push(TokenTree::Group(ng));
                            }
                            other => captured.push(other),
                        }
                    }

                    // Emit: ident ( captured )
                    let mut paren = TokenStream::new();
                    paren.extend(captured);
                    out.push(TokenTree::Ident(id));
                    out.push(TokenTree::Group(Group::new(Delimiter::Parenthesis, paren)));
                    prev_colon_run = 0;
                }

                TokenTree::Punct(p) => {
                    // Track runs of ':' to detect '::' BEFORE the next ident.
                    if p.as_char() == ':' {
                        prev_colon_run = (prev_colon_run.saturating_add(1)).min(2);
                    } else {
                        prev_colon_run = 0;
                    }
                    out.push(TokenTree::Punct(p));
                }

                other => {
                    prev_colon_run = 0;
                    out.push(other);
                }
            }
        }

        out.into_iter().collect()
    }

    ts = pass(ts, field_name, 0);
    ts
}

Tests

Click to view tests

#[cfg(test)]
mod test {
    use super::*;
    use crate::syntax::ast::type_list::TypeList;
    use darling::FromMeta;
    use quote::quote;
    use syn::{Attribute, parse_quote};

    mod hand_written_tests {
        use super::*;

        #[derive(FromMeta, Default, PartialEq, Debug)]
        #[darling(default)]
        struct HasGenerics {
            #[darling(multiple)]
            generics: Vec<TypeList>,
        }

        #[test]
        fn test_rewrite_generics_angles() {
            let input = quote! {
                #[foobar(generics = <T, U>)]
            };

            let input = rewrite_generics_angles(input, "generics");

            assert_eq!(
                input.to_string(),
                quote! {
                   #[foobar(generics(T, U))]
                }
                .to_string()
            );
        }

        #[test]
        fn test_rewrite_generics_angles_into_type_list() -> syn::Result<()> {
            let input = quote! {
                #[foobar(generics = <T, U>)]
            };
            let input = rewrite_generics_angles(input, "generics");
            let attr: Attribute = parse_quote!(#input);

            println!("{}", quote! {#attr}); // # [foobar (generics (T , U))]

            let has_generics = HasGenerics::from_meta(&attr.meta)?;
            assert_eq!(
                has_generics,
                HasGenerics {
                    generics: vec![TypeList(vec![parse_quote!(T), parse_quote!(U)])]
                }
            );

            let generics = &has_generics.generics[0];
            println!("generics: {}", quote! { #generics }); // generics: T , U
            Ok(())
        }

        #[test]
        fn nested_types() -> syn::Result<()> {
            let types = quote! { T<A<A<A, B>, B>, B>, U };
            let input = quote! {
                #[foobar(generics = <#types>)]
            };
            let input = rewrite_generics_angles(input, "generics");
            let attr: Attribute = parse_quote!(#input);
            println!("{}", quote! {#attr}); // # [foobar (generics (T < A < A < A , B > , B > , B > , U))]

            let has_generics = HasGenerics::from_meta(&attr.meta)?;
            assert_eq!(
                has_generics,
                HasGenerics {
                    generics: vec![TypeList(vec![
                        parse_quote!(T<A<A<A, B>, B>, B>),
                        parse_quote!(U)
                    ])]
                }
            );

            let generics = &has_generics.generics[0];
            println!("generics: {}", quote! { #generics }); // generics: T < A < A < A , B > , B > , B > , U
            Ok(())
        }

        #[test]
        fn test_rewrite_generics_angles_into_type_lists() -> syn::Result<()> {
            let input = quote! {
                #[foobar(generics = <T, U>, generics = <A, B>)]
            };
            let input = rewrite_generics_angles(input, "generics");
            let attr: Attribute = parse_quote!(#input);

            println!("{}", quote! {#attr}); // # [foobar (generics (T , U) generics (A , B))]

            let has_generics = HasGenerics::from_meta(&attr.meta)?;
            assert_eq!(
                has_generics,
                HasGenerics {
                    generics: vec![
                        TypeList(vec![parse_quote!(T), parse_quote!(U)]),
                        TypeList(vec![parse_quote!(A), parse_quote!(B)])
                    ]
                }
            );

            let generics = &has_generics.generics[0];
            println!("generics: {}", quote! { #generics }); // generics: T , U

            let generics = &has_generics.generics[1];
            println!("generics: {}", quote! { #generics }); // generics: A , B
            Ok(())
        }

        #[test]
        fn no_rewrite() -> syn::Result<()> {
            let og_input = quote! {
                #[foobar(generics(A, B))]
            };
            let input = rewrite_generics_angles(og_input.clone(), "generics");

            assert_eq!(input.to_string(), og_input.to_string());

            let attr: Attribute = parse_quote!(#input);

            println!("{}", quote! {#attr}); // # [foobar (generics (A , B))]

            let has_generics = HasGenerics::from_meta(&attr.meta)?;
            assert_eq!(
                has_generics,
                HasGenerics {
                    generics: vec![TypeList(vec![parse_quote!(A), parse_quote!(B)])]
                }
            );

            let generics = &has_generics.generics[0];
            println!("generics: {}", quote! { #generics }); // generics: A , B
            Ok(())
        }

        #[test]
        fn inside_another_generics() -> syn::Result<()> {
            let input = quote! {
                #[foobar(generics(generics = <T, U>))]
            };
            let input = rewrite_generics_angles(input, "generics");
            assert_eq!(
                input.to_string(),
                quote! { #[foobar(generics(generics(T, U)))] }.to_string()
            );
            Ok(())
        }
    }
    mod generated_tests {
        use super::*;
        use proc_macro2::TokenStream;
        use quote::quote;

        // Normalize a quoted snippet to a comparable string.
        fn s(ts: TokenStream) -> String {
            ts.to_string()
        }

        // Assert helper that compares TokenStream "pretty" forms.
        fn assert_ts_eq(left: TokenStream, right: TokenStream) {
            let l = s(left);
            let r = s(right);
            assert_eq!(l, r, "left:\n{}\n---\nright:\n{}\n", l, r);
        }

        #[test]
        fn rewrites_equals_form_simple() {
            let input = quote!(foo(generics = <T, U>));
            let out = rewrite_generics_angles(input, "generics");
            let expect = quote!(foo(generics(T, U)));
            assert_ts_eq(out, expect);
        }

        #[test]
        fn no_rewrites_angle_form_simple() {
            let input = quote!(foo(generics<T, U>));
            let out = rewrite_generics_angles(input, "generics");
            let expect = quote!(foo(generics<T, U>));
            assert_ts_eq(out, expect);
        }

        #[test]
        fn preserves_nested_generics_inner_angles() {
            let input = quote!(foo(generics = <A, Map<K, V>, Foo<Bar<Baz>>));
            let out = rewrite_generics_angles(input, "generics");
            // Outer <...> dropped, inner <...> preserved
            let expect = quote!(foo(generics(A, Map<K, V>, Foo<Bar<Baz>>)));
            assert_ts_eq(out, expect);
        }

        #[test]
        fn handles_trailing_comma_and_empty() {
            // Trailing comma
            let input = quote!(foo(generics = <T, U,>));
            let out = rewrite_generics_angles(input, "generics");
            let expect = quote!(foo(generics(T, U,)));
            assert_ts_eq(out, expect);

            // Empty list
            let input2 = quote!(foo(generics = <>));
            let out2 = rewrite_generics_angles(input2, "generics");
            let expect2 = quote!(foo(generics()));
            assert_ts_eq(out2, expect2);
        }

        #[test]
        fn leaves_other_fields_alone() {
            let input = quote!(foo(targets = <derive>, other<Thing>));
            let out = rewrite_generics_angles(input.clone(), "generics");
            assert_ts_eq(out, input);
        }

        #[test]
        fn works_inside_groups_and_multiple_occurrences() {
            let input = quote!({
                foo(generics = <T> , x = 1);
                (foo(generics = <T<'a>, U>));
                [foo(other = 3, generics = <Nested<Ok>>)];
            });
            let out = rewrite_generics_angles(input.clone(), "generics");
            let expect = quote!({
                foo(generics(T) , x = 1);
                (foo(generics(T<'a>, U)));
                [foo(other = 3, generics(Nested<Ok>))];
            });
            assert_ts_eq(out, expect);
        }

        #[test]
        fn equals_without_angle_is_restored() {
            // We consume '=', but if no '<' follows, we must put it back.
            let input = quote!(foo(generics = path::value, y));
            let out = rewrite_generics_angles(input.clone(), "generics");
            assert_ts_eq(out, input);
        }

        #[test]
        fn malformed_unbalanced_angles_do_not_panic() {
            // Missing closing '>'
            let input = quote!(foo(generics = <T, U, Foo<Bar>));
            let out = rewrite_generics_angles(input.clone(), "generics");
            // We don't strictly define behavior, just ensure it's stable and contains original tokens.
            // A simple check: string contains "generics", "<", and no panic occurred.
            let s = out.to_string();
            assert!(s.contains("generics"));
            assert!(s.contains("<"));
        }

        #[test]
        fn unrelated_idents_that_match_prefix_are_not_touched() {
            // Only exact ident "generics" should match, not "generics2" or "::generics"
            let input = quote!(foo(generics2 = <Bad>, ::generics = <Bad>, generics = <Good>));
            let out = rewrite_generics_angles(input.clone(), "generics");
            let expect = quote!(foo(generics2 = <Bad>, ::generics = <Bad>, generics(Good)));
            assert_ts_eq(out, expect);
        }

        #[test]
        fn tolerates_weird_spacing_and_joint_punct() {
            // Make sure joint punct like '<<' or '>>' in other contexts don't break us.
            // (Our is_lt / is_gt excludes joint puncts.)
            let input = quote!(foo(generics = < A<<B as C>::D > >, other >> 2));
            let out = rewrite_generics_angles(input.clone(), "generics");
            let expect = quote!(foo(generics( A<<B as C>::D > ), other >> 2));
            assert_ts_eq(out, expect);
        }

        #[test]
        fn string_literals_are_untouched() {
            // The preprocessor operates on tokens, so string literal contents are not parsed/modified.
            let input = quote!(foo(name = "generics<T, U>", generics = <T, U>));
            let out = rewrite_generics_angles(input.clone(), "generics");
            let expect = quote!(foo(name = "generics<T, U>", generics(T, U)));
            assert_ts_eq(out, expect);
        }
    }
}

---

Basically, preprocess the tokens before passing to syn or darling. So that way you can keep the generics = <...> for those that prefer it and also support generics(...)