structify-derive 0.1.0

A procedural macro to transform functions into structs with state and execution dependencies
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

use convert_case::{Case, Casing};
use proc_macro::TokenStream;
use syn::{parse::Parser, parse_macro_input, ItemFn};

fn is_dependency_type(ty: &syn::Type) -> bool {
    if let syn::Type::Path(type_path) = ty {
        if let Some(segment) = type_path.path.segments.last() {
            return segment.ident == "Dep";
        }
    }
    false
}

fn get_struct_name_ident(attr: &TokenStream, input_fn: &syn::ItemFn) -> syn::Ident {
    let fn_name_str = input_fn.sig.ident.to_string();

    let default_struct_name = fn_name_str.to_case(Case::Pascal).to_string();

    if let Ok(args) = syn::punctuated::Punctuated::<syn::Path, syn::Token![,]>::parse_terminated
        .parse(attr.clone())
    {
        if args.is_empty() {
            return syn::Ident::new(&default_struct_name, proc_macro2::Span::call_site());
        }
        if args.len() > 1 {
            panic!("Expected exactly one for struct name #[structify(StructName)]");
        }
        syn::Ident::new(
            &args[0].get_ident().unwrap().to_string(),
            proc_macro2::Span::call_site(),
        )
    } else {
        panic!("expected only a punctuated path");
    }
}

#[proc_macro_attribute]
pub fn structify(_attr: TokenStream, item: TokenStream) -> TokenStream {
    let input_fn = parse_macro_input!(item as ItemFn);

    let struct_name_ident = get_struct_name_ident(&_attr, &input_fn);

    let mut fields = Vec::new();
    let mut execute_bindings = Vec::new();
    let mut new_struct_fields = Vec::new();
    let mut execute_args = vec![quote::quote! {&self}];

    let asyncness = match input_fn.sig.asyncness {
        Some(_) => quote::quote! {async},
        None => quote::quote! {},
    };

    for arg in input_fn.sig.inputs.iter() {
        match arg {
            syn::FnArg::Typed(pat_type) => {
                let pat = pat_type.pat.clone();
                let ty = pat_type.ty.clone();
                if is_dependency_type(&pat_type.ty) {
                    execute_args.push(quote::quote! { #pat: impl Into<#ty> });
                    execute_bindings.push(quote::quote! {
                        let #pat = #pat.into();
                    });
                } else {
                    fields.push(quote::quote! {
                        #pat: #ty
                    });
                    execute_bindings.push(quote::quote! {
                        let #pat = &self.#pat;
                    });
                    new_struct_fields.push(quote::quote! {
                        #pat: #pat
                    });
                }
            }
            syn::FnArg::Receiver(_) => {
                panic!("Receiver arguments are not supported");
            }
        }
    }

    let block = input_fn.block.clone();

    let ret_ty = match &input_fn.sig.output {
        syn::ReturnType::Default => quote::quote! { () },
        syn::ReturnType::Type(_, ty) => quote::quote! { #ty },
    };

    quote::quote! {
        #[allow(unused)]
        #input_fn

        pub struct #struct_name_ident {
            #(#fields),*
        }

        impl #struct_name_ident {
            pub fn new(#(#fields),*) -> Self {
                Self {
                    #(#new_struct_fields),*
                }
            }
            pub #asyncness fn execute(#(#execute_args),*) -> #ret_ty {
                #(#execute_bindings)*
                #block
            }
        }
    }
    .into()
}