derive_fn 0.1.1

Macro to implement all three Fn traits
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

use proc_macro::TokenStream;
use quote::quote;
use syn::{Attribute, DeriveInput, MetaList, parse};

#[proc_macro_derive(Fn, attributes(option))]
pub fn derive_fn_mut(input: TokenStream) -> TokenStream {
    let ast = parse(input).unwrap();
    impl_fn(&ast)
}

fn find_attr(attributes: &[Attribute], wanted_attribute: &str) -> Attribute {
    attributes
        .iter()
        .find(|attr| attr.path().is_ident(wanted_attribute))
        .expect("No attribute of type {wanted_attribute} given")
        .clone()
}

fn impl_fn(ast: &DeriveInput) -> TokenStream {
    let name = &ast.ident;
    let args_attr = find_attr(&ast.attrs, "fn_args");
    let MetaList {
        tokens: arg_tokens, ..
    } = args_attr.meta.require_list().unwrap();
    let arg_size = arg_tokens.clone().into_iter().count().div_ceil(2);
    let args: proc_macro2::TokenStream = (0..arg_size)
        .map(|index| format!("args.{index}"))
        .collect::<Vec<_>>()
        .join(",")
        .parse()
        .unwrap();

    let body_attr = find_attr(&ast.attrs, "fn_body");
    let MetaList {
        tokens: body_tokens,
        ..
    } = body_attr.meta.require_list().unwrap();

    let output_attr = find_attr(&ast.attrs, "fn_output");
    let MetaList {
        tokens: output_tokens,
        ..
    } = output_attr.meta.require_list().unwrap();

    let generated = quote! {
        impl FnOnce<(#arg_tokens)> for #name {
            type Output = #output_tokens;
            extern "rust-call" fn call_once(self, args: (#arg_tokens)) -> Self::Output {
                self(#args)
            }
        }
        impl FnMut<(#arg_tokens)> for #name {
            extern "rust-call" fn call_mut(&mut self, args: (#arg_tokens)) -> Self::Output {
                self(#args)
            }
        }
        impl Fn<(#arg_tokens)> for #name {
            extern "rust-call" fn call(&self, args: (#arg_tokens)) -> Self::Output {
                #body_tokens
            }
        }

    };
    generated.into()
}

#[proc_macro_attribute]
pub fn fn_args(_: TokenStream, item: TokenStream) -> TokenStream {
    item
}

#[proc_macro_attribute]
pub fn fn_body(_: TokenStream, item: TokenStream) -> TokenStream {
    item
}

#[proc_macro_attribute]
pub fn fn_output(_: TokenStream, item: TokenStream) -> TokenStream {
    item
}