builders 0.5.0

Rust macros for building structs
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

mod util;
#[cfg(feature = "builder")]
mod builder;

use proc_macro::TokenStream;
use proc_macro2::TokenTree;
use syn::{Meta, MetaList};

#[cfg(feature = "builder")]
#[proc_macro_derive(Builder, attributes(builder))]
pub fn builder_derive(input: TokenStream) -> TokenStream {
    builder::builder_derive_impl(input)
}


#[cfg(feature = "getters")]
#[proc_macro_derive(Getters, attributes(getter,getters))]
pub fn getters_derive(input: TokenStream) -> TokenStream {
    use quote::quote;
    use syn::{parse_macro_input, DeriveInput};
    let ast = parse_macro_input!(input as DeriveInput);

    let prefix = util::get_prefix(&ast.attrs, "get_", "getters");

    util::gen_for_each_field(&ast, "getter", &prefix, |field,_each| {
        let ident = util::get_field_ident(field);
        let ty = &field.ty;
        quote! {
            (&self) -> & #ty {
                & self.#ident
            }
        }
    })
}

#[cfg(feature = "setters")]
#[proc_macro_derive(Setters, attributes(setter,setters))]
pub fn setters_derive(input: TokenStream) -> TokenStream {
    use syn::{parse_macro_input, DeriveInput};

    let ast = parse_macro_input!(input as DeriveInput);
    let prefix = util::get_prefix(&ast.attrs, "set_", "setters");

    util::gen_for_each_field(&ast, "setter", &prefix, |field,_each| {
        let ident = util::get_field_ident(field);
        let ty = &field.ty;
        quote::quote! {
            (&mut self, #ident: impl ::core::convert::Into<#ty>) {
                self.#ident = #ident.into();
            }
        }
    })
}

#[cfg(feature = "constructor")]
mod constructor;

#[cfg(feature = "constructor")]
#[proc_macro_derive(Constructor, attributes(constructor))]
pub fn constructor_derive(input: TokenStream) -> TokenStream {
    constructor::constructor_derive_impl(input)
}


#[cfg(feature = "as_box")]
#[proc_macro_derive(AsBox)]
pub fn auto_box_derive(input: TokenStream) -> TokenStream {
    use syn::parse_macro_input;

    let ast = parse_macro_input!(input as syn::DeriveInput);
    let ident = &ast.ident;
    let vis = &ast.vis;
    let generics = &ast.generics;
    let stripped = util::get_stripped_generics(generics, false);
    let wher = &generics.where_clause;

    quote::quote! {
        extern crate alloc;

        impl #generics #ident #stripped #wher {
            #vis fn as_box(self) -> ::alloc::boxed::Box<#ident #stripped> {
                std::boxed::Box::new(self)
            }
        }
    }.into()
}

#[cfg(feature = "into_enum")]
#[proc_macro_derive(IntoEnum, attributes(into_enum))]
pub fn wrap_enum_derive(input: TokenStream) -> TokenStream {
    let ast = syn::parse_macro_input!(input as syn::DeriveInput);
    let ident = &ast.ident;
    let generics = &ast.generics;
    let stripped = util::get_stripped_generics(generics, false);
    let wher = &generics.where_clause;

    let mut enum_name = None;
    let mut field_name = ident.clone();

    for attr in ast.attrs {
        if let Meta::List(MetaList { ref tokens, .. }) = attr.meta {
            let mut tokens = tokens.clone().into_iter();

            loop {
                let Some(key) = tokens.next() else { break };
                let TokenTree::Ident(ref name) = key else { panic!("Expected ident, found {key:#?}") };
                match tokens.next().unwrap() {
                    TokenTree::Punct(ref p) => assert_eq!(p.as_char(), '='),
                    tt => panic!("Expected '=', found: {tt}"),
                }
                let val = tokens.next().unwrap();
                let TokenTree::Ident(ref val) = val else { panic!("Expected ident, found {val:#?}") };

                if name == "enum_name" {
                    enum_name = Some(val.clone());
                }
                if name == "field" {
                    field_name = val.clone();
                }

                if let Some(key) = tokens.next() {
                    let TokenTree::Punct(ref name) = key else { panic!("Expected ',', found {key:#?}") };
                    if name.as_char() == ',' {
                        continue;
                    } else {
                        panic!()
                    }
                }
            }
        }
    }

    let enum_name = enum_name.unwrap();

    quote::quote! {
        impl #generics From<#ident #stripped> for #enum_name #wher {
            fn from(value: #ident #stripped) -> Self {
                #enum_name :: #field_name (value)
            }
        }
    }.into()
}