1 | use super::*; |
2 | use crate::derive::{Data, DataEnum, DataStruct, DataUnion, DeriveInput}; |
3 | use crate::punctuated::Punctuated; |
4 | use proc_macro2::TokenStream; |
5 | |
6 | #[cfg (feature = "parsing" )] |
7 | use std::mem; |
8 | |
9 | ast_enum_of_structs! { |
10 | /// Things that can appear directly inside of a module or scope. |
11 | /// |
12 | /// # Syntax tree enum |
13 | /// |
14 | /// This type is a [syntax tree enum]. |
15 | /// |
16 | /// [syntax tree enum]: Expr#syntax-tree-enums |
17 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
18 | #[non_exhaustive ] |
19 | pub enum Item { |
20 | /// A constant item: `const MAX: u16 = 65535`. |
21 | Const(ItemConst), |
22 | |
23 | /// An enum definition: `enum Foo<A, B> { A(A), B(B) }`. |
24 | Enum(ItemEnum), |
25 | |
26 | /// An `extern crate` item: `extern crate serde`. |
27 | ExternCrate(ItemExternCrate), |
28 | |
29 | /// A free-standing function: `fn process(n: usize) -> Result<()> { ... |
30 | /// }`. |
31 | Fn(ItemFn), |
32 | |
33 | /// A block of foreign items: `extern "C" { ... }`. |
34 | ForeignMod(ItemForeignMod), |
35 | |
36 | /// An impl block providing trait or associated items: `impl<A> Trait |
37 | /// for Data<A> { ... }`. |
38 | Impl(ItemImpl), |
39 | |
40 | /// A macro invocation, which includes `macro_rules!` definitions. |
41 | Macro(ItemMacro), |
42 | |
43 | /// A module or module declaration: `mod m` or `mod m { ... }`. |
44 | Mod(ItemMod), |
45 | |
46 | /// A static item: `static BIKE: Shed = Shed(42)`. |
47 | Static(ItemStatic), |
48 | |
49 | /// A struct definition: `struct Foo<A> { x: A }`. |
50 | Struct(ItemStruct), |
51 | |
52 | /// A trait definition: `pub trait Iterator { ... }`. |
53 | Trait(ItemTrait), |
54 | |
55 | /// A trait alias: `pub trait SharableIterator = Iterator + Sync`. |
56 | TraitAlias(ItemTraitAlias), |
57 | |
58 | /// A type alias: `type Result<T> = std::result::Result<T, MyError>`. |
59 | Type(ItemType), |
60 | |
61 | /// A union definition: `union Foo<A, B> { x: A, y: B }`. |
62 | Union(ItemUnion), |
63 | |
64 | /// A use declaration: `use std::collections::HashMap`. |
65 | Use(ItemUse), |
66 | |
67 | /// Tokens forming an item not interpreted by Syn. |
68 | Verbatim(TokenStream), |
69 | |
70 | // For testing exhaustiveness in downstream code, use the following idiom: |
71 | // |
72 | // match item { |
73 | // Item::Const(item) => {...} |
74 | // Item::Enum(item) => {...} |
75 | // ... |
76 | // Item::Verbatim(item) => {...} |
77 | // |
78 | // #[cfg_attr(test, deny(non_exhaustive_omitted_patterns))] |
79 | // _ => { /* some sane fallback */ } |
80 | // } |
81 | // |
82 | // This way we fail your tests but don't break your library when adding |
83 | // a variant. You will be notified by a test failure when a variant is |
84 | // added, so that you can add code to handle it, but your library will |
85 | // continue to compile and work for downstream users in the interim. |
86 | } |
87 | } |
88 | |
89 | ast_struct! { |
90 | /// A constant item: `const MAX: u16 = 65535`. |
91 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
92 | pub struct ItemConst { |
93 | pub attrs: Vec<Attribute>, |
94 | pub vis: Visibility, |
95 | pub const_token: Token![const], |
96 | pub ident: Ident, |
97 | pub generics: Generics, |
98 | pub colon_token: Token![:], |
99 | pub ty: Box<Type>, |
100 | pub eq_token: Token![=], |
101 | pub expr: Box<Expr>, |
102 | pub semi_token: Token![;], |
103 | } |
104 | } |
105 | |
106 | ast_struct! { |
107 | /// An enum definition: `enum Foo<A, B> { A(A), B(B) }`. |
108 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
109 | pub struct ItemEnum { |
110 | pub attrs: Vec<Attribute>, |
111 | pub vis: Visibility, |
112 | pub enum_token: Token![enum], |
113 | pub ident: Ident, |
114 | pub generics: Generics, |
115 | pub brace_token: token::Brace, |
116 | pub variants: Punctuated<Variant, Token![,]>, |
117 | } |
118 | } |
119 | |
120 | ast_struct! { |
121 | /// An `extern crate` item: `extern crate serde`. |
122 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
123 | pub struct ItemExternCrate { |
124 | pub attrs: Vec<Attribute>, |
125 | pub vis: Visibility, |
126 | pub extern_token: Token![extern], |
127 | pub crate_token: Token![crate], |
128 | pub ident: Ident, |
129 | pub rename: Option<(Token![as], Ident)>, |
130 | pub semi_token: Token![;], |
131 | } |
132 | } |
133 | |
134 | ast_struct! { |
135 | /// A free-standing function: `fn process(n: usize) -> Result<()> { ... }`. |
136 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
137 | pub struct ItemFn { |
138 | pub attrs: Vec<Attribute>, |
139 | pub vis: Visibility, |
140 | pub sig: Signature, |
141 | pub block: Box<Block>, |
142 | } |
143 | } |
144 | |
145 | ast_struct! { |
146 | /// A block of foreign items: `extern "C" { ... }`. |
147 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
148 | pub struct ItemForeignMod { |
149 | pub attrs: Vec<Attribute>, |
150 | pub unsafety: Option<Token![unsafe]>, |
151 | pub abi: Abi, |
152 | pub brace_token: token::Brace, |
153 | pub items: Vec<ForeignItem>, |
154 | } |
155 | } |
156 | |
157 | ast_struct! { |
158 | /// An impl block providing trait or associated items: `impl<A> Trait |
159 | /// for Data<A> { ... }`. |
160 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
161 | pub struct ItemImpl { |
162 | pub attrs: Vec<Attribute>, |
163 | pub defaultness: Option<Token![default]>, |
164 | pub unsafety: Option<Token![unsafe]>, |
165 | pub impl_token: Token![impl], |
166 | pub generics: Generics, |
167 | /// Trait this impl implements. |
168 | pub trait_: Option<(Option<Token![!]>, Path, Token![for])>, |
169 | /// The Self type of the impl. |
170 | pub self_ty: Box<Type>, |
171 | pub brace_token: token::Brace, |
172 | pub items: Vec<ImplItem>, |
173 | } |
174 | } |
175 | |
176 | ast_struct! { |
177 | /// A macro invocation, which includes `macro_rules!` definitions. |
178 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
179 | pub struct ItemMacro { |
180 | pub attrs: Vec<Attribute>, |
181 | /// The `example` in `macro_rules! example { ... }`. |
182 | pub ident: Option<Ident>, |
183 | pub mac: Macro, |
184 | pub semi_token: Option<Token![;]>, |
185 | } |
186 | } |
187 | |
188 | ast_struct! { |
189 | /// A module or module declaration: `mod m` or `mod m { ... }`. |
190 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
191 | pub struct ItemMod { |
192 | pub attrs: Vec<Attribute>, |
193 | pub vis: Visibility, |
194 | pub unsafety: Option<Token![unsafe]>, |
195 | pub mod_token: Token![mod], |
196 | pub ident: Ident, |
197 | pub content: Option<(token::Brace, Vec<Item>)>, |
198 | pub semi: Option<Token![;]>, |
199 | } |
200 | } |
201 | |
202 | ast_struct! { |
203 | /// A static item: `static BIKE: Shed = Shed(42)`. |
204 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
205 | pub struct ItemStatic { |
206 | pub attrs: Vec<Attribute>, |
207 | pub vis: Visibility, |
208 | pub static_token: Token![static], |
209 | pub mutability: StaticMutability, |
210 | pub ident: Ident, |
211 | pub colon_token: Token![:], |
212 | pub ty: Box<Type>, |
213 | pub eq_token: Token![=], |
214 | pub expr: Box<Expr>, |
215 | pub semi_token: Token![;], |
216 | } |
217 | } |
218 | |
219 | ast_struct! { |
220 | /// A struct definition: `struct Foo<A> { x: A }`. |
221 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
222 | pub struct ItemStruct { |
223 | pub attrs: Vec<Attribute>, |
224 | pub vis: Visibility, |
225 | pub struct_token: Token![struct], |
226 | pub ident: Ident, |
227 | pub generics: Generics, |
228 | pub fields: Fields, |
229 | pub semi_token: Option<Token![;]>, |
230 | } |
231 | } |
232 | |
233 | ast_struct! { |
234 | /// A trait definition: `pub trait Iterator { ... }`. |
235 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
236 | pub struct ItemTrait { |
237 | pub attrs: Vec<Attribute>, |
238 | pub vis: Visibility, |
239 | pub unsafety: Option<Token![unsafe]>, |
240 | pub auto_token: Option<Token![auto]>, |
241 | pub restriction: Option<ImplRestriction>, |
242 | pub trait_token: Token![trait], |
243 | pub ident: Ident, |
244 | pub generics: Generics, |
245 | pub colon_token: Option<Token![:]>, |
246 | pub supertraits: Punctuated<TypeParamBound, Token![+]>, |
247 | pub brace_token: token::Brace, |
248 | pub items: Vec<TraitItem>, |
249 | } |
250 | } |
251 | |
252 | ast_struct! { |
253 | /// A trait alias: `pub trait SharableIterator = Iterator + Sync`. |
254 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
255 | pub struct ItemTraitAlias { |
256 | pub attrs: Vec<Attribute>, |
257 | pub vis: Visibility, |
258 | pub trait_token: Token![trait], |
259 | pub ident: Ident, |
260 | pub generics: Generics, |
261 | pub eq_token: Token![=], |
262 | pub bounds: Punctuated<TypeParamBound, Token![+]>, |
263 | pub semi_token: Token![;], |
264 | } |
265 | } |
266 | |
267 | ast_struct! { |
268 | /// A type alias: `type Result<T> = std::result::Result<T, MyError>`. |
269 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
270 | pub struct ItemType { |
271 | pub attrs: Vec<Attribute>, |
272 | pub vis: Visibility, |
273 | pub type_token: Token![type], |
274 | pub ident: Ident, |
275 | pub generics: Generics, |
276 | pub eq_token: Token![=], |
277 | pub ty: Box<Type>, |
278 | pub semi_token: Token![;], |
279 | } |
280 | } |
281 | |
282 | ast_struct! { |
283 | /// A union definition: `union Foo<A, B> { x: A, y: B }`. |
284 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
285 | pub struct ItemUnion { |
286 | pub attrs: Vec<Attribute>, |
287 | pub vis: Visibility, |
288 | pub union_token: Token![union], |
289 | pub ident: Ident, |
290 | pub generics: Generics, |
291 | pub fields: FieldsNamed, |
292 | } |
293 | } |
294 | |
295 | ast_struct! { |
296 | /// A use declaration: `use std::collections::HashMap`. |
297 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
298 | pub struct ItemUse { |
299 | pub attrs: Vec<Attribute>, |
300 | pub vis: Visibility, |
301 | pub use_token: Token![use], |
302 | pub leading_colon: Option<Token![::]>, |
303 | pub tree: UseTree, |
304 | pub semi_token: Token![;], |
305 | } |
306 | } |
307 | |
308 | impl Item { |
309 | #[cfg (feature = "parsing" )] |
310 | pub(crate) fn replace_attrs(&mut self, new: Vec<Attribute>) -> Vec<Attribute> { |
311 | match self { |
312 | Item::Const(ItemConst { attrs: &mut Vec, .. }) |
313 | | Item::Enum(ItemEnum { attrs: &mut Vec, .. }) |
314 | | Item::ExternCrate(ItemExternCrate { attrs: &mut Vec, .. }) |
315 | | Item::Fn(ItemFn { attrs: &mut Vec, .. }) |
316 | | Item::ForeignMod(ItemForeignMod { attrs: &mut Vec, .. }) |
317 | | Item::Impl(ItemImpl { attrs: &mut Vec, .. }) |
318 | | Item::Macro(ItemMacro { attrs: &mut Vec, .. }) |
319 | | Item::Mod(ItemMod { attrs: &mut Vec, .. }) |
320 | | Item::Static(ItemStatic { attrs: &mut Vec, .. }) |
321 | | Item::Struct(ItemStruct { attrs: &mut Vec, .. }) |
322 | | Item::Trait(ItemTrait { attrs: &mut Vec, .. }) |
323 | | Item::TraitAlias(ItemTraitAlias { attrs: &mut Vec, .. }) |
324 | | Item::Type(ItemType { attrs: &mut Vec, .. }) |
325 | | Item::Union(ItemUnion { attrs: &mut Vec, .. }) |
326 | | Item::Use(ItemUse { attrs: &mut Vec, .. }) => mem::replace(dest:attrs, src:new), |
327 | Item::Verbatim(_) => Vec::new(), |
328 | } |
329 | } |
330 | } |
331 | |
332 | impl From<DeriveInput> for Item { |
333 | fn from(input: DeriveInput) -> Item { |
334 | match input.data { |
335 | Data::Struct(data) => Item::Struct(ItemStruct { |
336 | attrs: input.attrs, |
337 | vis: input.vis, |
338 | struct_token: data.struct_token, |
339 | ident: input.ident, |
340 | generics: input.generics, |
341 | fields: data.fields, |
342 | semi_token: data.semi_token, |
343 | }), |
344 | Data::Enum(data) => Item::Enum(ItemEnum { |
345 | attrs: input.attrs, |
346 | vis: input.vis, |
347 | enum_token: data.enum_token, |
348 | ident: input.ident, |
349 | generics: input.generics, |
350 | brace_token: data.brace_token, |
351 | variants: data.variants, |
352 | }), |
353 | Data::Union(data) => Item::Union(ItemUnion { |
354 | attrs: input.attrs, |
355 | vis: input.vis, |
356 | union_token: data.union_token, |
357 | ident: input.ident, |
358 | generics: input.generics, |
359 | fields: data.fields, |
360 | }), |
361 | } |
362 | } |
363 | } |
364 | |
365 | impl From<ItemStruct> for DeriveInput { |
366 | fn from(input: ItemStruct) -> DeriveInput { |
367 | DeriveInput { |
368 | attrs: input.attrs, |
369 | vis: input.vis, |
370 | ident: input.ident, |
371 | generics: input.generics, |
372 | data: Data::Struct(DataStruct { |
373 | struct_token: input.struct_token, |
374 | fields: input.fields, |
375 | semi_token: input.semi_token, |
376 | }), |
377 | } |
378 | } |
379 | } |
380 | |
381 | impl From<ItemEnum> for DeriveInput { |
382 | fn from(input: ItemEnum) -> DeriveInput { |
383 | DeriveInput { |
384 | attrs: input.attrs, |
385 | vis: input.vis, |
386 | ident: input.ident, |
387 | generics: input.generics, |
388 | data: Data::Enum(DataEnum { |
389 | enum_token: input.enum_token, |
390 | brace_token: input.brace_token, |
391 | variants: input.variants, |
392 | }), |
393 | } |
394 | } |
395 | } |
396 | |
397 | impl From<ItemUnion> for DeriveInput { |
398 | fn from(input: ItemUnion) -> DeriveInput { |
399 | DeriveInput { |
400 | attrs: input.attrs, |
401 | vis: input.vis, |
402 | ident: input.ident, |
403 | generics: input.generics, |
404 | data: Data::Union(DataUnion { |
405 | union_token: input.union_token, |
406 | fields: input.fields, |
407 | }), |
408 | } |
409 | } |
410 | } |
411 | |
412 | ast_enum_of_structs! { |
413 | /// A suffix of an import tree in a `use` item: `Type as Renamed` or `*`. |
414 | /// |
415 | /// # Syntax tree enum |
416 | /// |
417 | /// This type is a [syntax tree enum]. |
418 | /// |
419 | /// [syntax tree enum]: Expr#syntax-tree-enums |
420 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
421 | pub enum UseTree { |
422 | /// A path prefix of imports in a `use` item: `std::...`. |
423 | Path(UsePath), |
424 | |
425 | /// An identifier imported by a `use` item: `HashMap`. |
426 | Name(UseName), |
427 | |
428 | /// An renamed identifier imported by a `use` item: `HashMap as Map`. |
429 | Rename(UseRename), |
430 | |
431 | /// A glob import in a `use` item: `*`. |
432 | Glob(UseGlob), |
433 | |
434 | /// A braced group of imports in a `use` item: `{A, B, C}`. |
435 | Group(UseGroup), |
436 | } |
437 | } |
438 | |
439 | ast_struct! { |
440 | /// A path prefix of imports in a `use` item: `std::...`. |
441 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
442 | pub struct UsePath { |
443 | pub ident: Ident, |
444 | pub colon2_token: Token![::], |
445 | pub tree: Box<UseTree>, |
446 | } |
447 | } |
448 | |
449 | ast_struct! { |
450 | /// An identifier imported by a `use` item: `HashMap`. |
451 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
452 | pub struct UseName { |
453 | pub ident: Ident, |
454 | } |
455 | } |
456 | |
457 | ast_struct! { |
458 | /// An renamed identifier imported by a `use` item: `HashMap as Map`. |
459 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
460 | pub struct UseRename { |
461 | pub ident: Ident, |
462 | pub as_token: Token![as], |
463 | pub rename: Ident, |
464 | } |
465 | } |
466 | |
467 | ast_struct! { |
468 | /// A glob import in a `use` item: `*`. |
469 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
470 | pub struct UseGlob { |
471 | pub star_token: Token![*], |
472 | } |
473 | } |
474 | |
475 | ast_struct! { |
476 | /// A braced group of imports in a `use` item: `{A, B, C}`. |
477 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
478 | pub struct UseGroup { |
479 | pub brace_token: token::Brace, |
480 | pub items: Punctuated<UseTree, Token![,]>, |
481 | } |
482 | } |
483 | |
484 | ast_enum_of_structs! { |
485 | /// An item within an `extern` block. |
486 | /// |
487 | /// # Syntax tree enum |
488 | /// |
489 | /// This type is a [syntax tree enum]. |
490 | /// |
491 | /// [syntax tree enum]: Expr#syntax-tree-enums |
492 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
493 | #[non_exhaustive ] |
494 | pub enum ForeignItem { |
495 | /// A foreign function in an `extern` block. |
496 | Fn(ForeignItemFn), |
497 | |
498 | /// A foreign static item in an `extern` block: `static ext: u8`. |
499 | Static(ForeignItemStatic), |
500 | |
501 | /// A foreign type in an `extern` block: `type void`. |
502 | Type(ForeignItemType), |
503 | |
504 | /// A macro invocation within an extern block. |
505 | Macro(ForeignItemMacro), |
506 | |
507 | /// Tokens in an `extern` block not interpreted by Syn. |
508 | Verbatim(TokenStream), |
509 | |
510 | // For testing exhaustiveness in downstream code, use the following idiom: |
511 | // |
512 | // match item { |
513 | // ForeignItem::Fn(item) => {...} |
514 | // ForeignItem::Static(item) => {...} |
515 | // ... |
516 | // ForeignItem::Verbatim(item) => {...} |
517 | // |
518 | // #[cfg_attr(test, deny(non_exhaustive_omitted_patterns))] |
519 | // _ => { /* some sane fallback */ } |
520 | // } |
521 | // |
522 | // This way we fail your tests but don't break your library when adding |
523 | // a variant. You will be notified by a test failure when a variant is |
524 | // added, so that you can add code to handle it, but your library will |
525 | // continue to compile and work for downstream users in the interim. |
526 | } |
527 | } |
528 | |
529 | ast_struct! { |
530 | /// A foreign function in an `extern` block. |
531 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
532 | pub struct ForeignItemFn { |
533 | pub attrs: Vec<Attribute>, |
534 | pub vis: Visibility, |
535 | pub sig: Signature, |
536 | pub semi_token: Token![;], |
537 | } |
538 | } |
539 | |
540 | ast_struct! { |
541 | /// A foreign static item in an `extern` block: `static ext: u8`. |
542 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
543 | pub struct ForeignItemStatic { |
544 | pub attrs: Vec<Attribute>, |
545 | pub vis: Visibility, |
546 | pub static_token: Token![static], |
547 | pub mutability: StaticMutability, |
548 | pub ident: Ident, |
549 | pub colon_token: Token![:], |
550 | pub ty: Box<Type>, |
551 | pub semi_token: Token![;], |
552 | } |
553 | } |
554 | |
555 | ast_struct! { |
556 | /// A foreign type in an `extern` block: `type void`. |
557 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
558 | pub struct ForeignItemType { |
559 | pub attrs: Vec<Attribute>, |
560 | pub vis: Visibility, |
561 | pub type_token: Token![type], |
562 | pub ident: Ident, |
563 | pub generics: Generics, |
564 | pub semi_token: Token![;], |
565 | } |
566 | } |
567 | |
568 | ast_struct! { |
569 | /// A macro invocation within an extern block. |
570 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
571 | pub struct ForeignItemMacro { |
572 | pub attrs: Vec<Attribute>, |
573 | pub mac: Macro, |
574 | pub semi_token: Option<Token![;]>, |
575 | } |
576 | } |
577 | |
578 | ast_enum_of_structs! { |
579 | /// An item declaration within the definition of a trait. |
580 | /// |
581 | /// # Syntax tree enum |
582 | /// |
583 | /// This type is a [syntax tree enum]. |
584 | /// |
585 | /// [syntax tree enum]: Expr#syntax-tree-enums |
586 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
587 | #[non_exhaustive ] |
588 | pub enum TraitItem { |
589 | /// An associated constant within the definition of a trait. |
590 | Const(TraitItemConst), |
591 | |
592 | /// An associated function within the definition of a trait. |
593 | Fn(TraitItemFn), |
594 | |
595 | /// An associated type within the definition of a trait. |
596 | Type(TraitItemType), |
597 | |
598 | /// A macro invocation within the definition of a trait. |
599 | Macro(TraitItemMacro), |
600 | |
601 | /// Tokens within the definition of a trait not interpreted by Syn. |
602 | Verbatim(TokenStream), |
603 | |
604 | // For testing exhaustiveness in downstream code, use the following idiom: |
605 | // |
606 | // match item { |
607 | // TraitItem::Const(item) => {...} |
608 | // TraitItem::Fn(item) => {...} |
609 | // ... |
610 | // TraitItem::Verbatim(item) => {...} |
611 | // |
612 | // #[cfg_attr(test, deny(non_exhaustive_omitted_patterns))] |
613 | // _ => { /* some sane fallback */ } |
614 | // } |
615 | // |
616 | // This way we fail your tests but don't break your library when adding |
617 | // a variant. You will be notified by a test failure when a variant is |
618 | // added, so that you can add code to handle it, but your library will |
619 | // continue to compile and work for downstream users in the interim. |
620 | } |
621 | } |
622 | |
623 | ast_struct! { |
624 | /// An associated constant within the definition of a trait. |
625 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
626 | pub struct TraitItemConst { |
627 | pub attrs: Vec<Attribute>, |
628 | pub const_token: Token![const], |
629 | pub ident: Ident, |
630 | pub generics: Generics, |
631 | pub colon_token: Token![:], |
632 | pub ty: Type, |
633 | pub default: Option<(Token![=], Expr)>, |
634 | pub semi_token: Token![;], |
635 | } |
636 | } |
637 | |
638 | ast_struct! { |
639 | /// An associated function within the definition of a trait. |
640 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
641 | pub struct TraitItemFn { |
642 | pub attrs: Vec<Attribute>, |
643 | pub sig: Signature, |
644 | pub default: Option<Block>, |
645 | pub semi_token: Option<Token![;]>, |
646 | } |
647 | } |
648 | |
649 | ast_struct! { |
650 | /// An associated type within the definition of a trait. |
651 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
652 | pub struct TraitItemType { |
653 | pub attrs: Vec<Attribute>, |
654 | pub type_token: Token![type], |
655 | pub ident: Ident, |
656 | pub generics: Generics, |
657 | pub colon_token: Option<Token![:]>, |
658 | pub bounds: Punctuated<TypeParamBound, Token![+]>, |
659 | pub default: Option<(Token![=], Type)>, |
660 | pub semi_token: Token![;], |
661 | } |
662 | } |
663 | |
664 | ast_struct! { |
665 | /// A macro invocation within the definition of a trait. |
666 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
667 | pub struct TraitItemMacro { |
668 | pub attrs: Vec<Attribute>, |
669 | pub mac: Macro, |
670 | pub semi_token: Option<Token![;]>, |
671 | } |
672 | } |
673 | |
674 | ast_enum_of_structs! { |
675 | /// An item within an impl block. |
676 | /// |
677 | /// # Syntax tree enum |
678 | /// |
679 | /// This type is a [syntax tree enum]. |
680 | /// |
681 | /// [syntax tree enum]: Expr#syntax-tree-enums |
682 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
683 | #[non_exhaustive ] |
684 | pub enum ImplItem { |
685 | /// An associated constant within an impl block. |
686 | Const(ImplItemConst), |
687 | |
688 | /// An associated function within an impl block. |
689 | Fn(ImplItemFn), |
690 | |
691 | /// An associated type within an impl block. |
692 | Type(ImplItemType), |
693 | |
694 | /// A macro invocation within an impl block. |
695 | Macro(ImplItemMacro), |
696 | |
697 | /// Tokens within an impl block not interpreted by Syn. |
698 | Verbatim(TokenStream), |
699 | |
700 | // For testing exhaustiveness in downstream code, use the following idiom: |
701 | // |
702 | // match item { |
703 | // ImplItem::Const(item) => {...} |
704 | // ImplItem::Fn(item) => {...} |
705 | // ... |
706 | // ImplItem::Verbatim(item) => {...} |
707 | // |
708 | // #[cfg_attr(test, deny(non_exhaustive_omitted_patterns))] |
709 | // _ => { /* some sane fallback */ } |
710 | // } |
711 | // |
712 | // This way we fail your tests but don't break your library when adding |
713 | // a variant. You will be notified by a test failure when a variant is |
714 | // added, so that you can add code to handle it, but your library will |
715 | // continue to compile and work for downstream users in the interim. |
716 | } |
717 | } |
718 | |
719 | ast_struct! { |
720 | /// An associated constant within an impl block. |
721 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
722 | pub struct ImplItemConst { |
723 | pub attrs: Vec<Attribute>, |
724 | pub vis: Visibility, |
725 | pub defaultness: Option<Token![default]>, |
726 | pub const_token: Token![const], |
727 | pub ident: Ident, |
728 | pub generics: Generics, |
729 | pub colon_token: Token![:], |
730 | pub ty: Type, |
731 | pub eq_token: Token![=], |
732 | pub expr: Expr, |
733 | pub semi_token: Token![;], |
734 | } |
735 | } |
736 | |
737 | ast_struct! { |
738 | /// An associated function within an impl block. |
739 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
740 | pub struct ImplItemFn { |
741 | pub attrs: Vec<Attribute>, |
742 | pub vis: Visibility, |
743 | pub defaultness: Option<Token![default]>, |
744 | pub sig: Signature, |
745 | pub block: Block, |
746 | } |
747 | } |
748 | |
749 | ast_struct! { |
750 | /// An associated type within an impl block. |
751 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
752 | pub struct ImplItemType { |
753 | pub attrs: Vec<Attribute>, |
754 | pub vis: Visibility, |
755 | pub defaultness: Option<Token![default]>, |
756 | pub type_token: Token![type], |
757 | pub ident: Ident, |
758 | pub generics: Generics, |
759 | pub eq_token: Token![=], |
760 | pub ty: Type, |
761 | pub semi_token: Token![;], |
762 | } |
763 | } |
764 | |
765 | ast_struct! { |
766 | /// A macro invocation within an impl block. |
767 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
768 | pub struct ImplItemMacro { |
769 | pub attrs: Vec<Attribute>, |
770 | pub mac: Macro, |
771 | pub semi_token: Option<Token![;]>, |
772 | } |
773 | } |
774 | |
775 | ast_struct! { |
776 | /// A function signature in a trait or implementation: `unsafe fn |
777 | /// initialize(&self)`. |
778 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
779 | pub struct Signature { |
780 | pub constness: Option<Token![const]>, |
781 | pub asyncness: Option<Token![async]>, |
782 | pub unsafety: Option<Token![unsafe]>, |
783 | pub abi: Option<Abi>, |
784 | pub fn_token: Token![fn], |
785 | pub ident: Ident, |
786 | pub generics: Generics, |
787 | pub paren_token: token::Paren, |
788 | pub inputs: Punctuated<FnArg, Token![,]>, |
789 | pub variadic: Option<Variadic>, |
790 | pub output: ReturnType, |
791 | } |
792 | } |
793 | |
794 | impl Signature { |
795 | /// A method's `self` receiver, such as `&self` or `self: Box<Self>`. |
796 | pub fn receiver(&self) -> Option<&Receiver> { |
797 | let arg: &FnArg = self.inputs.first()?; |
798 | match arg { |
799 | FnArg::Receiver(receiver: &Receiver) => Some(receiver), |
800 | FnArg::Typed(_) => None, |
801 | } |
802 | } |
803 | } |
804 | |
805 | ast_enum_of_structs! { |
806 | /// An argument in a function signature: the `n: usize` in `fn f(n: usize)`. |
807 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
808 | pub enum FnArg { |
809 | /// The `self` argument of an associated method. |
810 | Receiver(Receiver), |
811 | |
812 | /// A function argument accepted by pattern and type. |
813 | Typed(PatType), |
814 | } |
815 | } |
816 | |
817 | ast_struct! { |
818 | /// The `self` argument of an associated method. |
819 | /// |
820 | /// If `colon_token` is present, the receiver is written with an explicit |
821 | /// type such as `self: Box<Self>`. If `colon_token` is absent, the receiver |
822 | /// is written in shorthand such as `self` or `&self` or `&mut self`. In the |
823 | /// shorthand case, the type in `ty` is reconstructed as one of `Self`, |
824 | /// `&Self`, or `&mut Self`. |
825 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
826 | pub struct Receiver { |
827 | pub attrs: Vec<Attribute>, |
828 | pub reference: Option<(Token![&], Option<Lifetime>)>, |
829 | pub mutability: Option<Token![mut]>, |
830 | pub self_token: Token![self], |
831 | pub colon_token: Option<Token![:]>, |
832 | pub ty: Box<Type>, |
833 | } |
834 | } |
835 | |
836 | impl Receiver { |
837 | pub fn lifetime(&self) -> Option<&Lifetime> { |
838 | self.reference.as_ref()?.1.as_ref() |
839 | } |
840 | } |
841 | |
842 | ast_struct! { |
843 | /// The variadic argument of a foreign function. |
844 | /// |
845 | /// ```rust |
846 | /// # struct c_char; |
847 | /// # struct c_int; |
848 | /// # |
849 | /// extern "C" { |
850 | /// fn printf(format: *const c_char, ...) -> c_int; |
851 | /// // ^^^ |
852 | /// } |
853 | /// ``` |
854 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
855 | pub struct Variadic { |
856 | pub attrs: Vec<Attribute>, |
857 | pub pat: Option<(Box<Pat>, Token![:])>, |
858 | pub dots: Token![...], |
859 | pub comma: Option<Token![,]>, |
860 | } |
861 | } |
862 | |
863 | ast_enum! { |
864 | /// The mutability of an `Item::Static` or `ForeignItem::Static`. |
865 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
866 | #[non_exhaustive ] |
867 | pub enum StaticMutability { |
868 | Mut(Token![mut]), |
869 | None, |
870 | } |
871 | } |
872 | |
873 | ast_enum! { |
874 | /// Unused, but reserved for RFC 3323 restrictions. |
875 | #[cfg_attr (doc_cfg, doc(cfg(feature = "full" )))] |
876 | #[non_exhaustive ] |
877 | pub enum ImplRestriction {} |
878 | |
879 | |
880 | // TODO: https://rust-lang.github.io/rfcs/3323-restrictions.html |
881 | // |
882 | // pub struct ImplRestriction { |
883 | // pub impl_token: Token![impl], |
884 | // pub paren_token: token::Paren, |
885 | // pub in_token: Option<Token![in]>, |
886 | // pub path: Box<Path>, |
887 | // } |
888 | } |
889 | |
890 | #[cfg (feature = "parsing" )] |
891 | pub(crate) mod parsing { |
892 | use super::*; |
893 | use crate::ext::IdentExt; |
894 | use crate::parse::discouraged::Speculative; |
895 | use crate::parse::{Parse, ParseBuffer, ParseStream, Result}; |
896 | |
897 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
898 | impl Parse for Item { |
899 | fn parse(input: ParseStream) -> Result<Self> { |
900 | let begin = input.fork(); |
901 | let attrs = input.call(Attribute::parse_outer)?; |
902 | parse_rest_of_item(begin, attrs, input) |
903 | } |
904 | } |
905 | |
906 | pub(crate) fn parse_rest_of_item( |
907 | begin: ParseBuffer, |
908 | mut attrs: Vec<Attribute>, |
909 | input: ParseStream, |
910 | ) -> Result<Item> { |
911 | let ahead = input.fork(); |
912 | let vis: Visibility = ahead.parse()?; |
913 | |
914 | let lookahead = ahead.lookahead1(); |
915 | let mut item = if lookahead.peek(Token![fn]) || peek_signature(&ahead) { |
916 | let vis: Visibility = input.parse()?; |
917 | let sig: Signature = input.parse()?; |
918 | if input.peek(Token![;]) { |
919 | input.parse::<Token![;]>()?; |
920 | Ok(Item::Verbatim(verbatim::between(&begin, input))) |
921 | } else { |
922 | parse_rest_of_fn(input, Vec::new(), vis, sig).map(Item::Fn) |
923 | } |
924 | } else if lookahead.peek(Token![extern]) { |
925 | ahead.parse::<Token![extern]>()?; |
926 | let lookahead = ahead.lookahead1(); |
927 | if lookahead.peek(Token![crate]) { |
928 | input.parse().map(Item::ExternCrate) |
929 | } else if lookahead.peek(token::Brace) { |
930 | input.parse().map(Item::ForeignMod) |
931 | } else if lookahead.peek(LitStr) { |
932 | ahead.parse::<LitStr>()?; |
933 | let lookahead = ahead.lookahead1(); |
934 | if lookahead.peek(token::Brace) { |
935 | input.parse().map(Item::ForeignMod) |
936 | } else { |
937 | Err(lookahead.error()) |
938 | } |
939 | } else { |
940 | Err(lookahead.error()) |
941 | } |
942 | } else if lookahead.peek(Token![use]) { |
943 | let allow_crate_root_in_path = true; |
944 | match parse_item_use(input, allow_crate_root_in_path)? { |
945 | Some(item_use) => Ok(Item::Use(item_use)), |
946 | None => Ok(Item::Verbatim(verbatim::between(&begin, input))), |
947 | } |
948 | } else if lookahead.peek(Token![static]) { |
949 | let vis = input.parse()?; |
950 | let static_token = input.parse()?; |
951 | let mutability = input.parse()?; |
952 | let ident = input.parse()?; |
953 | if input.peek(Token![=]) { |
954 | input.parse::<Token![=]>()?; |
955 | input.parse::<Expr>()?; |
956 | input.parse::<Token![;]>()?; |
957 | Ok(Item::Verbatim(verbatim::between(&begin, input))) |
958 | } else { |
959 | let colon_token = input.parse()?; |
960 | let ty = input.parse()?; |
961 | if input.peek(Token![;]) { |
962 | input.parse::<Token![;]>()?; |
963 | Ok(Item::Verbatim(verbatim::between(&begin, input))) |
964 | } else { |
965 | Ok(Item::Static(ItemStatic { |
966 | attrs: Vec::new(), |
967 | vis, |
968 | static_token, |
969 | mutability, |
970 | ident, |
971 | colon_token, |
972 | ty, |
973 | eq_token: input.parse()?, |
974 | expr: input.parse()?, |
975 | semi_token: input.parse()?, |
976 | })) |
977 | } |
978 | } |
979 | } else if lookahead.peek(Token![const]) { |
980 | let vis = input.parse()?; |
981 | let const_token: Token![const] = input.parse()?; |
982 | let lookahead = input.lookahead1(); |
983 | let ident = if lookahead.peek(Ident) || lookahead.peek(Token![_]) { |
984 | input.call(Ident::parse_any)? |
985 | } else { |
986 | return Err(lookahead.error()); |
987 | }; |
988 | let mut generics: Generics = input.parse()?; |
989 | let colon_token = input.parse()?; |
990 | let ty = input.parse()?; |
991 | let value = if let Some(eq_token) = input.parse::<Option<Token![=]>>()? { |
992 | let expr: Expr = input.parse()?; |
993 | Some((eq_token, expr)) |
994 | } else { |
995 | None |
996 | }; |
997 | generics.where_clause = input.parse()?; |
998 | let semi_token: Token![;] = input.parse()?; |
999 | match value { |
1000 | Some((eq_token, expr)) |
1001 | if generics.lt_token.is_none() && generics.where_clause.is_none() => |
1002 | { |
1003 | Ok(Item::Const(ItemConst { |
1004 | attrs: Vec::new(), |
1005 | vis, |
1006 | const_token, |
1007 | ident, |
1008 | generics, |
1009 | colon_token, |
1010 | ty, |
1011 | eq_token, |
1012 | expr: Box::new(expr), |
1013 | semi_token, |
1014 | })) |
1015 | } |
1016 | _ => Ok(Item::Verbatim(verbatim::between(&begin, input))), |
1017 | } |
1018 | } else if lookahead.peek(Token![unsafe]) { |
1019 | ahead.parse::<Token![unsafe]>()?; |
1020 | let lookahead = ahead.lookahead1(); |
1021 | if lookahead.peek(Token![trait]) |
1022 | || lookahead.peek(Token![auto]) && ahead.peek2(Token![trait]) |
1023 | { |
1024 | input.parse().map(Item::Trait) |
1025 | } else if lookahead.peek(Token![impl]) { |
1026 | let allow_verbatim_impl = true; |
1027 | if let Some(item) = parse_impl(input, allow_verbatim_impl)? { |
1028 | Ok(Item::Impl(item)) |
1029 | } else { |
1030 | Ok(Item::Verbatim(verbatim::between(&begin, input))) |
1031 | } |
1032 | } else if lookahead.peek(Token![extern]) { |
1033 | input.parse().map(Item::ForeignMod) |
1034 | } else if lookahead.peek(Token![mod]) { |
1035 | input.parse().map(Item::Mod) |
1036 | } else { |
1037 | Err(lookahead.error()) |
1038 | } |
1039 | } else if lookahead.peek(Token![mod]) { |
1040 | input.parse().map(Item::Mod) |
1041 | } else if lookahead.peek(Token![type]) { |
1042 | parse_item_type(begin, input) |
1043 | } else if lookahead.peek(Token![struct]) { |
1044 | input.parse().map(Item::Struct) |
1045 | } else if lookahead.peek(Token![enum]) { |
1046 | input.parse().map(Item::Enum) |
1047 | } else if lookahead.peek(Token![union]) && ahead.peek2(Ident) { |
1048 | input.parse().map(Item::Union) |
1049 | } else if lookahead.peek(Token![trait]) { |
1050 | input.call(parse_trait_or_trait_alias) |
1051 | } else if lookahead.peek(Token![auto]) && ahead.peek2(Token![trait]) { |
1052 | input.parse().map(Item::Trait) |
1053 | } else if lookahead.peek(Token![impl]) |
1054 | || lookahead.peek(Token![default]) && !ahead.peek2(Token![!]) |
1055 | { |
1056 | let allow_verbatim_impl = true; |
1057 | if let Some(item) = parse_impl(input, allow_verbatim_impl)? { |
1058 | Ok(Item::Impl(item)) |
1059 | } else { |
1060 | Ok(Item::Verbatim(verbatim::between(&begin, input))) |
1061 | } |
1062 | } else if lookahead.peek(Token![macro]) { |
1063 | input.advance_to(&ahead); |
1064 | parse_macro2(begin, vis, input) |
1065 | } else if vis.is_inherited() |
1066 | && (lookahead.peek(Ident) |
1067 | || lookahead.peek(Token![self]) |
1068 | || lookahead.peek(Token![super]) |
1069 | || lookahead.peek(Token![crate]) |
1070 | || lookahead.peek(Token![::])) |
1071 | { |
1072 | input.parse().map(Item::Macro) |
1073 | } else { |
1074 | Err(lookahead.error()) |
1075 | }?; |
1076 | |
1077 | attrs.extend(item.replace_attrs(Vec::new())); |
1078 | item.replace_attrs(attrs); |
1079 | Ok(item) |
1080 | } |
1081 | |
1082 | struct FlexibleItemType { |
1083 | vis: Visibility, |
1084 | defaultness: Option<Token![default]>, |
1085 | type_token: Token![type], |
1086 | ident: Ident, |
1087 | generics: Generics, |
1088 | colon_token: Option<Token![:]>, |
1089 | bounds: Punctuated<TypeParamBound, Token![+]>, |
1090 | ty: Option<(Token![=], Type)>, |
1091 | semi_token: Token![;], |
1092 | } |
1093 | |
1094 | enum TypeDefaultness { |
1095 | Optional, |
1096 | Disallowed, |
1097 | } |
1098 | |
1099 | enum WhereClauseLocation { |
1100 | // type Ty<T> where T: 'static = T; |
1101 | BeforeEq, |
1102 | // type Ty<T> = T where T: 'static; |
1103 | AfterEq, |
1104 | // TODO: goes away once the migration period on rust-lang/rust#89122 is over |
1105 | Both, |
1106 | } |
1107 | |
1108 | impl FlexibleItemType { |
1109 | fn parse( |
1110 | input: ParseStream, |
1111 | allow_defaultness: TypeDefaultness, |
1112 | where_clause_location: WhereClauseLocation, |
1113 | ) -> Result<Self> { |
1114 | let vis: Visibility = input.parse()?; |
1115 | let defaultness: Option<Token![default]> = match allow_defaultness { |
1116 | TypeDefaultness::Optional => input.parse()?, |
1117 | TypeDefaultness::Disallowed => None, |
1118 | }; |
1119 | let type_token: Token![type] = input.parse()?; |
1120 | let ident: Ident = input.parse()?; |
1121 | let mut generics: Generics = input.parse()?; |
1122 | let (colon_token, bounds) = Self::parse_optional_bounds(input)?; |
1123 | |
1124 | match where_clause_location { |
1125 | WhereClauseLocation::BeforeEq | WhereClauseLocation::Both => { |
1126 | generics.where_clause = input.parse()?; |
1127 | } |
1128 | WhereClauseLocation::AfterEq => {} |
1129 | } |
1130 | |
1131 | let ty = Self::parse_optional_definition(input)?; |
1132 | |
1133 | match where_clause_location { |
1134 | WhereClauseLocation::AfterEq | WhereClauseLocation::Both |
1135 | if generics.where_clause.is_none() => |
1136 | { |
1137 | generics.where_clause = input.parse()?; |
1138 | } |
1139 | _ => {} |
1140 | } |
1141 | |
1142 | let semi_token: Token![;] = input.parse()?; |
1143 | |
1144 | Ok(FlexibleItemType { |
1145 | vis, |
1146 | defaultness, |
1147 | type_token, |
1148 | ident, |
1149 | generics, |
1150 | colon_token, |
1151 | bounds, |
1152 | ty, |
1153 | semi_token, |
1154 | }) |
1155 | } |
1156 | |
1157 | fn parse_optional_bounds( |
1158 | input: ParseStream, |
1159 | ) -> Result<(Option<Token![:]>, Punctuated<TypeParamBound, Token![+]>)> { |
1160 | let colon_token: Option<Token![:]> = input.parse()?; |
1161 | |
1162 | let mut bounds = Punctuated::new(); |
1163 | if colon_token.is_some() { |
1164 | loop { |
1165 | if input.peek(Token![where]) || input.peek(Token![=]) || input.peek(Token![;]) { |
1166 | break; |
1167 | } |
1168 | bounds.push_value(input.parse::<TypeParamBound>()?); |
1169 | if input.peek(Token![where]) || input.peek(Token![=]) || input.peek(Token![;]) { |
1170 | break; |
1171 | } |
1172 | bounds.push_punct(input.parse::<Token![+]>()?); |
1173 | } |
1174 | } |
1175 | |
1176 | Ok((colon_token, bounds)) |
1177 | } |
1178 | |
1179 | fn parse_optional_definition(input: ParseStream) -> Result<Option<(Token![=], Type)>> { |
1180 | let eq_token: Option<Token![=]> = input.parse()?; |
1181 | if let Some(eq_token) = eq_token { |
1182 | let definition: Type = input.parse()?; |
1183 | Ok(Some((eq_token, definition))) |
1184 | } else { |
1185 | Ok(None) |
1186 | } |
1187 | } |
1188 | } |
1189 | |
1190 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
1191 | impl Parse for ItemMacro { |
1192 | fn parse(input: ParseStream) -> Result<Self> { |
1193 | let attrs = input.call(Attribute::parse_outer)?; |
1194 | let path = input.call(Path::parse_mod_style)?; |
1195 | let bang_token: Token![!] = input.parse()?; |
1196 | let ident: Option<Ident> = if input.peek(Token![try]) { |
1197 | input.call(Ident::parse_any).map(Some) |
1198 | } else { |
1199 | input.parse() |
1200 | }?; |
1201 | let (delimiter, tokens) = input.call(mac::parse_delimiter)?; |
1202 | let semi_token: Option<Token![;]> = if !delimiter.is_brace() { |
1203 | Some(input.parse()?) |
1204 | } else { |
1205 | None |
1206 | }; |
1207 | Ok(ItemMacro { |
1208 | attrs, |
1209 | ident, |
1210 | mac: Macro { |
1211 | path, |
1212 | bang_token, |
1213 | delimiter, |
1214 | tokens, |
1215 | }, |
1216 | semi_token, |
1217 | }) |
1218 | } |
1219 | } |
1220 | |
1221 | fn parse_macro2(begin: ParseBuffer, _vis: Visibility, input: ParseStream) -> Result<Item> { |
1222 | input.parse::<Token![macro]>()?; |
1223 | input.parse::<Ident>()?; |
1224 | |
1225 | let mut lookahead = input.lookahead1(); |
1226 | if lookahead.peek(token::Paren) { |
1227 | let paren_content; |
1228 | parenthesized!(paren_content in input); |
1229 | paren_content.parse::<TokenStream>()?; |
1230 | lookahead = input.lookahead1(); |
1231 | } |
1232 | |
1233 | if lookahead.peek(token::Brace) { |
1234 | let brace_content; |
1235 | braced!(brace_content in input); |
1236 | brace_content.parse::<TokenStream>()?; |
1237 | } else { |
1238 | return Err(lookahead.error()); |
1239 | } |
1240 | |
1241 | Ok(Item::Verbatim(verbatim::between(&begin, input))) |
1242 | } |
1243 | |
1244 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
1245 | impl Parse for ItemExternCrate { |
1246 | fn parse(input: ParseStream) -> Result<Self> { |
1247 | Ok(ItemExternCrate { |
1248 | attrs: input.call(Attribute::parse_outer)?, |
1249 | vis: input.parse()?, |
1250 | extern_token: input.parse()?, |
1251 | crate_token: input.parse()?, |
1252 | ident: { |
1253 | if input.peek(Token![self]) { |
1254 | input.call(Ident::parse_any)? |
1255 | } else { |
1256 | input.parse()? |
1257 | } |
1258 | }, |
1259 | rename: { |
1260 | if input.peek(Token![as]) { |
1261 | let as_token: Token![as] = input.parse()?; |
1262 | let rename: Ident = if input.peek(Token![_]) { |
1263 | Ident::from(input.parse::<Token![_]>()?) |
1264 | } else { |
1265 | input.parse()? |
1266 | }; |
1267 | Some((as_token, rename)) |
1268 | } else { |
1269 | None |
1270 | } |
1271 | }, |
1272 | semi_token: input.parse()?, |
1273 | }) |
1274 | } |
1275 | } |
1276 | |
1277 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
1278 | impl Parse for ItemUse { |
1279 | fn parse(input: ParseStream) -> Result<Self> { |
1280 | let allow_crate_root_in_path = false; |
1281 | parse_item_use(input, allow_crate_root_in_path).map(Option::unwrap) |
1282 | } |
1283 | } |
1284 | |
1285 | fn parse_item_use( |
1286 | input: ParseStream, |
1287 | allow_crate_root_in_path: bool, |
1288 | ) -> Result<Option<ItemUse>> { |
1289 | let attrs = input.call(Attribute::parse_outer)?; |
1290 | let vis: Visibility = input.parse()?; |
1291 | let use_token: Token![use] = input.parse()?; |
1292 | let leading_colon: Option<Token![::]> = input.parse()?; |
1293 | let tree = parse_use_tree(input, allow_crate_root_in_path && leading_colon.is_none())?; |
1294 | let semi_token: Token![;] = input.parse()?; |
1295 | |
1296 | let tree = match tree { |
1297 | Some(tree) => tree, |
1298 | None => return Ok(None), |
1299 | }; |
1300 | |
1301 | Ok(Some(ItemUse { |
1302 | attrs, |
1303 | vis, |
1304 | use_token, |
1305 | leading_colon, |
1306 | tree, |
1307 | semi_token, |
1308 | })) |
1309 | } |
1310 | |
1311 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
1312 | impl Parse for UseTree { |
1313 | fn parse(input: ParseStream) -> Result<UseTree> { |
1314 | let allow_crate_root_in_path = false; |
1315 | parse_use_tree(input, allow_crate_root_in_path).map(Option::unwrap) |
1316 | } |
1317 | } |
1318 | |
1319 | fn parse_use_tree( |
1320 | input: ParseStream, |
1321 | allow_crate_root_in_path: bool, |
1322 | ) -> Result<Option<UseTree>> { |
1323 | let lookahead = input.lookahead1(); |
1324 | if lookahead.peek(Ident) |
1325 | || lookahead.peek(Token![self]) |
1326 | || lookahead.peek(Token![super]) |
1327 | || lookahead.peek(Token![crate]) |
1328 | || lookahead.peek(Token![try]) |
1329 | { |
1330 | let ident = input.call(Ident::parse_any)?; |
1331 | if input.peek(Token![::]) { |
1332 | Ok(Some(UseTree::Path(UsePath { |
1333 | ident, |
1334 | colon2_token: input.parse()?, |
1335 | tree: Box::new(input.parse()?), |
1336 | }))) |
1337 | } else if input.peek(Token![as]) { |
1338 | Ok(Some(UseTree::Rename(UseRename { |
1339 | ident, |
1340 | as_token: input.parse()?, |
1341 | rename: { |
1342 | if input.peek(Ident) { |
1343 | input.parse()? |
1344 | } else if input.peek(Token![_]) { |
1345 | Ident::from(input.parse::<Token![_]>()?) |
1346 | } else { |
1347 | return Err(input.error("expected identifier or underscore" )); |
1348 | } |
1349 | }, |
1350 | }))) |
1351 | } else { |
1352 | Ok(Some(UseTree::Name(UseName { ident }))) |
1353 | } |
1354 | } else if lookahead.peek(Token![*]) { |
1355 | Ok(Some(UseTree::Glob(UseGlob { |
1356 | star_token: input.parse()?, |
1357 | }))) |
1358 | } else if lookahead.peek(token::Brace) { |
1359 | let content; |
1360 | let brace_token = braced!(content in input); |
1361 | let mut items = Punctuated::new(); |
1362 | let mut has_any_crate_root_in_path = false; |
1363 | loop { |
1364 | if content.is_empty() { |
1365 | break; |
1366 | } |
1367 | let this_tree_starts_with_crate_root = |
1368 | allow_crate_root_in_path && content.parse::<Option<Token![::]>>()?.is_some(); |
1369 | has_any_crate_root_in_path |= this_tree_starts_with_crate_root; |
1370 | match parse_use_tree( |
1371 | &content, |
1372 | allow_crate_root_in_path && !this_tree_starts_with_crate_root, |
1373 | )? { |
1374 | Some(tree) => items.push_value(tree), |
1375 | None => has_any_crate_root_in_path = true, |
1376 | } |
1377 | if content.is_empty() { |
1378 | break; |
1379 | } |
1380 | let comma: Token![,] = content.parse()?; |
1381 | items.push_punct(comma); |
1382 | } |
1383 | if has_any_crate_root_in_path { |
1384 | Ok(None) |
1385 | } else { |
1386 | Ok(Some(UseTree::Group(UseGroup { brace_token, items }))) |
1387 | } |
1388 | } else { |
1389 | Err(lookahead.error()) |
1390 | } |
1391 | } |
1392 | |
1393 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
1394 | impl Parse for ItemStatic { |
1395 | fn parse(input: ParseStream) -> Result<Self> { |
1396 | Ok(ItemStatic { |
1397 | attrs: input.call(Attribute::parse_outer)?, |
1398 | vis: input.parse()?, |
1399 | static_token: input.parse()?, |
1400 | mutability: input.parse()?, |
1401 | ident: input.parse()?, |
1402 | colon_token: input.parse()?, |
1403 | ty: input.parse()?, |
1404 | eq_token: input.parse()?, |
1405 | expr: input.parse()?, |
1406 | semi_token: input.parse()?, |
1407 | }) |
1408 | } |
1409 | } |
1410 | |
1411 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
1412 | impl Parse for ItemConst { |
1413 | fn parse(input: ParseStream) -> Result<Self> { |
1414 | let attrs = input.call(Attribute::parse_outer)?; |
1415 | let vis: Visibility = input.parse()?; |
1416 | let const_token: Token![const] = input.parse()?; |
1417 | |
1418 | let lookahead = input.lookahead1(); |
1419 | let ident = if lookahead.peek(Ident) || lookahead.peek(Token![_]) { |
1420 | input.call(Ident::parse_any)? |
1421 | } else { |
1422 | return Err(lookahead.error()); |
1423 | }; |
1424 | |
1425 | let colon_token: Token![:] = input.parse()?; |
1426 | let ty: Type = input.parse()?; |
1427 | let eq_token: Token![=] = input.parse()?; |
1428 | let expr: Expr = input.parse()?; |
1429 | let semi_token: Token![;] = input.parse()?; |
1430 | |
1431 | Ok(ItemConst { |
1432 | attrs, |
1433 | vis, |
1434 | const_token, |
1435 | ident, |
1436 | generics: Generics::default(), |
1437 | colon_token, |
1438 | ty: Box::new(ty), |
1439 | eq_token, |
1440 | expr: Box::new(expr), |
1441 | semi_token, |
1442 | }) |
1443 | } |
1444 | } |
1445 | |
1446 | fn peek_signature(input: ParseStream) -> bool { |
1447 | let fork = input.fork(); |
1448 | fork.parse::<Option<Token![const]>>().is_ok() |
1449 | && fork.parse::<Option<Token![async]>>().is_ok() |
1450 | && fork.parse::<Option<Token![unsafe]>>().is_ok() |
1451 | && fork.parse::<Option<Abi>>().is_ok() |
1452 | && fork.peek(Token![fn]) |
1453 | } |
1454 | |
1455 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
1456 | impl Parse for Signature { |
1457 | fn parse(input: ParseStream) -> Result<Self> { |
1458 | let constness: Option<Token![const]> = input.parse()?; |
1459 | let asyncness: Option<Token![async]> = input.parse()?; |
1460 | let unsafety: Option<Token![unsafe]> = input.parse()?; |
1461 | let abi: Option<Abi> = input.parse()?; |
1462 | let fn_token: Token![fn] = input.parse()?; |
1463 | let ident: Ident = input.parse()?; |
1464 | let mut generics: Generics = input.parse()?; |
1465 | |
1466 | let content; |
1467 | let paren_token = parenthesized!(content in input); |
1468 | let (inputs, variadic) = parse_fn_args(&content)?; |
1469 | |
1470 | let output: ReturnType = input.parse()?; |
1471 | generics.where_clause = input.parse()?; |
1472 | |
1473 | Ok(Signature { |
1474 | constness, |
1475 | asyncness, |
1476 | unsafety, |
1477 | abi, |
1478 | fn_token, |
1479 | ident, |
1480 | generics, |
1481 | paren_token, |
1482 | inputs, |
1483 | variadic, |
1484 | output, |
1485 | }) |
1486 | } |
1487 | } |
1488 | |
1489 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
1490 | impl Parse for ItemFn { |
1491 | fn parse(input: ParseStream) -> Result<Self> { |
1492 | let outer_attrs = input.call(Attribute::parse_outer)?; |
1493 | let vis: Visibility = input.parse()?; |
1494 | let sig: Signature = input.parse()?; |
1495 | parse_rest_of_fn(input, outer_attrs, vis, sig) |
1496 | } |
1497 | } |
1498 | |
1499 | fn parse_rest_of_fn( |
1500 | input: ParseStream, |
1501 | mut attrs: Vec<Attribute>, |
1502 | vis: Visibility, |
1503 | sig: Signature, |
1504 | ) -> Result<ItemFn> { |
1505 | let content; |
1506 | let brace_token = braced!(content in input); |
1507 | attr::parsing::parse_inner(&content, &mut attrs)?; |
1508 | let stmts = content.call(Block::parse_within)?; |
1509 | |
1510 | Ok(ItemFn { |
1511 | attrs, |
1512 | vis, |
1513 | sig, |
1514 | block: Box::new(Block { brace_token, stmts }), |
1515 | }) |
1516 | } |
1517 | |
1518 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
1519 | impl Parse for FnArg { |
1520 | fn parse(input: ParseStream) -> Result<Self> { |
1521 | let allow_variadic = false; |
1522 | let attrs = input.call(Attribute::parse_outer)?; |
1523 | match parse_fn_arg_or_variadic(input, attrs, allow_variadic)? { |
1524 | FnArgOrVariadic::FnArg(arg) => Ok(arg), |
1525 | FnArgOrVariadic::Variadic(_) => unreachable!(), |
1526 | } |
1527 | } |
1528 | } |
1529 | |
1530 | enum FnArgOrVariadic { |
1531 | FnArg(FnArg), |
1532 | Variadic(Variadic), |
1533 | } |
1534 | |
1535 | fn parse_fn_arg_or_variadic( |
1536 | input: ParseStream, |
1537 | attrs: Vec<Attribute>, |
1538 | allow_variadic: bool, |
1539 | ) -> Result<FnArgOrVariadic> { |
1540 | let ahead = input.fork(); |
1541 | if let Ok(mut receiver) = ahead.parse::<Receiver>() { |
1542 | input.advance_to(&ahead); |
1543 | receiver.attrs = attrs; |
1544 | return Ok(FnArgOrVariadic::FnArg(FnArg::Receiver(receiver))); |
1545 | } |
1546 | |
1547 | // Hack to parse pre-2018 syntax in |
1548 | // test/ui/rfc-2565-param-attrs/param-attrs-pretty.rs |
1549 | // because the rest of the test case is valuable. |
1550 | if input.peek(Ident) && input.peek2(Token![<]) { |
1551 | let span = input.fork().parse::<Ident>()?.span(); |
1552 | return Ok(FnArgOrVariadic::FnArg(FnArg::Typed(PatType { |
1553 | attrs, |
1554 | pat: Box::new(Pat::Wild(PatWild { |
1555 | attrs: Vec::new(), |
1556 | underscore_token: Token![_](span), |
1557 | })), |
1558 | colon_token: Token![:](span), |
1559 | ty: input.parse()?, |
1560 | }))); |
1561 | } |
1562 | |
1563 | let pat = Box::new(Pat::parse_single(input)?); |
1564 | let colon_token: Token![:] = input.parse()?; |
1565 | |
1566 | if allow_variadic { |
1567 | if let Some(dots) = input.parse::<Option<Token![...]>>()? { |
1568 | return Ok(FnArgOrVariadic::Variadic(Variadic { |
1569 | attrs, |
1570 | pat: Some((pat, colon_token)), |
1571 | dots, |
1572 | comma: None, |
1573 | })); |
1574 | } |
1575 | } |
1576 | |
1577 | Ok(FnArgOrVariadic::FnArg(FnArg::Typed(PatType { |
1578 | attrs, |
1579 | pat, |
1580 | colon_token, |
1581 | ty: input.parse()?, |
1582 | }))) |
1583 | } |
1584 | |
1585 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
1586 | impl Parse for Receiver { |
1587 | fn parse(input: ParseStream) -> Result<Self> { |
1588 | let reference = if input.peek(Token![&]) { |
1589 | let ampersand: Token![&] = input.parse()?; |
1590 | let lifetime: Option<Lifetime> = input.parse()?; |
1591 | Some((ampersand, lifetime)) |
1592 | } else { |
1593 | None |
1594 | }; |
1595 | let mutability: Option<Token![mut]> = input.parse()?; |
1596 | let self_token: Token![self] = input.parse()?; |
1597 | let colon_token: Option<Token![:]> = if reference.is_some() { |
1598 | None |
1599 | } else { |
1600 | input.parse()? |
1601 | }; |
1602 | let ty: Type = if colon_token.is_some() { |
1603 | input.parse()? |
1604 | } else { |
1605 | let mut ty = Type::Path(TypePath { |
1606 | qself: None, |
1607 | path: Path::from(Ident::new("Self" , self_token.span)), |
1608 | }); |
1609 | if let Some((ampersand, lifetime)) = reference.as_ref() { |
1610 | ty = Type::Reference(TypeReference { |
1611 | and_token: Token![&](ampersand.span), |
1612 | lifetime: lifetime.clone(), |
1613 | mutability: mutability.as_ref().map(|m| Token![mut](m.span)), |
1614 | elem: Box::new(ty), |
1615 | }); |
1616 | } |
1617 | ty |
1618 | }; |
1619 | Ok(Receiver { |
1620 | attrs: Vec::new(), |
1621 | reference, |
1622 | mutability, |
1623 | self_token, |
1624 | colon_token, |
1625 | ty: Box::new(ty), |
1626 | }) |
1627 | } |
1628 | } |
1629 | |
1630 | fn parse_fn_args( |
1631 | input: ParseStream, |
1632 | ) -> Result<(Punctuated<FnArg, Token![,]>, Option<Variadic>)> { |
1633 | let mut args = Punctuated::new(); |
1634 | let mut variadic = None; |
1635 | let mut has_receiver = false; |
1636 | |
1637 | while !input.is_empty() { |
1638 | let attrs = input.call(Attribute::parse_outer)?; |
1639 | |
1640 | if let Some(dots) = input.parse::<Option<Token![...]>>()? { |
1641 | variadic = Some(Variadic { |
1642 | attrs, |
1643 | pat: None, |
1644 | dots, |
1645 | comma: if input.is_empty() { |
1646 | None |
1647 | } else { |
1648 | Some(input.parse()?) |
1649 | }, |
1650 | }); |
1651 | break; |
1652 | } |
1653 | |
1654 | let allow_variadic = true; |
1655 | let arg = match parse_fn_arg_or_variadic(input, attrs, allow_variadic)? { |
1656 | FnArgOrVariadic::FnArg(arg) => arg, |
1657 | FnArgOrVariadic::Variadic(arg) => { |
1658 | variadic = Some(Variadic { |
1659 | comma: if input.is_empty() { |
1660 | None |
1661 | } else { |
1662 | Some(input.parse()?) |
1663 | }, |
1664 | ..arg |
1665 | }); |
1666 | break; |
1667 | } |
1668 | }; |
1669 | |
1670 | match &arg { |
1671 | FnArg::Receiver(receiver) if has_receiver => { |
1672 | return Err(Error::new( |
1673 | receiver.self_token.span, |
1674 | "unexpected second method receiver" , |
1675 | )); |
1676 | } |
1677 | FnArg::Receiver(receiver) if !args.is_empty() => { |
1678 | return Err(Error::new( |
1679 | receiver.self_token.span, |
1680 | "unexpected method receiver" , |
1681 | )); |
1682 | } |
1683 | FnArg::Receiver(_) => has_receiver = true, |
1684 | FnArg::Typed(_) => {} |
1685 | } |
1686 | args.push_value(arg); |
1687 | |
1688 | if input.is_empty() { |
1689 | break; |
1690 | } |
1691 | |
1692 | let comma: Token![,] = input.parse()?; |
1693 | args.push_punct(comma); |
1694 | } |
1695 | |
1696 | Ok((args, variadic)) |
1697 | } |
1698 | |
1699 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
1700 | impl Parse for ItemMod { |
1701 | fn parse(input: ParseStream) -> Result<Self> { |
1702 | let mut attrs = input.call(Attribute::parse_outer)?; |
1703 | let vis: Visibility = input.parse()?; |
1704 | let unsafety: Option<Token![unsafe]> = input.parse()?; |
1705 | let mod_token: Token![mod] = input.parse()?; |
1706 | let ident: Ident = if input.peek(Token![try]) { |
1707 | input.call(Ident::parse_any) |
1708 | } else { |
1709 | input.parse() |
1710 | }?; |
1711 | |
1712 | let lookahead = input.lookahead1(); |
1713 | if lookahead.peek(Token![;]) { |
1714 | Ok(ItemMod { |
1715 | attrs, |
1716 | vis, |
1717 | unsafety, |
1718 | mod_token, |
1719 | ident, |
1720 | content: None, |
1721 | semi: Some(input.parse()?), |
1722 | }) |
1723 | } else if lookahead.peek(token::Brace) { |
1724 | let content; |
1725 | let brace_token = braced!(content in input); |
1726 | attr::parsing::parse_inner(&content, &mut attrs)?; |
1727 | |
1728 | let mut items = Vec::new(); |
1729 | while !content.is_empty() { |
1730 | items.push(content.parse()?); |
1731 | } |
1732 | |
1733 | Ok(ItemMod { |
1734 | attrs, |
1735 | vis, |
1736 | unsafety, |
1737 | mod_token, |
1738 | ident, |
1739 | content: Some((brace_token, items)), |
1740 | semi: None, |
1741 | }) |
1742 | } else { |
1743 | Err(lookahead.error()) |
1744 | } |
1745 | } |
1746 | } |
1747 | |
1748 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
1749 | impl Parse for ItemForeignMod { |
1750 | fn parse(input: ParseStream) -> Result<Self> { |
1751 | let mut attrs = input.call(Attribute::parse_outer)?; |
1752 | let unsafety: Option<Token![unsafe]> = input.parse()?; |
1753 | let abi: Abi = input.parse()?; |
1754 | |
1755 | let content; |
1756 | let brace_token = braced!(content in input); |
1757 | attr::parsing::parse_inner(&content, &mut attrs)?; |
1758 | let mut items = Vec::new(); |
1759 | while !content.is_empty() { |
1760 | items.push(content.parse()?); |
1761 | } |
1762 | |
1763 | Ok(ItemForeignMod { |
1764 | attrs, |
1765 | unsafety, |
1766 | abi, |
1767 | brace_token, |
1768 | items, |
1769 | }) |
1770 | } |
1771 | } |
1772 | |
1773 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
1774 | impl Parse for ForeignItem { |
1775 | fn parse(input: ParseStream) -> Result<Self> { |
1776 | let begin = input.fork(); |
1777 | let mut attrs = input.call(Attribute::parse_outer)?; |
1778 | let ahead = input.fork(); |
1779 | let vis: Visibility = ahead.parse()?; |
1780 | |
1781 | let lookahead = ahead.lookahead1(); |
1782 | let mut item = if lookahead.peek(Token![fn]) || peek_signature(&ahead) { |
1783 | let vis: Visibility = input.parse()?; |
1784 | let sig: Signature = input.parse()?; |
1785 | if input.peek(token::Brace) { |
1786 | let content; |
1787 | braced!(content in input); |
1788 | content.call(Attribute::parse_inner)?; |
1789 | content.call(Block::parse_within)?; |
1790 | |
1791 | Ok(ForeignItem::Verbatim(verbatim::between(&begin, input))) |
1792 | } else { |
1793 | Ok(ForeignItem::Fn(ForeignItemFn { |
1794 | attrs: Vec::new(), |
1795 | vis, |
1796 | sig, |
1797 | semi_token: input.parse()?, |
1798 | })) |
1799 | } |
1800 | } else if lookahead.peek(Token![static]) { |
1801 | let vis = input.parse()?; |
1802 | let static_token = input.parse()?; |
1803 | let mutability = input.parse()?; |
1804 | let ident = input.parse()?; |
1805 | let colon_token = input.parse()?; |
1806 | let ty = input.parse()?; |
1807 | if input.peek(Token![=]) { |
1808 | input.parse::<Token![=]>()?; |
1809 | input.parse::<Expr>()?; |
1810 | input.parse::<Token![;]>()?; |
1811 | Ok(ForeignItem::Verbatim(verbatim::between(&begin, input))) |
1812 | } else { |
1813 | Ok(ForeignItem::Static(ForeignItemStatic { |
1814 | attrs: Vec::new(), |
1815 | vis, |
1816 | static_token, |
1817 | mutability, |
1818 | ident, |
1819 | colon_token, |
1820 | ty, |
1821 | semi_token: input.parse()?, |
1822 | })) |
1823 | } |
1824 | } else if lookahead.peek(Token![type]) { |
1825 | parse_foreign_item_type(begin, input) |
1826 | } else if vis.is_inherited() |
1827 | && (lookahead.peek(Ident) |
1828 | || lookahead.peek(Token![self]) |
1829 | || lookahead.peek(Token![super]) |
1830 | || lookahead.peek(Token![crate]) |
1831 | || lookahead.peek(Token![::])) |
1832 | { |
1833 | input.parse().map(ForeignItem::Macro) |
1834 | } else { |
1835 | Err(lookahead.error()) |
1836 | }?; |
1837 | |
1838 | let item_attrs = match &mut item { |
1839 | ForeignItem::Fn(item) => &mut item.attrs, |
1840 | ForeignItem::Static(item) => &mut item.attrs, |
1841 | ForeignItem::Type(item) => &mut item.attrs, |
1842 | ForeignItem::Macro(item) => &mut item.attrs, |
1843 | ForeignItem::Verbatim(_) => return Ok(item), |
1844 | }; |
1845 | attrs.append(item_attrs); |
1846 | *item_attrs = attrs; |
1847 | |
1848 | Ok(item) |
1849 | } |
1850 | } |
1851 | |
1852 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
1853 | impl Parse for ForeignItemFn { |
1854 | fn parse(input: ParseStream) -> Result<Self> { |
1855 | let attrs = input.call(Attribute::parse_outer)?; |
1856 | let vis: Visibility = input.parse()?; |
1857 | let sig: Signature = input.parse()?; |
1858 | let semi_token: Token![;] = input.parse()?; |
1859 | Ok(ForeignItemFn { |
1860 | attrs, |
1861 | vis, |
1862 | sig, |
1863 | semi_token, |
1864 | }) |
1865 | } |
1866 | } |
1867 | |
1868 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
1869 | impl Parse for ForeignItemStatic { |
1870 | fn parse(input: ParseStream) -> Result<Self> { |
1871 | Ok(ForeignItemStatic { |
1872 | attrs: input.call(Attribute::parse_outer)?, |
1873 | vis: input.parse()?, |
1874 | static_token: input.parse()?, |
1875 | mutability: input.parse()?, |
1876 | ident: input.parse()?, |
1877 | colon_token: input.parse()?, |
1878 | ty: input.parse()?, |
1879 | semi_token: input.parse()?, |
1880 | }) |
1881 | } |
1882 | } |
1883 | |
1884 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
1885 | impl Parse for ForeignItemType { |
1886 | fn parse(input: ParseStream) -> Result<Self> { |
1887 | Ok(ForeignItemType { |
1888 | attrs: input.call(Attribute::parse_outer)?, |
1889 | vis: input.parse()?, |
1890 | type_token: input.parse()?, |
1891 | ident: input.parse()?, |
1892 | generics: { |
1893 | let mut generics: Generics = input.parse()?; |
1894 | generics.where_clause = input.parse()?; |
1895 | generics |
1896 | }, |
1897 | semi_token: input.parse()?, |
1898 | }) |
1899 | } |
1900 | } |
1901 | |
1902 | fn parse_foreign_item_type(begin: ParseBuffer, input: ParseStream) -> Result<ForeignItem> { |
1903 | let FlexibleItemType { |
1904 | vis, |
1905 | defaultness: _, |
1906 | type_token, |
1907 | ident, |
1908 | generics, |
1909 | colon_token, |
1910 | bounds: _, |
1911 | ty, |
1912 | semi_token, |
1913 | } = FlexibleItemType::parse( |
1914 | input, |
1915 | TypeDefaultness::Disallowed, |
1916 | WhereClauseLocation::Both, |
1917 | )?; |
1918 | |
1919 | if colon_token.is_some() || ty.is_some() { |
1920 | Ok(ForeignItem::Verbatim(verbatim::between(&begin, input))) |
1921 | } else { |
1922 | Ok(ForeignItem::Type(ForeignItemType { |
1923 | attrs: Vec::new(), |
1924 | vis, |
1925 | type_token, |
1926 | ident, |
1927 | generics, |
1928 | semi_token, |
1929 | })) |
1930 | } |
1931 | } |
1932 | |
1933 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
1934 | impl Parse for ForeignItemMacro { |
1935 | fn parse(input: ParseStream) -> Result<Self> { |
1936 | let attrs = input.call(Attribute::parse_outer)?; |
1937 | let mac: Macro = input.parse()?; |
1938 | let semi_token: Option<Token![;]> = if mac.delimiter.is_brace() { |
1939 | None |
1940 | } else { |
1941 | Some(input.parse()?) |
1942 | }; |
1943 | Ok(ForeignItemMacro { |
1944 | attrs, |
1945 | mac, |
1946 | semi_token, |
1947 | }) |
1948 | } |
1949 | } |
1950 | |
1951 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
1952 | impl Parse for ItemType { |
1953 | fn parse(input: ParseStream) -> Result<Self> { |
1954 | Ok(ItemType { |
1955 | attrs: input.call(Attribute::parse_outer)?, |
1956 | vis: input.parse()?, |
1957 | type_token: input.parse()?, |
1958 | ident: input.parse()?, |
1959 | generics: { |
1960 | let mut generics: Generics = input.parse()?; |
1961 | generics.where_clause = input.parse()?; |
1962 | generics |
1963 | }, |
1964 | eq_token: input.parse()?, |
1965 | ty: input.parse()?, |
1966 | semi_token: input.parse()?, |
1967 | }) |
1968 | } |
1969 | } |
1970 | |
1971 | fn parse_item_type(begin: ParseBuffer, input: ParseStream) -> Result<Item> { |
1972 | let FlexibleItemType { |
1973 | vis, |
1974 | defaultness: _, |
1975 | type_token, |
1976 | ident, |
1977 | generics, |
1978 | colon_token, |
1979 | bounds: _, |
1980 | ty, |
1981 | semi_token, |
1982 | } = FlexibleItemType::parse( |
1983 | input, |
1984 | TypeDefaultness::Disallowed, |
1985 | WhereClauseLocation::BeforeEq, |
1986 | )?; |
1987 | |
1988 | let (eq_token, ty) = match ty { |
1989 | Some(ty) if colon_token.is_none() => ty, |
1990 | _ => return Ok(Item::Verbatim(verbatim::between(&begin, input))), |
1991 | }; |
1992 | |
1993 | Ok(Item::Type(ItemType { |
1994 | attrs: Vec::new(), |
1995 | vis, |
1996 | type_token, |
1997 | ident, |
1998 | generics, |
1999 | eq_token, |
2000 | ty: Box::new(ty), |
2001 | semi_token, |
2002 | })) |
2003 | } |
2004 | |
2005 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
2006 | impl Parse for ItemStruct { |
2007 | fn parse(input: ParseStream) -> Result<Self> { |
2008 | let attrs = input.call(Attribute::parse_outer)?; |
2009 | let vis = input.parse::<Visibility>()?; |
2010 | let struct_token = input.parse::<Token![struct]>()?; |
2011 | let ident = input.parse::<Ident>()?; |
2012 | let generics = input.parse::<Generics>()?; |
2013 | let (where_clause, fields, semi_token) = derive::parsing::data_struct(input)?; |
2014 | Ok(ItemStruct { |
2015 | attrs, |
2016 | vis, |
2017 | struct_token, |
2018 | ident, |
2019 | generics: Generics { |
2020 | where_clause, |
2021 | ..generics |
2022 | }, |
2023 | fields, |
2024 | semi_token, |
2025 | }) |
2026 | } |
2027 | } |
2028 | |
2029 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
2030 | impl Parse for ItemEnum { |
2031 | fn parse(input: ParseStream) -> Result<Self> { |
2032 | let attrs = input.call(Attribute::parse_outer)?; |
2033 | let vis = input.parse::<Visibility>()?; |
2034 | let enum_token = input.parse::<Token![enum]>()?; |
2035 | let ident = input.parse::<Ident>()?; |
2036 | let generics = input.parse::<Generics>()?; |
2037 | let (where_clause, brace_token, variants) = derive::parsing::data_enum(input)?; |
2038 | Ok(ItemEnum { |
2039 | attrs, |
2040 | vis, |
2041 | enum_token, |
2042 | ident, |
2043 | generics: Generics { |
2044 | where_clause, |
2045 | ..generics |
2046 | }, |
2047 | brace_token, |
2048 | variants, |
2049 | }) |
2050 | } |
2051 | } |
2052 | |
2053 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
2054 | impl Parse for ItemUnion { |
2055 | fn parse(input: ParseStream) -> Result<Self> { |
2056 | let attrs = input.call(Attribute::parse_outer)?; |
2057 | let vis = input.parse::<Visibility>()?; |
2058 | let union_token = input.parse::<Token![union]>()?; |
2059 | let ident = input.parse::<Ident>()?; |
2060 | let generics = input.parse::<Generics>()?; |
2061 | let (where_clause, fields) = derive::parsing::data_union(input)?; |
2062 | Ok(ItemUnion { |
2063 | attrs, |
2064 | vis, |
2065 | union_token, |
2066 | ident, |
2067 | generics: Generics { |
2068 | where_clause, |
2069 | ..generics |
2070 | }, |
2071 | fields, |
2072 | }) |
2073 | } |
2074 | } |
2075 | |
2076 | fn parse_trait_or_trait_alias(input: ParseStream) -> Result<Item> { |
2077 | let (attrs, vis, trait_token, ident, generics) = parse_start_of_trait_alias(input)?; |
2078 | let lookahead = input.lookahead1(); |
2079 | if lookahead.peek(token::Brace) |
2080 | || lookahead.peek(Token![:]) |
2081 | || lookahead.peek(Token![where]) |
2082 | { |
2083 | let unsafety = None; |
2084 | let auto_token = None; |
2085 | parse_rest_of_trait( |
2086 | input, |
2087 | attrs, |
2088 | vis, |
2089 | unsafety, |
2090 | auto_token, |
2091 | trait_token, |
2092 | ident, |
2093 | generics, |
2094 | ) |
2095 | .map(Item::Trait) |
2096 | } else if lookahead.peek(Token![=]) { |
2097 | parse_rest_of_trait_alias(input, attrs, vis, trait_token, ident, generics) |
2098 | .map(Item::TraitAlias) |
2099 | } else { |
2100 | Err(lookahead.error()) |
2101 | } |
2102 | } |
2103 | |
2104 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
2105 | impl Parse for ItemTrait { |
2106 | fn parse(input: ParseStream) -> Result<Self> { |
2107 | let outer_attrs = input.call(Attribute::parse_outer)?; |
2108 | let vis: Visibility = input.parse()?; |
2109 | let unsafety: Option<Token![unsafe]> = input.parse()?; |
2110 | let auto_token: Option<Token![auto]> = input.parse()?; |
2111 | let trait_token: Token![trait] = input.parse()?; |
2112 | let ident: Ident = input.parse()?; |
2113 | let generics: Generics = input.parse()?; |
2114 | parse_rest_of_trait( |
2115 | input, |
2116 | outer_attrs, |
2117 | vis, |
2118 | unsafety, |
2119 | auto_token, |
2120 | trait_token, |
2121 | ident, |
2122 | generics, |
2123 | ) |
2124 | } |
2125 | } |
2126 | |
2127 | fn parse_rest_of_trait( |
2128 | input: ParseStream, |
2129 | mut attrs: Vec<Attribute>, |
2130 | vis: Visibility, |
2131 | unsafety: Option<Token![unsafe]>, |
2132 | auto_token: Option<Token![auto]>, |
2133 | trait_token: Token![trait], |
2134 | ident: Ident, |
2135 | mut generics: Generics, |
2136 | ) -> Result<ItemTrait> { |
2137 | let colon_token: Option<Token![:]> = input.parse()?; |
2138 | |
2139 | let mut supertraits = Punctuated::new(); |
2140 | if colon_token.is_some() { |
2141 | loop { |
2142 | if input.peek(Token![where]) || input.peek(token::Brace) { |
2143 | break; |
2144 | } |
2145 | supertraits.push_value(input.parse()?); |
2146 | if input.peek(Token![where]) || input.peek(token::Brace) { |
2147 | break; |
2148 | } |
2149 | supertraits.push_punct(input.parse()?); |
2150 | } |
2151 | } |
2152 | |
2153 | generics.where_clause = input.parse()?; |
2154 | |
2155 | let content; |
2156 | let brace_token = braced!(content in input); |
2157 | attr::parsing::parse_inner(&content, &mut attrs)?; |
2158 | let mut items = Vec::new(); |
2159 | while !content.is_empty() { |
2160 | items.push(content.parse()?); |
2161 | } |
2162 | |
2163 | Ok(ItemTrait { |
2164 | attrs, |
2165 | vis, |
2166 | unsafety, |
2167 | auto_token, |
2168 | restriction: None, |
2169 | trait_token, |
2170 | ident, |
2171 | generics, |
2172 | colon_token, |
2173 | supertraits, |
2174 | brace_token, |
2175 | items, |
2176 | }) |
2177 | } |
2178 | |
2179 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
2180 | impl Parse for ItemTraitAlias { |
2181 | fn parse(input: ParseStream) -> Result<Self> { |
2182 | let (attrs, vis, trait_token, ident, generics) = parse_start_of_trait_alias(input)?; |
2183 | parse_rest_of_trait_alias(input, attrs, vis, trait_token, ident, generics) |
2184 | } |
2185 | } |
2186 | |
2187 | fn parse_start_of_trait_alias( |
2188 | input: ParseStream, |
2189 | ) -> Result<(Vec<Attribute>, Visibility, Token![trait], Ident, Generics)> { |
2190 | let attrs = input.call(Attribute::parse_outer)?; |
2191 | let vis: Visibility = input.parse()?; |
2192 | let trait_token: Token![trait] = input.parse()?; |
2193 | let ident: Ident = input.parse()?; |
2194 | let generics: Generics = input.parse()?; |
2195 | Ok((attrs, vis, trait_token, ident, generics)) |
2196 | } |
2197 | |
2198 | fn parse_rest_of_trait_alias( |
2199 | input: ParseStream, |
2200 | attrs: Vec<Attribute>, |
2201 | vis: Visibility, |
2202 | trait_token: Token![trait], |
2203 | ident: Ident, |
2204 | mut generics: Generics, |
2205 | ) -> Result<ItemTraitAlias> { |
2206 | let eq_token: Token![=] = input.parse()?; |
2207 | |
2208 | let mut bounds = Punctuated::new(); |
2209 | loop { |
2210 | if input.peek(Token![where]) || input.peek(Token![;]) { |
2211 | break; |
2212 | } |
2213 | bounds.push_value(input.parse()?); |
2214 | if input.peek(Token![where]) || input.peek(Token![;]) { |
2215 | break; |
2216 | } |
2217 | bounds.push_punct(input.parse()?); |
2218 | } |
2219 | |
2220 | generics.where_clause = input.parse()?; |
2221 | let semi_token: Token![;] = input.parse()?; |
2222 | |
2223 | Ok(ItemTraitAlias { |
2224 | attrs, |
2225 | vis, |
2226 | trait_token, |
2227 | ident, |
2228 | generics, |
2229 | eq_token, |
2230 | bounds, |
2231 | semi_token, |
2232 | }) |
2233 | } |
2234 | |
2235 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
2236 | impl Parse for TraitItem { |
2237 | fn parse(input: ParseStream) -> Result<Self> { |
2238 | let begin = input.fork(); |
2239 | let mut attrs = input.call(Attribute::parse_outer)?; |
2240 | let vis: Visibility = input.parse()?; |
2241 | let defaultness: Option<Token![default]> = input.parse()?; |
2242 | let ahead = input.fork(); |
2243 | |
2244 | let lookahead = ahead.lookahead1(); |
2245 | let mut item = if lookahead.peek(Token![fn]) || peek_signature(&ahead) { |
2246 | input.parse().map(TraitItem::Fn) |
2247 | } else if lookahead.peek(Token![const]) { |
2248 | let const_token: Token![const] = ahead.parse()?; |
2249 | let lookahead = ahead.lookahead1(); |
2250 | if lookahead.peek(Ident) || lookahead.peek(Token![_]) { |
2251 | input.advance_to(&ahead); |
2252 | let ident = input.call(Ident::parse_any)?; |
2253 | let mut generics: Generics = input.parse()?; |
2254 | let colon_token: Token![:] = input.parse()?; |
2255 | let ty: Type = input.parse()?; |
2256 | let default = if let Some(eq_token) = input.parse::<Option<Token![=]>>()? { |
2257 | let expr: Expr = input.parse()?; |
2258 | Some((eq_token, expr)) |
2259 | } else { |
2260 | None |
2261 | }; |
2262 | generics.where_clause = input.parse()?; |
2263 | let semi_token: Token![;] = input.parse()?; |
2264 | if generics.lt_token.is_none() && generics.where_clause.is_none() { |
2265 | Ok(TraitItem::Const(TraitItemConst { |
2266 | attrs: Vec::new(), |
2267 | const_token, |
2268 | ident, |
2269 | generics, |
2270 | colon_token, |
2271 | ty, |
2272 | default, |
2273 | semi_token, |
2274 | })) |
2275 | } else { |
2276 | return Ok(TraitItem::Verbatim(verbatim::between(&begin, input))); |
2277 | } |
2278 | } else if lookahead.peek(Token![async]) |
2279 | || lookahead.peek(Token![unsafe]) |
2280 | || lookahead.peek(Token![extern]) |
2281 | || lookahead.peek(Token![fn]) |
2282 | { |
2283 | input.parse().map(TraitItem::Fn) |
2284 | } else { |
2285 | Err(lookahead.error()) |
2286 | } |
2287 | } else if lookahead.peek(Token![type]) { |
2288 | parse_trait_item_type(begin.fork(), input) |
2289 | } else if vis.is_inherited() |
2290 | && defaultness.is_none() |
2291 | && (lookahead.peek(Ident) |
2292 | || lookahead.peek(Token![self]) |
2293 | || lookahead.peek(Token![super]) |
2294 | || lookahead.peek(Token![crate]) |
2295 | || lookahead.peek(Token![::])) |
2296 | { |
2297 | input.parse().map(TraitItem::Macro) |
2298 | } else { |
2299 | Err(lookahead.error()) |
2300 | }?; |
2301 | |
2302 | match (vis, defaultness) { |
2303 | (Visibility::Inherited, None) => {} |
2304 | _ => return Ok(TraitItem::Verbatim(verbatim::between(&begin, input))), |
2305 | } |
2306 | |
2307 | let item_attrs = match &mut item { |
2308 | TraitItem::Const(item) => &mut item.attrs, |
2309 | TraitItem::Fn(item) => &mut item.attrs, |
2310 | TraitItem::Type(item) => &mut item.attrs, |
2311 | TraitItem::Macro(item) => &mut item.attrs, |
2312 | TraitItem::Verbatim(_) => unreachable!(), |
2313 | }; |
2314 | attrs.append(item_attrs); |
2315 | *item_attrs = attrs; |
2316 | Ok(item) |
2317 | } |
2318 | } |
2319 | |
2320 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
2321 | impl Parse for TraitItemConst { |
2322 | fn parse(input: ParseStream) -> Result<Self> { |
2323 | let attrs = input.call(Attribute::parse_outer)?; |
2324 | let const_token: Token![const] = input.parse()?; |
2325 | |
2326 | let lookahead = input.lookahead1(); |
2327 | let ident = if lookahead.peek(Ident) || lookahead.peek(Token![_]) { |
2328 | input.call(Ident::parse_any)? |
2329 | } else { |
2330 | return Err(lookahead.error()); |
2331 | }; |
2332 | |
2333 | let colon_token: Token![:] = input.parse()?; |
2334 | let ty: Type = input.parse()?; |
2335 | let default = if input.peek(Token![=]) { |
2336 | let eq_token: Token![=] = input.parse()?; |
2337 | let default: Expr = input.parse()?; |
2338 | Some((eq_token, default)) |
2339 | } else { |
2340 | None |
2341 | }; |
2342 | let semi_token: Token![;] = input.parse()?; |
2343 | |
2344 | Ok(TraitItemConst { |
2345 | attrs, |
2346 | const_token, |
2347 | ident, |
2348 | generics: Generics::default(), |
2349 | colon_token, |
2350 | ty, |
2351 | default, |
2352 | semi_token, |
2353 | }) |
2354 | } |
2355 | } |
2356 | |
2357 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
2358 | impl Parse for TraitItemFn { |
2359 | fn parse(input: ParseStream) -> Result<Self> { |
2360 | let mut attrs = input.call(Attribute::parse_outer)?; |
2361 | let sig: Signature = input.parse()?; |
2362 | |
2363 | let lookahead = input.lookahead1(); |
2364 | let (brace_token, stmts, semi_token) = if lookahead.peek(token::Brace) { |
2365 | let content; |
2366 | let brace_token = braced!(content in input); |
2367 | attr::parsing::parse_inner(&content, &mut attrs)?; |
2368 | let stmts = content.call(Block::parse_within)?; |
2369 | (Some(brace_token), stmts, None) |
2370 | } else if lookahead.peek(Token![;]) { |
2371 | let semi_token: Token![;] = input.parse()?; |
2372 | (None, Vec::new(), Some(semi_token)) |
2373 | } else { |
2374 | return Err(lookahead.error()); |
2375 | }; |
2376 | |
2377 | Ok(TraitItemFn { |
2378 | attrs, |
2379 | sig, |
2380 | default: brace_token.map(|brace_token| Block { brace_token, stmts }), |
2381 | semi_token, |
2382 | }) |
2383 | } |
2384 | } |
2385 | |
2386 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
2387 | impl Parse for TraitItemType { |
2388 | fn parse(input: ParseStream) -> Result<Self> { |
2389 | let attrs = input.call(Attribute::parse_outer)?; |
2390 | let type_token: Token![type] = input.parse()?; |
2391 | let ident: Ident = input.parse()?; |
2392 | let mut generics: Generics = input.parse()?; |
2393 | let (colon_token, bounds) = FlexibleItemType::parse_optional_bounds(input)?; |
2394 | let default = FlexibleItemType::parse_optional_definition(input)?; |
2395 | generics.where_clause = input.parse()?; |
2396 | let semi_token: Token![;] = input.parse()?; |
2397 | Ok(TraitItemType { |
2398 | attrs, |
2399 | type_token, |
2400 | ident, |
2401 | generics, |
2402 | colon_token, |
2403 | bounds, |
2404 | default, |
2405 | semi_token, |
2406 | }) |
2407 | } |
2408 | } |
2409 | |
2410 | fn parse_trait_item_type(begin: ParseBuffer, input: ParseStream) -> Result<TraitItem> { |
2411 | let FlexibleItemType { |
2412 | vis, |
2413 | defaultness: _, |
2414 | type_token, |
2415 | ident, |
2416 | generics, |
2417 | colon_token, |
2418 | bounds, |
2419 | ty, |
2420 | semi_token, |
2421 | } = FlexibleItemType::parse( |
2422 | input, |
2423 | TypeDefaultness::Disallowed, |
2424 | WhereClauseLocation::AfterEq, |
2425 | )?; |
2426 | |
2427 | if vis.is_some() { |
2428 | Ok(TraitItem::Verbatim(verbatim::between(&begin, input))) |
2429 | } else { |
2430 | Ok(TraitItem::Type(TraitItemType { |
2431 | attrs: Vec::new(), |
2432 | type_token, |
2433 | ident, |
2434 | generics, |
2435 | colon_token, |
2436 | bounds, |
2437 | default: ty, |
2438 | semi_token, |
2439 | })) |
2440 | } |
2441 | } |
2442 | |
2443 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
2444 | impl Parse for TraitItemMacro { |
2445 | fn parse(input: ParseStream) -> Result<Self> { |
2446 | let attrs = input.call(Attribute::parse_outer)?; |
2447 | let mac: Macro = input.parse()?; |
2448 | let semi_token: Option<Token![;]> = if mac.delimiter.is_brace() { |
2449 | None |
2450 | } else { |
2451 | Some(input.parse()?) |
2452 | }; |
2453 | Ok(TraitItemMacro { |
2454 | attrs, |
2455 | mac, |
2456 | semi_token, |
2457 | }) |
2458 | } |
2459 | } |
2460 | |
2461 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
2462 | impl Parse for ItemImpl { |
2463 | fn parse(input: ParseStream) -> Result<Self> { |
2464 | let allow_verbatim_impl = false; |
2465 | parse_impl(input, allow_verbatim_impl).map(Option::unwrap) |
2466 | } |
2467 | } |
2468 | |
2469 | fn parse_impl(input: ParseStream, allow_verbatim_impl: bool) -> Result<Option<ItemImpl>> { |
2470 | let mut attrs = input.call(Attribute::parse_outer)?; |
2471 | let has_visibility = allow_verbatim_impl && input.parse::<Visibility>()?.is_some(); |
2472 | let defaultness: Option<Token![default]> = input.parse()?; |
2473 | let unsafety: Option<Token![unsafe]> = input.parse()?; |
2474 | let impl_token: Token![impl] = input.parse()?; |
2475 | |
2476 | let has_generics = input.peek(Token![<]) |
2477 | && (input.peek2(Token![>]) |
2478 | || input.peek2(Token![#]) |
2479 | || (input.peek2(Ident) || input.peek2(Lifetime)) |
2480 | && (input.peek3(Token![:]) |
2481 | || input.peek3(Token![,]) |
2482 | || input.peek3(Token![>]) |
2483 | || input.peek3(Token![=])) |
2484 | || input.peek2(Token![const])); |
2485 | let mut generics: Generics = if has_generics { |
2486 | input.parse()? |
2487 | } else { |
2488 | Generics::default() |
2489 | }; |
2490 | |
2491 | let is_const_impl = allow_verbatim_impl |
2492 | && (input.peek(Token![const]) || input.peek(Token![?]) && input.peek2(Token![const])); |
2493 | if is_const_impl { |
2494 | input.parse::<Option<Token![?]>>()?; |
2495 | input.parse::<Token![const]>()?; |
2496 | } |
2497 | |
2498 | let begin = input.fork(); |
2499 | let polarity = if input.peek(Token![!]) && !input.peek2(token::Brace) { |
2500 | Some(input.parse::<Token![!]>()?) |
2501 | } else { |
2502 | None |
2503 | }; |
2504 | |
2505 | #[cfg (not(feature = "printing" ))] |
2506 | let first_ty_span = input.span(); |
2507 | let mut first_ty: Type = input.parse()?; |
2508 | let self_ty: Type; |
2509 | let trait_; |
2510 | |
2511 | let is_impl_for = input.peek(Token![for]); |
2512 | if is_impl_for { |
2513 | let for_token: Token![for] = input.parse()?; |
2514 | let mut first_ty_ref = &first_ty; |
2515 | while let Type::Group(ty) = first_ty_ref { |
2516 | first_ty_ref = &ty.elem; |
2517 | } |
2518 | if let Type::Path(TypePath { qself: None, .. }) = first_ty_ref { |
2519 | while let Type::Group(ty) = first_ty { |
2520 | first_ty = *ty.elem; |
2521 | } |
2522 | if let Type::Path(TypePath { qself: None, path }) = first_ty { |
2523 | trait_ = Some((polarity, path, for_token)); |
2524 | } else { |
2525 | unreachable!(); |
2526 | } |
2527 | } else if !allow_verbatim_impl { |
2528 | #[cfg (feature = "printing" )] |
2529 | return Err(Error::new_spanned(first_ty_ref, "expected trait path" )); |
2530 | #[cfg (not(feature = "printing" ))] |
2531 | return Err(Error::new(first_ty_span, "expected trait path" )); |
2532 | } else { |
2533 | trait_ = None; |
2534 | } |
2535 | self_ty = input.parse()?; |
2536 | } else { |
2537 | trait_ = None; |
2538 | self_ty = if polarity.is_none() { |
2539 | first_ty |
2540 | } else { |
2541 | Type::Verbatim(verbatim::between(&begin, input)) |
2542 | }; |
2543 | } |
2544 | |
2545 | generics.where_clause = input.parse()?; |
2546 | |
2547 | let content; |
2548 | let brace_token = braced!(content in input); |
2549 | attr::parsing::parse_inner(&content, &mut attrs)?; |
2550 | |
2551 | let mut items = Vec::new(); |
2552 | while !content.is_empty() { |
2553 | items.push(content.parse()?); |
2554 | } |
2555 | |
2556 | if has_visibility || is_const_impl || is_impl_for && trait_.is_none() { |
2557 | Ok(None) |
2558 | } else { |
2559 | Ok(Some(ItemImpl { |
2560 | attrs, |
2561 | defaultness, |
2562 | unsafety, |
2563 | impl_token, |
2564 | generics, |
2565 | trait_, |
2566 | self_ty: Box::new(self_ty), |
2567 | brace_token, |
2568 | items, |
2569 | })) |
2570 | } |
2571 | } |
2572 | |
2573 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
2574 | impl Parse for ImplItem { |
2575 | fn parse(input: ParseStream) -> Result<Self> { |
2576 | let begin = input.fork(); |
2577 | let mut attrs = input.call(Attribute::parse_outer)?; |
2578 | let ahead = input.fork(); |
2579 | let vis: Visibility = ahead.parse()?; |
2580 | |
2581 | let mut lookahead = ahead.lookahead1(); |
2582 | let defaultness = if lookahead.peek(Token![default]) && !ahead.peek2(Token![!]) { |
2583 | let defaultness: Token![default] = ahead.parse()?; |
2584 | lookahead = ahead.lookahead1(); |
2585 | Some(defaultness) |
2586 | } else { |
2587 | None |
2588 | }; |
2589 | |
2590 | let mut item = if lookahead.peek(Token![fn]) || peek_signature(&ahead) { |
2591 | let allow_omitted_body = true; |
2592 | if let Some(item) = parse_impl_item_fn(input, allow_omitted_body)? { |
2593 | Ok(ImplItem::Fn(item)) |
2594 | } else { |
2595 | Ok(ImplItem::Verbatim(verbatim::between(&begin, input))) |
2596 | } |
2597 | } else if lookahead.peek(Token![const]) { |
2598 | input.advance_to(&ahead); |
2599 | let const_token: Token![const] = input.parse()?; |
2600 | let lookahead = input.lookahead1(); |
2601 | let ident = if lookahead.peek(Ident) || lookahead.peek(Token![_]) { |
2602 | input.call(Ident::parse_any)? |
2603 | } else { |
2604 | return Err(lookahead.error()); |
2605 | }; |
2606 | let mut generics: Generics = input.parse()?; |
2607 | let colon_token: Token![:] = input.parse()?; |
2608 | let ty: Type = input.parse()?; |
2609 | let value = if let Some(eq_token) = input.parse::<Option<Token![=]>>()? { |
2610 | let expr: Expr = input.parse()?; |
2611 | Some((eq_token, expr)) |
2612 | } else { |
2613 | None |
2614 | }; |
2615 | generics.where_clause = input.parse()?; |
2616 | let semi_token: Token![;] = input.parse()?; |
2617 | return match value { |
2618 | Some((eq_token, expr)) |
2619 | if generics.lt_token.is_none() && generics.where_clause.is_none() => |
2620 | { |
2621 | Ok(ImplItem::Const(ImplItemConst { |
2622 | attrs, |
2623 | vis, |
2624 | defaultness, |
2625 | const_token, |
2626 | ident, |
2627 | generics, |
2628 | colon_token, |
2629 | ty, |
2630 | eq_token, |
2631 | expr, |
2632 | semi_token, |
2633 | })) |
2634 | } |
2635 | _ => Ok(ImplItem::Verbatim(verbatim::between(&begin, input))), |
2636 | }; |
2637 | } else if lookahead.peek(Token![type]) { |
2638 | parse_impl_item_type(begin, input) |
2639 | } else if vis.is_inherited() |
2640 | && defaultness.is_none() |
2641 | && (lookahead.peek(Ident) |
2642 | || lookahead.peek(Token![self]) |
2643 | || lookahead.peek(Token![super]) |
2644 | || lookahead.peek(Token![crate]) |
2645 | || lookahead.peek(Token![::])) |
2646 | { |
2647 | input.parse().map(ImplItem::Macro) |
2648 | } else { |
2649 | Err(lookahead.error()) |
2650 | }?; |
2651 | |
2652 | { |
2653 | let item_attrs = match &mut item { |
2654 | ImplItem::Const(item) => &mut item.attrs, |
2655 | ImplItem::Fn(item) => &mut item.attrs, |
2656 | ImplItem::Type(item) => &mut item.attrs, |
2657 | ImplItem::Macro(item) => &mut item.attrs, |
2658 | ImplItem::Verbatim(_) => return Ok(item), |
2659 | }; |
2660 | attrs.append(item_attrs); |
2661 | *item_attrs = attrs; |
2662 | } |
2663 | |
2664 | Ok(item) |
2665 | } |
2666 | } |
2667 | |
2668 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
2669 | impl Parse for ImplItemConst { |
2670 | fn parse(input: ParseStream) -> Result<Self> { |
2671 | let attrs = input.call(Attribute::parse_outer)?; |
2672 | let vis: Visibility = input.parse()?; |
2673 | let defaultness: Option<Token![default]> = input.parse()?; |
2674 | let const_token: Token![const] = input.parse()?; |
2675 | |
2676 | let lookahead = input.lookahead1(); |
2677 | let ident = if lookahead.peek(Ident) || lookahead.peek(Token![_]) { |
2678 | input.call(Ident::parse_any)? |
2679 | } else { |
2680 | return Err(lookahead.error()); |
2681 | }; |
2682 | |
2683 | let colon_token: Token![:] = input.parse()?; |
2684 | let ty: Type = input.parse()?; |
2685 | let eq_token: Token![=] = input.parse()?; |
2686 | let expr: Expr = input.parse()?; |
2687 | let semi_token: Token![;] = input.parse()?; |
2688 | |
2689 | Ok(ImplItemConst { |
2690 | attrs, |
2691 | vis, |
2692 | defaultness, |
2693 | const_token, |
2694 | ident, |
2695 | generics: Generics::default(), |
2696 | colon_token, |
2697 | ty, |
2698 | eq_token, |
2699 | expr, |
2700 | semi_token, |
2701 | }) |
2702 | } |
2703 | } |
2704 | |
2705 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
2706 | impl Parse for ImplItemFn { |
2707 | fn parse(input: ParseStream) -> Result<Self> { |
2708 | let allow_omitted_body = false; |
2709 | parse_impl_item_fn(input, allow_omitted_body).map(Option::unwrap) |
2710 | } |
2711 | } |
2712 | |
2713 | fn parse_impl_item_fn( |
2714 | input: ParseStream, |
2715 | allow_omitted_body: bool, |
2716 | ) -> Result<Option<ImplItemFn>> { |
2717 | let mut attrs = input.call(Attribute::parse_outer)?; |
2718 | let vis: Visibility = input.parse()?; |
2719 | let defaultness: Option<Token![default]> = input.parse()?; |
2720 | let sig: Signature = input.parse()?; |
2721 | |
2722 | // Accept functions without a body in an impl block because rustc's |
2723 | // *parser* does not reject them (the compilation error is emitted later |
2724 | // than parsing) and it can be useful for macro DSLs. |
2725 | if allow_omitted_body && input.parse::<Option<Token![;]>>()?.is_some() { |
2726 | return Ok(None); |
2727 | } |
2728 | |
2729 | let content; |
2730 | let brace_token = braced!(content in input); |
2731 | attrs.extend(content.call(Attribute::parse_inner)?); |
2732 | let block = Block { |
2733 | brace_token, |
2734 | stmts: content.call(Block::parse_within)?, |
2735 | }; |
2736 | |
2737 | Ok(Some(ImplItemFn { |
2738 | attrs, |
2739 | vis, |
2740 | defaultness, |
2741 | sig, |
2742 | block, |
2743 | })) |
2744 | } |
2745 | |
2746 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
2747 | impl Parse for ImplItemType { |
2748 | fn parse(input: ParseStream) -> Result<Self> { |
2749 | let attrs = input.call(Attribute::parse_outer)?; |
2750 | let vis: Visibility = input.parse()?; |
2751 | let defaultness: Option<Token![default]> = input.parse()?; |
2752 | let type_token: Token![type] = input.parse()?; |
2753 | let ident: Ident = input.parse()?; |
2754 | let mut generics: Generics = input.parse()?; |
2755 | let eq_token: Token![=] = input.parse()?; |
2756 | let ty: Type = input.parse()?; |
2757 | generics.where_clause = input.parse()?; |
2758 | let semi_token: Token![;] = input.parse()?; |
2759 | Ok(ImplItemType { |
2760 | attrs, |
2761 | vis, |
2762 | defaultness, |
2763 | type_token, |
2764 | ident, |
2765 | generics, |
2766 | eq_token, |
2767 | ty, |
2768 | semi_token, |
2769 | }) |
2770 | } |
2771 | } |
2772 | |
2773 | fn parse_impl_item_type(begin: ParseBuffer, input: ParseStream) -> Result<ImplItem> { |
2774 | let FlexibleItemType { |
2775 | vis, |
2776 | defaultness, |
2777 | type_token, |
2778 | ident, |
2779 | generics, |
2780 | colon_token, |
2781 | bounds: _, |
2782 | ty, |
2783 | semi_token, |
2784 | } = FlexibleItemType::parse( |
2785 | input, |
2786 | TypeDefaultness::Optional, |
2787 | WhereClauseLocation::AfterEq, |
2788 | )?; |
2789 | |
2790 | let (eq_token, ty) = match ty { |
2791 | Some(ty) if colon_token.is_none() => ty, |
2792 | _ => return Ok(ImplItem::Verbatim(verbatim::between(&begin, input))), |
2793 | }; |
2794 | |
2795 | Ok(ImplItem::Type(ImplItemType { |
2796 | attrs: Vec::new(), |
2797 | vis, |
2798 | defaultness, |
2799 | type_token, |
2800 | ident, |
2801 | generics, |
2802 | eq_token, |
2803 | ty, |
2804 | semi_token, |
2805 | })) |
2806 | } |
2807 | |
2808 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
2809 | impl Parse for ImplItemMacro { |
2810 | fn parse(input: ParseStream) -> Result<Self> { |
2811 | let attrs = input.call(Attribute::parse_outer)?; |
2812 | let mac: Macro = input.parse()?; |
2813 | let semi_token: Option<Token![;]> = if mac.delimiter.is_brace() { |
2814 | None |
2815 | } else { |
2816 | Some(input.parse()?) |
2817 | }; |
2818 | Ok(ImplItemMacro { |
2819 | attrs, |
2820 | mac, |
2821 | semi_token, |
2822 | }) |
2823 | } |
2824 | } |
2825 | |
2826 | impl Visibility { |
2827 | fn is_inherited(&self) -> bool { |
2828 | match self { |
2829 | Visibility::Inherited => true, |
2830 | _ => false, |
2831 | } |
2832 | } |
2833 | } |
2834 | |
2835 | impl MacroDelimiter { |
2836 | pub(crate) fn is_brace(&self) -> bool { |
2837 | match self { |
2838 | MacroDelimiter::Brace(_) => true, |
2839 | MacroDelimiter::Paren(_) | MacroDelimiter::Bracket(_) => false, |
2840 | } |
2841 | } |
2842 | } |
2843 | |
2844 | #[cfg_attr (doc_cfg, doc(cfg(feature = "parsing" )))] |
2845 | impl Parse for StaticMutability { |
2846 | fn parse(input: ParseStream) -> Result<Self> { |
2847 | let mut_token: Option<Token![mut]> = input.parse()?; |
2848 | Ok(mut_token.map_or(StaticMutability::None, StaticMutability::Mut)) |
2849 | } |
2850 | } |
2851 | } |
2852 | |
2853 | #[cfg (feature = "printing" )] |
2854 | mod printing { |
2855 | use super::*; |
2856 | use crate::attr::FilterAttrs; |
2857 | use crate::print::TokensOrDefault; |
2858 | use proc_macro2::TokenStream; |
2859 | use quote::{ToTokens, TokenStreamExt}; |
2860 | |
2861 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
2862 | impl ToTokens for ItemExternCrate { |
2863 | fn to_tokens(&self, tokens: &mut TokenStream) { |
2864 | tokens.append_all(self.attrs.outer()); |
2865 | self.vis.to_tokens(tokens); |
2866 | self.extern_token.to_tokens(tokens); |
2867 | self.crate_token.to_tokens(tokens); |
2868 | self.ident.to_tokens(tokens); |
2869 | if let Some((as_token, rename)) = &self.rename { |
2870 | as_token.to_tokens(tokens); |
2871 | rename.to_tokens(tokens); |
2872 | } |
2873 | self.semi_token.to_tokens(tokens); |
2874 | } |
2875 | } |
2876 | |
2877 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
2878 | impl ToTokens for ItemUse { |
2879 | fn to_tokens(&self, tokens: &mut TokenStream) { |
2880 | tokens.append_all(self.attrs.outer()); |
2881 | self.vis.to_tokens(tokens); |
2882 | self.use_token.to_tokens(tokens); |
2883 | self.leading_colon.to_tokens(tokens); |
2884 | self.tree.to_tokens(tokens); |
2885 | self.semi_token.to_tokens(tokens); |
2886 | } |
2887 | } |
2888 | |
2889 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
2890 | impl ToTokens for ItemStatic { |
2891 | fn to_tokens(&self, tokens: &mut TokenStream) { |
2892 | tokens.append_all(self.attrs.outer()); |
2893 | self.vis.to_tokens(tokens); |
2894 | self.static_token.to_tokens(tokens); |
2895 | self.mutability.to_tokens(tokens); |
2896 | self.ident.to_tokens(tokens); |
2897 | self.colon_token.to_tokens(tokens); |
2898 | self.ty.to_tokens(tokens); |
2899 | self.eq_token.to_tokens(tokens); |
2900 | self.expr.to_tokens(tokens); |
2901 | self.semi_token.to_tokens(tokens); |
2902 | } |
2903 | } |
2904 | |
2905 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
2906 | impl ToTokens for ItemConst { |
2907 | fn to_tokens(&self, tokens: &mut TokenStream) { |
2908 | tokens.append_all(self.attrs.outer()); |
2909 | self.vis.to_tokens(tokens); |
2910 | self.const_token.to_tokens(tokens); |
2911 | self.ident.to_tokens(tokens); |
2912 | self.colon_token.to_tokens(tokens); |
2913 | self.ty.to_tokens(tokens); |
2914 | self.eq_token.to_tokens(tokens); |
2915 | self.expr.to_tokens(tokens); |
2916 | self.semi_token.to_tokens(tokens); |
2917 | } |
2918 | } |
2919 | |
2920 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
2921 | impl ToTokens for ItemFn { |
2922 | fn to_tokens(&self, tokens: &mut TokenStream) { |
2923 | tokens.append_all(self.attrs.outer()); |
2924 | self.vis.to_tokens(tokens); |
2925 | self.sig.to_tokens(tokens); |
2926 | self.block.brace_token.surround(tokens, |tokens| { |
2927 | tokens.append_all(self.attrs.inner()); |
2928 | tokens.append_all(&self.block.stmts); |
2929 | }); |
2930 | } |
2931 | } |
2932 | |
2933 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
2934 | impl ToTokens for ItemMod { |
2935 | fn to_tokens(&self, tokens: &mut TokenStream) { |
2936 | tokens.append_all(self.attrs.outer()); |
2937 | self.vis.to_tokens(tokens); |
2938 | self.unsafety.to_tokens(tokens); |
2939 | self.mod_token.to_tokens(tokens); |
2940 | self.ident.to_tokens(tokens); |
2941 | if let Some((brace, items)) = &self.content { |
2942 | brace.surround(tokens, |tokens| { |
2943 | tokens.append_all(self.attrs.inner()); |
2944 | tokens.append_all(items); |
2945 | }); |
2946 | } else { |
2947 | TokensOrDefault(&self.semi).to_tokens(tokens); |
2948 | } |
2949 | } |
2950 | } |
2951 | |
2952 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
2953 | impl ToTokens for ItemForeignMod { |
2954 | fn to_tokens(&self, tokens: &mut TokenStream) { |
2955 | tokens.append_all(self.attrs.outer()); |
2956 | self.unsafety.to_tokens(tokens); |
2957 | self.abi.to_tokens(tokens); |
2958 | self.brace_token.surround(tokens, |tokens| { |
2959 | tokens.append_all(self.attrs.inner()); |
2960 | tokens.append_all(&self.items); |
2961 | }); |
2962 | } |
2963 | } |
2964 | |
2965 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
2966 | impl ToTokens for ItemType { |
2967 | fn to_tokens(&self, tokens: &mut TokenStream) { |
2968 | tokens.append_all(self.attrs.outer()); |
2969 | self.vis.to_tokens(tokens); |
2970 | self.type_token.to_tokens(tokens); |
2971 | self.ident.to_tokens(tokens); |
2972 | self.generics.to_tokens(tokens); |
2973 | self.generics.where_clause.to_tokens(tokens); |
2974 | self.eq_token.to_tokens(tokens); |
2975 | self.ty.to_tokens(tokens); |
2976 | self.semi_token.to_tokens(tokens); |
2977 | } |
2978 | } |
2979 | |
2980 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
2981 | impl ToTokens for ItemEnum { |
2982 | fn to_tokens(&self, tokens: &mut TokenStream) { |
2983 | tokens.append_all(self.attrs.outer()); |
2984 | self.vis.to_tokens(tokens); |
2985 | self.enum_token.to_tokens(tokens); |
2986 | self.ident.to_tokens(tokens); |
2987 | self.generics.to_tokens(tokens); |
2988 | self.generics.where_clause.to_tokens(tokens); |
2989 | self.brace_token.surround(tokens, |tokens| { |
2990 | self.variants.to_tokens(tokens); |
2991 | }); |
2992 | } |
2993 | } |
2994 | |
2995 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
2996 | impl ToTokens for ItemStruct { |
2997 | fn to_tokens(&self, tokens: &mut TokenStream) { |
2998 | tokens.append_all(self.attrs.outer()); |
2999 | self.vis.to_tokens(tokens); |
3000 | self.struct_token.to_tokens(tokens); |
3001 | self.ident.to_tokens(tokens); |
3002 | self.generics.to_tokens(tokens); |
3003 | match &self.fields { |
3004 | Fields::Named(fields) => { |
3005 | self.generics.where_clause.to_tokens(tokens); |
3006 | fields.to_tokens(tokens); |
3007 | } |
3008 | Fields::Unnamed(fields) => { |
3009 | fields.to_tokens(tokens); |
3010 | self.generics.where_clause.to_tokens(tokens); |
3011 | TokensOrDefault(&self.semi_token).to_tokens(tokens); |
3012 | } |
3013 | Fields::Unit => { |
3014 | self.generics.where_clause.to_tokens(tokens); |
3015 | TokensOrDefault(&self.semi_token).to_tokens(tokens); |
3016 | } |
3017 | } |
3018 | } |
3019 | } |
3020 | |
3021 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3022 | impl ToTokens for ItemUnion { |
3023 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3024 | tokens.append_all(self.attrs.outer()); |
3025 | self.vis.to_tokens(tokens); |
3026 | self.union_token.to_tokens(tokens); |
3027 | self.ident.to_tokens(tokens); |
3028 | self.generics.to_tokens(tokens); |
3029 | self.generics.where_clause.to_tokens(tokens); |
3030 | self.fields.to_tokens(tokens); |
3031 | } |
3032 | } |
3033 | |
3034 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3035 | impl ToTokens for ItemTrait { |
3036 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3037 | tokens.append_all(self.attrs.outer()); |
3038 | self.vis.to_tokens(tokens); |
3039 | self.unsafety.to_tokens(tokens); |
3040 | self.auto_token.to_tokens(tokens); |
3041 | self.trait_token.to_tokens(tokens); |
3042 | self.ident.to_tokens(tokens); |
3043 | self.generics.to_tokens(tokens); |
3044 | if !self.supertraits.is_empty() { |
3045 | TokensOrDefault(&self.colon_token).to_tokens(tokens); |
3046 | self.supertraits.to_tokens(tokens); |
3047 | } |
3048 | self.generics.where_clause.to_tokens(tokens); |
3049 | self.brace_token.surround(tokens, |tokens| { |
3050 | tokens.append_all(self.attrs.inner()); |
3051 | tokens.append_all(&self.items); |
3052 | }); |
3053 | } |
3054 | } |
3055 | |
3056 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3057 | impl ToTokens for ItemTraitAlias { |
3058 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3059 | tokens.append_all(self.attrs.outer()); |
3060 | self.vis.to_tokens(tokens); |
3061 | self.trait_token.to_tokens(tokens); |
3062 | self.ident.to_tokens(tokens); |
3063 | self.generics.to_tokens(tokens); |
3064 | self.eq_token.to_tokens(tokens); |
3065 | self.bounds.to_tokens(tokens); |
3066 | self.generics.where_clause.to_tokens(tokens); |
3067 | self.semi_token.to_tokens(tokens); |
3068 | } |
3069 | } |
3070 | |
3071 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3072 | impl ToTokens for ItemImpl { |
3073 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3074 | tokens.append_all(self.attrs.outer()); |
3075 | self.defaultness.to_tokens(tokens); |
3076 | self.unsafety.to_tokens(tokens); |
3077 | self.impl_token.to_tokens(tokens); |
3078 | self.generics.to_tokens(tokens); |
3079 | if let Some((polarity, path, for_token)) = &self.trait_ { |
3080 | polarity.to_tokens(tokens); |
3081 | path.to_tokens(tokens); |
3082 | for_token.to_tokens(tokens); |
3083 | } |
3084 | self.self_ty.to_tokens(tokens); |
3085 | self.generics.where_clause.to_tokens(tokens); |
3086 | self.brace_token.surround(tokens, |tokens| { |
3087 | tokens.append_all(self.attrs.inner()); |
3088 | tokens.append_all(&self.items); |
3089 | }); |
3090 | } |
3091 | } |
3092 | |
3093 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3094 | impl ToTokens for ItemMacro { |
3095 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3096 | tokens.append_all(self.attrs.outer()); |
3097 | self.mac.path.to_tokens(tokens); |
3098 | self.mac.bang_token.to_tokens(tokens); |
3099 | self.ident.to_tokens(tokens); |
3100 | match &self.mac.delimiter { |
3101 | MacroDelimiter::Paren(paren) => { |
3102 | paren.surround(tokens, |tokens| self.mac.tokens.to_tokens(tokens)); |
3103 | } |
3104 | MacroDelimiter::Brace(brace) => { |
3105 | brace.surround(tokens, |tokens| self.mac.tokens.to_tokens(tokens)); |
3106 | } |
3107 | MacroDelimiter::Bracket(bracket) => { |
3108 | bracket.surround(tokens, |tokens| self.mac.tokens.to_tokens(tokens)); |
3109 | } |
3110 | } |
3111 | self.semi_token.to_tokens(tokens); |
3112 | } |
3113 | } |
3114 | |
3115 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3116 | impl ToTokens for UsePath { |
3117 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3118 | self.ident.to_tokens(tokens); |
3119 | self.colon2_token.to_tokens(tokens); |
3120 | self.tree.to_tokens(tokens); |
3121 | } |
3122 | } |
3123 | |
3124 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3125 | impl ToTokens for UseName { |
3126 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3127 | self.ident.to_tokens(tokens); |
3128 | } |
3129 | } |
3130 | |
3131 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3132 | impl ToTokens for UseRename { |
3133 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3134 | self.ident.to_tokens(tokens); |
3135 | self.as_token.to_tokens(tokens); |
3136 | self.rename.to_tokens(tokens); |
3137 | } |
3138 | } |
3139 | |
3140 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3141 | impl ToTokens for UseGlob { |
3142 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3143 | self.star_token.to_tokens(tokens); |
3144 | } |
3145 | } |
3146 | |
3147 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3148 | impl ToTokens for UseGroup { |
3149 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3150 | self.brace_token.surround(tokens, |tokens| { |
3151 | self.items.to_tokens(tokens); |
3152 | }); |
3153 | } |
3154 | } |
3155 | |
3156 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3157 | impl ToTokens for TraitItemConst { |
3158 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3159 | tokens.append_all(self.attrs.outer()); |
3160 | self.const_token.to_tokens(tokens); |
3161 | self.ident.to_tokens(tokens); |
3162 | self.colon_token.to_tokens(tokens); |
3163 | self.ty.to_tokens(tokens); |
3164 | if let Some((eq_token, default)) = &self.default { |
3165 | eq_token.to_tokens(tokens); |
3166 | default.to_tokens(tokens); |
3167 | } |
3168 | self.semi_token.to_tokens(tokens); |
3169 | } |
3170 | } |
3171 | |
3172 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3173 | impl ToTokens for TraitItemFn { |
3174 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3175 | tokens.append_all(self.attrs.outer()); |
3176 | self.sig.to_tokens(tokens); |
3177 | match &self.default { |
3178 | Some(block) => { |
3179 | block.brace_token.surround(tokens, |tokens| { |
3180 | tokens.append_all(self.attrs.inner()); |
3181 | tokens.append_all(&block.stmts); |
3182 | }); |
3183 | } |
3184 | None => { |
3185 | TokensOrDefault(&self.semi_token).to_tokens(tokens); |
3186 | } |
3187 | } |
3188 | } |
3189 | } |
3190 | |
3191 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3192 | impl ToTokens for TraitItemType { |
3193 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3194 | tokens.append_all(self.attrs.outer()); |
3195 | self.type_token.to_tokens(tokens); |
3196 | self.ident.to_tokens(tokens); |
3197 | self.generics.to_tokens(tokens); |
3198 | if !self.bounds.is_empty() { |
3199 | TokensOrDefault(&self.colon_token).to_tokens(tokens); |
3200 | self.bounds.to_tokens(tokens); |
3201 | } |
3202 | if let Some((eq_token, default)) = &self.default { |
3203 | eq_token.to_tokens(tokens); |
3204 | default.to_tokens(tokens); |
3205 | } |
3206 | self.generics.where_clause.to_tokens(tokens); |
3207 | self.semi_token.to_tokens(tokens); |
3208 | } |
3209 | } |
3210 | |
3211 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3212 | impl ToTokens for TraitItemMacro { |
3213 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3214 | tokens.append_all(self.attrs.outer()); |
3215 | self.mac.to_tokens(tokens); |
3216 | self.semi_token.to_tokens(tokens); |
3217 | } |
3218 | } |
3219 | |
3220 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3221 | impl ToTokens for ImplItemConst { |
3222 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3223 | tokens.append_all(self.attrs.outer()); |
3224 | self.vis.to_tokens(tokens); |
3225 | self.defaultness.to_tokens(tokens); |
3226 | self.const_token.to_tokens(tokens); |
3227 | self.ident.to_tokens(tokens); |
3228 | self.colon_token.to_tokens(tokens); |
3229 | self.ty.to_tokens(tokens); |
3230 | self.eq_token.to_tokens(tokens); |
3231 | self.expr.to_tokens(tokens); |
3232 | self.semi_token.to_tokens(tokens); |
3233 | } |
3234 | } |
3235 | |
3236 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3237 | impl ToTokens for ImplItemFn { |
3238 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3239 | tokens.append_all(self.attrs.outer()); |
3240 | self.vis.to_tokens(tokens); |
3241 | self.defaultness.to_tokens(tokens); |
3242 | self.sig.to_tokens(tokens); |
3243 | self.block.brace_token.surround(tokens, |tokens| { |
3244 | tokens.append_all(self.attrs.inner()); |
3245 | tokens.append_all(&self.block.stmts); |
3246 | }); |
3247 | } |
3248 | } |
3249 | |
3250 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3251 | impl ToTokens for ImplItemType { |
3252 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3253 | tokens.append_all(self.attrs.outer()); |
3254 | self.vis.to_tokens(tokens); |
3255 | self.defaultness.to_tokens(tokens); |
3256 | self.type_token.to_tokens(tokens); |
3257 | self.ident.to_tokens(tokens); |
3258 | self.generics.to_tokens(tokens); |
3259 | self.eq_token.to_tokens(tokens); |
3260 | self.ty.to_tokens(tokens); |
3261 | self.generics.where_clause.to_tokens(tokens); |
3262 | self.semi_token.to_tokens(tokens); |
3263 | } |
3264 | } |
3265 | |
3266 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3267 | impl ToTokens for ImplItemMacro { |
3268 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3269 | tokens.append_all(self.attrs.outer()); |
3270 | self.mac.to_tokens(tokens); |
3271 | self.semi_token.to_tokens(tokens); |
3272 | } |
3273 | } |
3274 | |
3275 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3276 | impl ToTokens for ForeignItemFn { |
3277 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3278 | tokens.append_all(self.attrs.outer()); |
3279 | self.vis.to_tokens(tokens); |
3280 | self.sig.to_tokens(tokens); |
3281 | self.semi_token.to_tokens(tokens); |
3282 | } |
3283 | } |
3284 | |
3285 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3286 | impl ToTokens for ForeignItemStatic { |
3287 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3288 | tokens.append_all(self.attrs.outer()); |
3289 | self.vis.to_tokens(tokens); |
3290 | self.static_token.to_tokens(tokens); |
3291 | self.mutability.to_tokens(tokens); |
3292 | self.ident.to_tokens(tokens); |
3293 | self.colon_token.to_tokens(tokens); |
3294 | self.ty.to_tokens(tokens); |
3295 | self.semi_token.to_tokens(tokens); |
3296 | } |
3297 | } |
3298 | |
3299 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3300 | impl ToTokens for ForeignItemType { |
3301 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3302 | tokens.append_all(self.attrs.outer()); |
3303 | self.vis.to_tokens(tokens); |
3304 | self.type_token.to_tokens(tokens); |
3305 | self.ident.to_tokens(tokens); |
3306 | self.generics.to_tokens(tokens); |
3307 | self.generics.where_clause.to_tokens(tokens); |
3308 | self.semi_token.to_tokens(tokens); |
3309 | } |
3310 | } |
3311 | |
3312 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3313 | impl ToTokens for ForeignItemMacro { |
3314 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3315 | tokens.append_all(self.attrs.outer()); |
3316 | self.mac.to_tokens(tokens); |
3317 | self.semi_token.to_tokens(tokens); |
3318 | } |
3319 | } |
3320 | |
3321 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3322 | impl ToTokens for Signature { |
3323 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3324 | self.constness.to_tokens(tokens); |
3325 | self.asyncness.to_tokens(tokens); |
3326 | self.unsafety.to_tokens(tokens); |
3327 | self.abi.to_tokens(tokens); |
3328 | self.fn_token.to_tokens(tokens); |
3329 | self.ident.to_tokens(tokens); |
3330 | self.generics.to_tokens(tokens); |
3331 | self.paren_token.surround(tokens, |tokens| { |
3332 | self.inputs.to_tokens(tokens); |
3333 | if let Some(variadic) = &self.variadic { |
3334 | if !self.inputs.empty_or_trailing() { |
3335 | <Token![,]>::default().to_tokens(tokens); |
3336 | } |
3337 | variadic.to_tokens(tokens); |
3338 | } |
3339 | }); |
3340 | self.output.to_tokens(tokens); |
3341 | self.generics.where_clause.to_tokens(tokens); |
3342 | } |
3343 | } |
3344 | |
3345 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3346 | impl ToTokens for Receiver { |
3347 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3348 | tokens.append_all(self.attrs.outer()); |
3349 | if let Some((ampersand, lifetime)) = &self.reference { |
3350 | ampersand.to_tokens(tokens); |
3351 | lifetime.to_tokens(tokens); |
3352 | } |
3353 | self.mutability.to_tokens(tokens); |
3354 | self.self_token.to_tokens(tokens); |
3355 | if let Some(colon_token) = &self.colon_token { |
3356 | colon_token.to_tokens(tokens); |
3357 | self.ty.to_tokens(tokens); |
3358 | } else { |
3359 | let consistent = match (&self.reference, &self.mutability, &*self.ty) { |
3360 | (Some(_), mutability, Type::Reference(ty)) => { |
3361 | mutability.is_some() == ty.mutability.is_some() |
3362 | && match &*ty.elem { |
3363 | Type::Path(ty) => ty.qself.is_none() && ty.path.is_ident("Self" ), |
3364 | _ => false, |
3365 | } |
3366 | } |
3367 | (None, _, Type::Path(ty)) => ty.qself.is_none() && ty.path.is_ident("Self" ), |
3368 | _ => false, |
3369 | }; |
3370 | if !consistent { |
3371 | <Token![:]>::default().to_tokens(tokens); |
3372 | self.ty.to_tokens(tokens); |
3373 | } |
3374 | } |
3375 | } |
3376 | } |
3377 | |
3378 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3379 | impl ToTokens for Variadic { |
3380 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3381 | tokens.append_all(self.attrs.outer()); |
3382 | if let Some((pat, colon)) = &self.pat { |
3383 | pat.to_tokens(tokens); |
3384 | colon.to_tokens(tokens); |
3385 | } |
3386 | self.dots.to_tokens(tokens); |
3387 | self.comma.to_tokens(tokens); |
3388 | } |
3389 | } |
3390 | |
3391 | #[cfg_attr (doc_cfg, doc(cfg(feature = "printing" )))] |
3392 | impl ToTokens for StaticMutability { |
3393 | fn to_tokens(&self, tokens: &mut TokenStream) { |
3394 | match self { |
3395 | StaticMutability::None => {} |
3396 | StaticMutability::Mut(mut_token) => mut_token.to_tokens(tokens), |
3397 | } |
3398 | } |
3399 | } |
3400 | } |
3401 | |