boring-derive 0.1.1

Derive macros for some common patterns
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

use syn::{punctuated::Punctuated, Token};

use super::{context::Context, data::Data};
use crate::core::data::{Field, Style, Variant};

pub trait AttrContainer {
    fn from_ast(cx: &Context, item: &syn::DeriveInput) -> Self;
}

pub trait AttrVariant {
    fn from_ast(cx: &Context, variant: &syn::Variant) -> Self;
}

pub trait AttrField {
    fn from_ast(cx: &Context, index: usize, field: &syn::Field) -> Self;
}

// parsing the ast into the data structure and the attributes
#[allow(dead_code)]
pub struct Container<'a, F, V, C>
where
    F: AttrField,
    V: AttrVariant,
    C: AttrContainer,
{
    pub ident: syn::Ident,
    pub attrs: C,
    pub data: Data<'a, F, V>,
    pub generics: &'a syn::Generics,
    pub original: &'a syn::DeriveInput,
}

impl<'a, F, V, C> Container<'a, F, V, C>
where
    F: AttrField,
    V: AttrVariant,
    C: AttrContainer,
{
    pub fn from_ast(cx: &Context, item: &'a syn::DeriveInput) -> Option<Container<'a, F, V, C>> {
        let attrs = C::from_ast(cx, item);
        let data = match &item.data {
            syn::Data::Struct(data) => {
                let (style, fields) = struct_from_ast(cx, &data.fields);
                Data::Struct(style, fields)
            }
            syn::Data::Enum(data) => Data::Enum(enum_from_ast(cx, &data.variants)),
            syn::Data::Union(data) => Data::Union(union_from_ast(cx, &data.fields)),
        };

        let item = Container {
            ident: item.ident.clone(),
            attrs,
            data,
            generics: &item.generics,
            original: item,
        };
        Some(item)
    }
}

fn enum_from_ast<'a, F, V>(
    cx: &Context,
    variants: &'a Punctuated<syn::Variant, Token![,]>,
) -> Vec<Variant<'a, F, V>>
where
    F: AttrField,
    V: AttrVariant,
{
    let variants: Vec<_> = variants
        .iter()
        .map(|variant| {
            let attrs = V::from_ast(cx, variant);
            let (style, fields) = struct_from_ast(cx, &variant.fields);
            Variant {
                ident: variant.ident.clone(),
                attrs,
                style,
                fields,
                original: variant,
            }
        })
        .collect();

    variants
}

fn struct_from_ast<'a, A>(cx: &Context, fields: &'a syn::Fields) -> (Style, Vec<Field<'a, A>>)
where
    A: AttrField,
{
    match fields {
        syn::Fields::Unit => (Style::Unit, Vec::new()),
        syn::Fields::Unnamed(fields) if fields.unnamed.len() == 1 => {
            (Style::Newtype, fields_from_ast(cx, &fields.unnamed))
        }
        syn::Fields::Unnamed(fields) => (Style::Tuple, fields_from_ast(cx, &fields.unnamed)),
        syn::Fields::Named(fields) => (Style::Struct, fields_from_ast(cx, &fields.named)),
    }
}

fn union_from_ast<'a, A>(cx: &Context, fields: &'a syn::FieldsNamed) -> Vec<Field<'a, A>>
where
    A: AttrField,
{
    fields_from_ast(cx, &fields.named)
}

fn fields_from_ast<'a, A>(
    cx: &Context,
    fields: &'a Punctuated<syn::Field, Token![,]>,
) -> Vec<Field<'a, A>>
where
    A: AttrField,
{
    fields
        .iter()
        .enumerate()
        .map(|(i, field)| Field {
            member: match &field.ident {
                Some(ident) => syn::Member::Named(ident.clone()),
                None => syn::Member::Unnamed(i.into()),
            },
            attrs: A::from_ast(cx, i, field),
            ty: &field.ty,
            original: field,
        })
        .collect()
}