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