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