getset2 0.4.0

Getset2 is a derive macro, which is inspired by getset, is designed for generating the most basic getters and setters on struct fields.
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use crate::parse_attr;
use proc_macro2::{Ident, Span, TokenStream as TokenStream2};
use proc_macro_error2::abort;
use quote::quote;
use std::collections::HashSet;
use syn::{self, ext::IdentExt, spanned::Spanned, token::Const, Field, Visibility};

use self::GenMode::{GetCopy, GetMut, GetRef, Set, SetWith};

#[derive(Clone)]
pub struct GenParams {
    pub mode: GenMode,
    pub vis: Option<Visibility>,
    pub is_const: Option<bool>,
}

#[derive(PartialEq, Eq, Hash, Copy, Clone)]
pub enum GenMode {
    GetRef,
    GetCopy,
    GetMut,
    Set,
    SetWith,
}

impl GenMode {
    pub fn list() -> [GenMode; 5] {
        [
            GenMode::GetRef,
            GenMode::GetCopy,
            GenMode::GetMut,
            GenMode::Set,
            GenMode::SetWith,
        ]
    }

    pub fn prefix(self) -> &'static str {
        match self {
            GetRef | GetCopy | GetMut => "",
            Set => "set_",
            SetWith => "with_",
        }
    }

    pub fn suffix(self) -> &'static str {
        match self {
            GetRef | GetCopy | Set | SetWith => "",
            GetMut => "_mut",
        }
    }
}

pub fn implement(field: &Field, global_params: &[GenParams]) -> TokenStream2 {
    let mut ts = TokenStream2::new();
    let (mut params_list, skip_list) = if let Some(attr) = field
        .attrs
        .iter()
        .find(|attr| attr.path().is_ident("getset2"))
    {
        parse_attr(attr)
    } else {
        (global_params.to_vec(), HashSet::new())
    };
    let had_ref_copy = params_list
        .iter()
        .any(|p| matches!(p.mode, GenMode::GetRef | GenMode::GetCopy));
    for params in global_params {
        if (!skip_list.contains(&params.mode) && params_list.iter().all(|p| p.mode != params.mode))
            && (!had_ref_copy || !matches!(params.mode, GenMode::GetRef | GenMode::GetCopy))
        {
            params_list.push(params.clone());
        }
    }
    for mut params in params_list {
        params.vis = params.vis.or_else(|| Some(field.vis.clone()));
        ts.extend(gen_method(field, params));
    }
    ts
}

pub fn gen_method(field: &Field, params: GenParams) -> TokenStream2 {
    let field_name = field
        .ident
        .clone()
        .unwrap_or_else(|| abort!(field.span(), "Expected the field to have a name"));

    let fn_name = if params.mode.prefix().is_empty() && params.mode.suffix().is_empty() {
        field_name.clone()
    } else {
        Ident::new(
            &format!(
                "{}{}{}",
                params.mode.prefix(),
                field_name.unraw(),
                params.mode.suffix()
            ),
            Span::call_site(),
        )
    };
    let ty = field.ty.clone();

    let doc = field.attrs.iter().filter(|v| v.meta.path().is_ident("doc"));

    let visibility = params.vis;
    let const_kw: Option<Const> = params.is_const.and_then(|is_const| {
        if is_const {
            Some(Const::default())
        } else {
            None
        }
    });

    match params.mode {
        GenMode::GetRef => {
            quote! {
                #(#doc)*
                #[inline(always)]
                #visibility #const_kw fn #fn_name(&self) -> &#ty {
                    &self.#field_name
                }
            }
        }
        GenMode::GetCopy => {
            quote! {
                #(#doc)*
                #[inline(always)]
                #visibility #const_kw fn #fn_name(&self) -> #ty {
                    self.#field_name
                }
            }
        }
        GenMode::GetMut => {
            quote! {
                #(#doc)*
                #[inline(always)]
                #visibility #const_kw fn #fn_name(&mut self) -> &mut #ty {
                    &mut self.#field_name
                }
            }
        }
        GenMode::Set => {
            quote! {
                #(#doc)*
                #[inline(always)]
                #visibility #const_kw fn #fn_name(&mut self, val: #ty) -> &mut Self {
                    self.#field_name = val;
                    self
                }
            }
        }
        GenMode::SetWith => {
            quote! {
                #(#doc)*
                #[inline(always)]
                #visibility #const_kw fn #fn_name(mut self, val: #ty) -> Self {
                    self.#field_name = val;
                    self
                }
            }
        }
    }
}