1use crate::attr::Attribute;
2use crate::data::{Fields, FieldsNamed, Variant};
3use crate::generics::Generics;
4use crate::ident::Ident;
5use crate::punctuated::Punctuated;
6use crate::restriction::Visibility;
7use crate::token;
8
9ast_struct! {
10 /// Data structure sent to a `proc_macro_derive` macro.
11 #[cfg_attr(docsrs, doc(cfg(feature = "derive")))]
12 pub struct DeriveInput {
13 pub attrs: Vec<Attribute>,
14 pub vis: Visibility,
15 pub ident: Ident,
16 pub generics: Generics,
17 pub data: Data,
18 }
19}
20
21ast_enum! {
22 /// The storage of a struct, enum or union data structure.
23 ///
24 /// # Syntax tree enum
25 ///
26 /// This type is a [syntax tree enum].
27 ///
28 /// [syntax tree enum]: crate::expr::Expr#syntax-tree-enums
29 #[cfg_attr(docsrs, doc(cfg(feature = "derive")))]
30 pub enum Data {
31 Struct(DataStruct),
32 Enum(DataEnum),
33 Union(DataUnion),
34 }
35}
36
37ast_struct! {
38 /// A struct input to a `proc_macro_derive` macro.
39 #[cfg_attr(docsrs, doc(cfg(feature = "derive")))]
40 pub struct DataStruct {
41 pub struct_token: Token![struct],
42 pub fields: Fields,
43 pub semi_token: Option<Token![;]>,
44 }
45}
46
47ast_struct! {
48 /// An enum input to a `proc_macro_derive` macro.
49 #[cfg_attr(docsrs, doc(cfg(feature = "derive")))]
50 pub struct DataEnum {
51 pub enum_token: Token![enum],
52 pub brace_token: token::Brace,
53 pub variants: Punctuated<Variant, Token![,]>,
54 }
55}
56
57ast_struct! {
58 /// An untagged union input to a `proc_macro_derive` macro.
59 #[cfg_attr(docsrs, doc(cfg(feature = "derive")))]
60 pub struct DataUnion {
61 pub union_token: Token![union],
62 pub fields: FieldsNamed,
63 }
64}
65
66#[cfg(feature = "parsing")]
67pub(crate) mod parsing {
68 use crate::attr::Attribute;
69 use crate::data::{Fields, FieldsNamed, Variant};
70 use crate::derive::{Data, DataEnum, DataStruct, DataUnion, DeriveInput};
71 use crate::error::Result;
72 use crate::generics::{Generics, WhereClause};
73 use crate::ident::Ident;
74 use crate::parse::{Parse, ParseStream};
75 use crate::punctuated::Punctuated;
76 use crate::restriction::Visibility;
77 use crate::token;
78
79 #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
80 impl Parse for DeriveInput {
81 fn parse(input: ParseStream) -> Result<Self> {
82 let attrs = input.call(Attribute::parse_outer)?;
83 let vis = input.parse::<Visibility>()?;
84
85 let lookahead = input.lookahead1();
86 if lookahead.peek(Token![struct]) {
87 let struct_token = input.parse::<Token![struct]>()?;
88 let ident = input.parse::<Ident>()?;
89 let generics = input.parse::<Generics>()?;
90 let (where_clause, fields, semi) = data_struct(input)?;
91 Ok(DeriveInput {
92 attrs,
93 vis,
94 ident,
95 generics: Generics {
96 where_clause,
97 ..generics
98 },
99 data: Data::Struct(DataStruct {
100 struct_token,
101 fields,
102 semi_token: semi,
103 }),
104 })
105 } else if lookahead.peek(Token![enum]) {
106 let enum_token = input.parse::<Token![enum]>()?;
107 let ident = input.parse::<Ident>()?;
108 let generics = input.parse::<Generics>()?;
109 let (where_clause, brace, variants) = data_enum(input)?;
110 Ok(DeriveInput {
111 attrs,
112 vis,
113 ident,
114 generics: Generics {
115 where_clause,
116 ..generics
117 },
118 data: Data::Enum(DataEnum {
119 enum_token,
120 brace_token: brace,
121 variants,
122 }),
123 })
124 } else if lookahead.peek(Token![union]) {
125 let union_token = input.parse::<Token![union]>()?;
126 let ident = input.parse::<Ident>()?;
127 let generics = input.parse::<Generics>()?;
128 let (where_clause, fields) = data_union(input)?;
129 Ok(DeriveInput {
130 attrs,
131 vis,
132 ident,
133 generics: Generics {
134 where_clause,
135 ..generics
136 },
137 data: Data::Union(DataUnion {
138 union_token,
139 fields,
140 }),
141 })
142 } else {
143 Err(lookahead.error())
144 }
145 }
146 }
147
148 pub(crate) fn data_struct(
149 input: ParseStream,
150 ) -> Result<(Option<WhereClause>, Fields, Option<Token![;]>)> {
151 let mut lookahead = input.lookahead1();
152 let mut where_clause = None;
153 if lookahead.peek(Token![where]) {
154 where_clause = Some(input.parse()?);
155 lookahead = input.lookahead1();
156 }
157
158 if where_clause.is_none() && lookahead.peek(token::Paren) {
159 let fields = input.parse()?;
160
161 lookahead = input.lookahead1();
162 if lookahead.peek(Token![where]) {
163 where_clause = Some(input.parse()?);
164 lookahead = input.lookahead1();
165 }
166
167 if lookahead.peek(Token![;]) {
168 let semi = input.parse()?;
169 Ok((where_clause, Fields::Unnamed(fields), Some(semi)))
170 } else {
171 Err(lookahead.error())
172 }
173 } else if lookahead.peek(token::Brace) {
174 let fields = input.parse()?;
175 Ok((where_clause, Fields::Named(fields), None))
176 } else if lookahead.peek(Token![;]) {
177 let semi = input.parse()?;
178 Ok((where_clause, Fields::Unit, Some(semi)))
179 } else {
180 Err(lookahead.error())
181 }
182 }
183
184 pub(crate) fn data_enum(
185 input: ParseStream,
186 ) -> Result<(
187 Option<WhereClause>,
188 token::Brace,
189 Punctuated<Variant, Token![,]>,
190 )> {
191 let where_clause = input.parse()?;
192
193 let content;
194 let brace = braced!(content in input);
195 let variants = content.parse_terminated(Variant::parse, Token![,])?;
196
197 Ok((where_clause, brace, variants))
198 }
199
200 pub(crate) fn data_union(input: ParseStream) -> Result<(Option<WhereClause>, FieldsNamed)> {
201 let where_clause = input.parse()?;
202 let fields = input.parse()?;
203 Ok((where_clause, fields))
204 }
205}
206
207#[cfg(feature = "printing")]
208mod printing {
209 use crate::attr::FilterAttrs;
210 use crate::data::Fields;
211 use crate::derive::{Data, DeriveInput};
212 use crate::print::TokensOrDefault;
213 use proc_macro2::TokenStream;
214 use quote::ToTokens;
215
216 #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
217 impl ToTokens for DeriveInput {
218 fn to_tokens(&self, tokens: &mut TokenStream) {
219 for attr in self.attrs.outer() {
220 attr.to_tokens(tokens);
221 }
222 self.vis.to_tokens(tokens);
223 match &self.data {
224 Data::Struct(d) => d.struct_token.to_tokens(tokens),
225 Data::Enum(d) => d.enum_token.to_tokens(tokens),
226 Data::Union(d) => d.union_token.to_tokens(tokens),
227 }
228 self.ident.to_tokens(tokens);
229 self.generics.to_tokens(tokens);
230 match &self.data {
231 Data::Struct(data) => match &data.fields {
232 Fields::Named(fields) => {
233 self.generics.where_clause.to_tokens(tokens);
234 fields.to_tokens(tokens);
235 }
236 Fields::Unnamed(fields) => {
237 fields.to_tokens(tokens);
238 self.generics.where_clause.to_tokens(tokens);
239 TokensOrDefault(&data.semi_token).to_tokens(tokens);
240 }
241 Fields::Unit => {
242 self.generics.where_clause.to_tokens(tokens);
243 TokensOrDefault(&data.semi_token).to_tokens(tokens);
244 }
245 },
246 Data::Enum(data) => {
247 self.generics.where_clause.to_tokens(tokens);
248 data.brace_token.surround(tokens, |tokens| {
249 data.variants.to_tokens(tokens);
250 });
251 }
252 Data::Union(data) => {
253 self.generics.where_clause.to_tokens(tokens);
254 data.fields.to_tokens(tokens);
255 }
256 }
257 }
258 }
259}
260