1use super::*;
2use crate::derive::{Data, DataEnum, DataStruct, DataUnion, DeriveInput};
3use crate::punctuated::Punctuated;
4use proc_macro2::TokenStream;
5
6#[cfg(feature = "parsing")]
7use std::mem;
8
9ast_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
89ast_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
106ast_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
120ast_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
134ast_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
145ast_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
157ast_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
176ast_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
188ast_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
202ast_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
219ast_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
233ast_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
252ast_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
267ast_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
282ast_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
295ast_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
308impl 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
332impl 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
365impl 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
381impl 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
397impl 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
412ast_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
439ast_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
449ast_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
457ast_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
467ast_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
475ast_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
484ast_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
529ast_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
540ast_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
555ast_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
568ast_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
578ast_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
623ast_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
638ast_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
649ast_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
664ast_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
674ast_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
719ast_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
737ast_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
749ast_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
765ast_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
775ast_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
794impl 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
805ast_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
817ast_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
836impl Receiver {
837 pub fn lifetime(&self) -> Option<&Lifetime> {
838 self.reference.as_ref()?.1.as_ref()
839 }
840}
841
842ast_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
863ast_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
873ast_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")]
891pub(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")]
2854mod 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