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
use super::*;
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct MacroInput {
pub ident: Ident,
pub vis: Visibility,
pub attrs: Vec<Attribute>,
pub generics: Generics,
pub body: Body,
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum Body {
Enum(Vec<Variant>),
Struct(VariantData),
}
#[cfg(feature = "parsing")]
pub mod parsing {
use super::*;
use attr::parsing::attribute;
use data::parsing::{visibility, struct_body, enum_body};
use generics::parsing::generics;
use ident::parsing::ident;
use nom::multispace;
named!(pub macro_input -> MacroInput, do_parse!(
attrs: many0!(attribute) >>
vis: visibility >>
which: alt!(punct!("struct") | punct!("enum")) >>
multispace >>
id: ident >>
generics: generics >>
item: switch!(value!(which),
"struct" => map!(struct_body, move |body| MacroInput {
ident: id,
vis: vis,
attrs: attrs,
generics: generics,
body: Body::Struct(body),
})
|
"enum" => map!(enum_body, move |body| MacroInput {
ident: id,
vis: vis,
attrs: attrs,
generics: generics,
body: Body::Enum(body),
})
) >>
option!(multispace) >>
(item)
));
}
#[cfg(feature = "printing")]
mod printing {
use super::*;
use data::{Visibility, VariantData};
use quote::{Tokens, ToTokens};
impl ToTokens for MacroInput {
fn to_tokens(&self, tokens: &mut Tokens) {
for attr in &self.attrs {
attr.to_tokens(tokens);
}
if let Visibility::Public = self.vis {
tokens.append("pub");
}
match self.body {
Body::Enum(_) => tokens.append("enum"),
Body::Struct(_) => tokens.append("struct"),
}
self.ident.to_tokens(tokens);
self.generics.to_tokens(tokens);
self.generics.where_clause.to_tokens(tokens);
self.body.to_tokens(tokens);
}
}
impl ToTokens for Body {
fn to_tokens(&self, tokens: &mut Tokens) {
match *self {
Body::Enum(ref variants) => {
tokens.append("{");
for variant in variants {
variant.to_tokens(tokens);
tokens.append(",");
}
tokens.append("}");
}
Body::Struct(ref variant_data) => {
variant_data.to_tokens(tokens);
match *variant_data {
VariantData::Struct(_) => { }
VariantData::Tuple(_) |
VariantData::Unit => tokens.append(";"),
}
}
}
}
}
}