iter_variants_derive 0.1.2

Derive macros for iterating over all variants of a rust struct/enum
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use proc_macro as pm;
use proc_macro2::{self as pm2, Span};
use quote::{format_ident, quote};
use syn::{parse_macro_input, Data, DeriveInput, Fields, Ident};

fn do_fields(fields: &Fields, ident: pm2::TokenStream) -> pm2::TokenStream {
    match fields {
        Fields::Unnamed(fields_unnamed) => {
            let vs = (0..fields_unnamed.unnamed.len()).map(|i| format_ident!("v{}", i));
            let mut result = {
                let vs = vs.clone();
                quote! {
                    f(#ident(#(#vs,)*))
                }
            };
            for (field, v) in fields_unnamed.unnamed.iter().zip(vs) {
                let ty = &field.ty;
                result = quote! {
                    #ty::iter_variants(|#v| #result)
                }
            }
            result
        }
        Fields::Named(fields_named) => {
            let idents: Vec<_> = fields_named
                .named
                .iter()
                .map(|field| field.ident.clone())
                .collect();
            let mut result = quote! {
                f(#ident {
                    #(#idents,)*
                })
            };
            for field in &fields_named.named {
                let ident = field.ident.clone();
                let ty = field.ty.clone();
                result = quote! {
                    #ty::iter_variants(|#ident| #result)
                }
            }
            result
        }
        Fields::Unit => quote! {
            f(#ident)
        },
    }
}

#[proc_macro_derive(IterVariants)]
pub fn iter_variants_derive(input: pm::TokenStream) -> pm::TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let ident = input.ident;

    let output = match input.data {
        Data::Enum(data_enum) => {
            let arms = data_enum.variants.iter().map(|variant| {
                let variant_ident = &variant.ident;
                do_fields(&variant.fields, quote! {Self::#variant_ident})
            });

            quote! {
                #(#arms;)*
            }
        }
        Data::Struct(data_struct) => {
            let ident = ident.clone();
            do_fields(&data_struct.fields, quote! { #ident })
        }
        _ => syn::Error::new_spanned(&ident, "`Name` can only be derived for enums or structs")
            .to_compile_error(),
    };

    let expanded = quote! {
        impl IterVariants for #ident {
            type IterVariantsInput = Self;
            fn iter_variants<F: Fn(Self::IterVariantsInput)>(f: F) {
                #output
            }
        }
    };

    pm::TokenStream::from(expanded)
}

#[proc_macro]
pub fn impl_iter_variants_tuple(_input: pm::TokenStream) -> pm::TokenStream {
    let output = (0..=12).map(|n| {
        let vs = (0..n).map(|i| Ident::new(&format!("v{}", i), Span::call_site()));
        let v_types: Vec<_> = (0..n).map(|i| Ident::new(&format!("V{}", i), Span::call_site())).collect();
        let mut result = {
            let vs = vs.clone();
            quote! {
                f((#(#vs,)*))
            }
        };
        {
            let v_types = v_types.clone();
            for (v_type, v) in v_types.iter().zip(vs) {
                result = quote! {
                    #v_type::iter_variants(|#v| #result)
                }
            }
        }
        quote! {
            impl<#(#v_types: IterVariants,)*> IterVariants for (#(#v_types,)*)
            where
                #(<#v_types as IterVariants>::IterVariantsInput: IterVariants + Copy,)*
            {
                type IterVariantsInput = (#(<#v_types as IterVariants>::IterVariantsInput,)*);
                fn iter_variants<F: Fn(Self::IterVariantsInput)>(f: F) {
                    #result
                }
            }
        }
    });

    pm::TokenStream::from(quote! {
        #(#output)*
    })
}