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