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
use syn;
use Ctxt;
#[derive(Debug)]
pub struct Container<'a> {
pub ident: syn::Ident,
pub body: Body<'a>,
pub generics: &'a syn::Generics,
}
#[derive(Debug)]
pub enum Body<'a> {
Enum(Vec<Variant<'a>>),
Struct(Style, Vec<Field<'a>>),
}
#[derive(Debug)]
pub struct Variant<'a> {
pub ident: syn::Ident,
pub style: Style,
pub fields: Vec<Field<'a>>,
}
#[derive(Debug)]
pub struct Field<'a> {
pub ident: Option<syn::Ident>,
pub ty: &'a syn::Ty,
}
#[derive(Copy, Clone, Debug)]
pub enum Style {
Struct,
Tuple,
Newtype,
Unit,
}
impl<'a> Container<'a> {
pub fn from_ast(_cx: &Ctxt, item: &'a syn::DeriveInput) -> Container<'a> {
let body = match item.body {
syn::Body::Enum(ref variants) => Body::Enum(enum_from_ast(variants)),
syn::Body::Struct(ref variant_data) => {
let (style, fields) = struct_from_ast(variant_data);
Body::Struct(style, fields)
}
};
let item = Container {
ident: item.ident.clone(),
body: body,
generics: &item.generics,
};
item
}
}
fn enum_from_ast<'a>(variants: &'a [syn::Variant]) -> Vec<Variant<'a>> {
variants
.iter()
.map(
|variant| {
let (style, fields) = struct_from_ast(&variant.data);
Variant {
ident: variant.ident.clone(),
style: style,
fields: fields,
}
}
)
.collect()
}
fn struct_from_ast<'a>( data: &'a syn::VariantData) -> (Style, Vec<Field<'a>>) {
match *data {
syn::VariantData::Struct(ref fields) => (Style::Struct, fields_from_ast(fields)),
syn::VariantData::Tuple(ref fields) if fields.len() == 1 => {
(Style::Newtype, fields_from_ast(fields))
}
syn::VariantData::Tuple(ref fields) => (Style::Tuple, fields_from_ast( fields)),
syn::VariantData::Unit => (Style::Unit, Vec::new()),
}
}
fn fields_from_ast<'a>(fields: &'a [syn::Field]) -> Vec<Field<'a>> {
fields
.iter()
.map(
|field| {
Field {
ident: field.ident.clone(),
ty: &field.ty,
}
},
)
.collect()
}