rand-gen-proc-macro 0.1.1

Proc macros for the rand-gen crate
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

use proc_macro2::Ident;
use quote::ToTokens;
use syn::Type;

#[derive(Debug, FromDeriveInput)]
#[darling(attributes(rand_gen), supports(struct_any))]
pub(crate) struct RandGenReceiver {
    ident: syn::Ident,
    generics: syn::Generics,
    data: darling::ast::Data<(), RandGenField>,
}

impl ToTokens for RandGenReceiver {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        let RandGenReceiver {
            ref ident,
            ref generics,
            ref data,
        } = *self;

        let (imp, ty, wher) = generics.split_for_impl();
        let fields = data
            .as_ref()
            .take_struct()
            .expect("Should never be enum")
            .fields;

        let result = fields.iter().map(|x| {
            let ident = x.ident.clone();
            let ty = x.ty.clone();
            let code = match x.method.clone() {
                Some(method) => quote! {#method(rng)},
                None => {
                    quote! {
                        #ty::random(rng)
                    }
                }
            };
            quote! {
                #ident: #code
            }
        });

        tokens.extend(quote! {
            impl #imp RandGen for #ident #ty #wher {
                fn random<R: Rng + ?Sized>(rng: &mut R) -> Self {
                    Self {
                        #(#result),*
                    }
                }
            }
        });
    }
}

#[derive(Debug, FromField)]
#[darling(attributes(rand_gen))]
pub(crate) struct RandGenField {
    ident: Option<syn::Ident>,
    ty: Type,
    method: Option<Ident>, // The Method to the optional custom_method that will run when generating the random
}