1 use super::*; 2 use derive::{Data, DeriveInput}; 3 use proc_macro2::TokenStream; 4 use punctuated::Punctuated; 5 use token::{Brace, Paren}; 6 7 #[cfg(feature = "extra-traits")] 8 use std::hash::{Hash, Hasher}; 9 #[cfg(feature = "extra-traits")] 10 use tt::TokenStreamHelper; 11 12 ast_enum_of_structs! { 13 /// Things that can appear directly inside of a module or scope. 14 /// 15 /// *This type is available if Syn is built with the `"full"` feature.* 16 /// 17 /// # Syntax tree enum 18 /// 19 /// This type is a [syntax tree enum]. 20 /// 21 /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums 22 pub enum Item { 23 /// An `extern crate` item: `extern crate serde`. 24 /// 25 /// *This type is available if Syn is built with the `"full"` feature.* 26 pub ExternCrate(ItemExternCrate { 27 pub attrs: Vec<Attribute>, 28 pub vis: Visibility, 29 pub extern_token: Token![extern], 30 pub crate_token: Token![crate], 31 pub ident: Ident, 32 pub rename: Option<(Token![as], Ident)>, 33 pub semi_token: Token![;], 34 }), 35 36 /// A use declaration: `use std::collections::HashMap`. 37 /// 38 /// *This type is available if Syn is built with the `"full"` feature.* 39 pub Use(ItemUse { 40 pub attrs: Vec<Attribute>, 41 pub vis: Visibility, 42 pub use_token: Token![use], 43 pub leading_colon: Option<Token![::]>, 44 pub tree: UseTree, 45 pub semi_token: Token![;], 46 }), 47 48 /// A static item: `static BIKE: Shed = Shed(42)`. 49 /// 50 /// *This type is available if Syn is built with the `"full"` feature.* 51 pub Static(ItemStatic { 52 pub attrs: Vec<Attribute>, 53 pub vis: Visibility, 54 pub static_token: Token![static], 55 pub mutability: Option<Token![mut]>, 56 pub ident: Ident, 57 pub colon_token: Token![:], 58 pub ty: Box<Type>, 59 pub eq_token: Token![=], 60 pub expr: Box<Expr>, 61 pub semi_token: Token![;], 62 }), 63 64 /// A constant item: `const MAX: u16 = 65535`. 65 /// 66 /// *This type is available if Syn is built with the `"full"` feature.* 67 pub Const(ItemConst { 68 pub attrs: Vec<Attribute>, 69 pub vis: Visibility, 70 pub const_token: Token![const], 71 pub ident: Ident, 72 pub colon_token: Token![:], 73 pub ty: Box<Type>, 74 pub eq_token: Token![=], 75 pub expr: Box<Expr>, 76 pub semi_token: Token![;], 77 }), 78 79 /// A free-standing function: `fn process(n: usize) -> Result<()> { ... 80 /// }`. 81 /// 82 /// *This type is available if Syn is built with the `"full"` feature.* 83 pub Fn(ItemFn { 84 pub attrs: Vec<Attribute>, 85 pub vis: Visibility, 86 pub constness: Option<Token![const]>, 87 pub unsafety: Option<Token![unsafe]>, 88 pub asyncness: Option<Token![async]>, 89 pub abi: Option<Abi>, 90 pub ident: Ident, 91 pub decl: Box<FnDecl>, 92 pub block: Box<Block>, 93 }), 94 95 /// A module or module declaration: `mod m` or `mod m { ... }`. 96 /// 97 /// *This type is available if Syn is built with the `"full"` feature.* 98 pub Mod(ItemMod { 99 pub attrs: Vec<Attribute>, 100 pub vis: Visibility, 101 pub mod_token: Token![mod], 102 pub ident: Ident, 103 pub content: Option<(token::Brace, Vec<Item>)>, 104 pub semi: Option<Token![;]>, 105 }), 106 107 /// A block of foreign items: `extern "C" { ... }`. 108 /// 109 /// *This type is available if Syn is built with the `"full"` feature.* 110 pub ForeignMod(ItemForeignMod { 111 pub attrs: Vec<Attribute>, 112 pub abi: Abi, 113 pub brace_token: token::Brace, 114 pub items: Vec<ForeignItem>, 115 }), 116 117 /// A type alias: `type Result<T> = std::result::Result<T, MyError>`. 118 /// 119 /// *This type is available if Syn is built with the `"full"` feature.* 120 pub Type(ItemType { 121 pub attrs: Vec<Attribute>, 122 pub vis: Visibility, 123 pub type_token: Token![type], 124 pub ident: Ident, 125 pub generics: Generics, 126 pub eq_token: Token![=], 127 pub ty: Box<Type>, 128 pub semi_token: Token![;], 129 }), 130 131 /// An existential type: `existential type Iter: Iterator<Item = u8>`. 132 /// 133 /// *This type is available if Syn is built with the `"full"` feature.* 134 pub Existential(ItemExistential { 135 pub attrs: Vec<Attribute>, 136 pub vis: Visibility, 137 pub existential_token: Token![existential], 138 pub type_token: Token![type], 139 pub ident: Ident, 140 pub generics: Generics, 141 pub colon_token: Option<Token![:]>, 142 pub bounds: Punctuated<TypeParamBound, Token![+]>, 143 pub semi_token: Token![;], 144 }), 145 146 /// A struct definition: `struct Foo<A> { x: A }`. 147 /// 148 /// *This type is available if Syn is built with the `"full"` feature.* 149 pub Struct(ItemStruct { 150 pub attrs: Vec<Attribute>, 151 pub vis: Visibility, 152 pub struct_token: Token![struct], 153 pub ident: Ident, 154 pub generics: Generics, 155 pub fields: Fields, 156 pub semi_token: Option<Token![;]>, 157 }), 158 159 /// An enum definition: `enum Foo<A, B> { C<A>, D<B> }`. 160 /// 161 /// *This type is available if Syn is built with the `"full"` feature.* 162 pub Enum(ItemEnum { 163 pub attrs: Vec<Attribute>, 164 pub vis: Visibility, 165 pub enum_token: Token![enum], 166 pub ident: Ident, 167 pub generics: Generics, 168 pub brace_token: token::Brace, 169 pub variants: Punctuated<Variant, Token![,]>, 170 }), 171 172 /// A union definition: `union Foo<A, B> { x: A, y: B }`. 173 /// 174 /// *This type is available if Syn is built with the `"full"` feature.* 175 pub Union(ItemUnion { 176 pub attrs: Vec<Attribute>, 177 pub vis: Visibility, 178 pub union_token: Token![union], 179 pub ident: Ident, 180 pub generics: Generics, 181 pub fields: FieldsNamed, 182 }), 183 184 /// A trait definition: `pub trait Iterator { ... }`. 185 /// 186 /// *This type is available if Syn is built with the `"full"` feature.* 187 pub Trait(ItemTrait { 188 pub attrs: Vec<Attribute>, 189 pub vis: Visibility, 190 pub unsafety: Option<Token![unsafe]>, 191 pub auto_token: Option<Token![auto]>, 192 pub trait_token: Token![trait], 193 pub ident: Ident, 194 pub generics: Generics, 195 pub colon_token: Option<Token![:]>, 196 pub supertraits: Punctuated<TypeParamBound, Token![+]>, 197 pub brace_token: token::Brace, 198 pub items: Vec<TraitItem>, 199 }), 200 201 /// A trait alias: `pub trait SharableIterator = Iterator + Sync`. 202 /// 203 /// *This type is available if Syn is built with the `"full"` feature.* 204 pub TraitAlias(ItemTraitAlias { 205 pub attrs: Vec<Attribute>, 206 pub vis: Visibility, 207 pub trait_token: Token![trait], 208 pub ident: Ident, 209 pub generics: Generics, 210 pub eq_token: Token![=], 211 pub bounds: Punctuated<TypeParamBound, Token![+]>, 212 pub semi_token: Token![;], 213 }), 214 215 /// An impl block providing trait or associated items: `impl<A> Trait 216 /// for Data<A> { ... }`. 217 /// 218 /// *This type is available if Syn is built with the `"full"` feature.* 219 pub Impl(ItemImpl { 220 pub attrs: Vec<Attribute>, 221 pub defaultness: Option<Token![default]>, 222 pub unsafety: Option<Token![unsafe]>, 223 pub impl_token: Token![impl], 224 pub generics: Generics, 225 /// Trait this impl implements. 226 pub trait_: Option<(Option<Token![!]>, Path, Token![for])>, 227 /// The Self type of the impl. 228 pub self_ty: Box<Type>, 229 pub brace_token: token::Brace, 230 pub items: Vec<ImplItem>, 231 }), 232 233 /// A macro invocation, which includes `macro_rules!` definitions. 234 /// 235 /// *This type is available if Syn is built with the `"full"` feature.* 236 pub Macro(ItemMacro { 237 pub attrs: Vec<Attribute>, 238 /// The `example` in `macro_rules! example { ... }`. 239 pub ident: Option<Ident>, 240 pub mac: Macro, 241 pub semi_token: Option<Token![;]>, 242 }), 243 244 /// A 2.0-style declarative macro introduced by the `macro` keyword. 245 /// 246 /// *This type is available if Syn is built with the `"full"` feature.* 247 pub Macro2(ItemMacro2 #manual_extra_traits { 248 pub attrs: Vec<Attribute>, 249 pub vis: Visibility, 250 pub macro_token: Token![macro], 251 pub ident: Ident, 252 pub paren_token: Paren, 253 pub args: TokenStream, 254 pub brace_token: Brace, 255 pub body: TokenStream, 256 }), 257 258 /// Tokens forming an item not interpreted by Syn. 259 /// 260 /// *This type is available if Syn is built with the `"full"` feature.* 261 pub Verbatim(ItemVerbatim #manual_extra_traits { 262 pub tts: TokenStream, 263 }), 264 } 265 } 266 267 #[cfg(feature = "extra-traits")] 268 impl Eq for ItemMacro2 {} 269 270 #[cfg(feature = "extra-traits")] 271 impl PartialEq for ItemMacro2 { eq(&self, other: &Self) -> bool272 fn eq(&self, other: &Self) -> bool { 273 self.attrs == other.attrs 274 && self.vis == other.vis 275 && self.macro_token == other.macro_token 276 && self.ident == other.ident 277 && self.paren_token == other.paren_token 278 && TokenStreamHelper(&self.args) == TokenStreamHelper(&other.args) 279 && self.brace_token == other.brace_token 280 && TokenStreamHelper(&self.body) == TokenStreamHelper(&other.body) 281 } 282 } 283 284 #[cfg(feature = "extra-traits")] 285 impl Hash for ItemMacro2 { hash<H>(&self, state: &mut H) where H: Hasher,286 fn hash<H>(&self, state: &mut H) 287 where 288 H: Hasher, 289 { 290 self.attrs.hash(state); 291 self.vis.hash(state); 292 self.macro_token.hash(state); 293 self.ident.hash(state); 294 self.paren_token.hash(state); 295 TokenStreamHelper(&self.args).hash(state); 296 self.brace_token.hash(state); 297 TokenStreamHelper(&self.body).hash(state); 298 } 299 } 300 301 #[cfg(feature = "extra-traits")] 302 impl Eq for ItemVerbatim {} 303 304 #[cfg(feature = "extra-traits")] 305 impl PartialEq for ItemVerbatim { eq(&self, other: &Self) -> bool306 fn eq(&self, other: &Self) -> bool { 307 TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts) 308 } 309 } 310 311 #[cfg(feature = "extra-traits")] 312 impl Hash for ItemVerbatim { hash<H>(&self, state: &mut H) where H: Hasher,313 fn hash<H>(&self, state: &mut H) 314 where 315 H: Hasher, 316 { 317 TokenStreamHelper(&self.tts).hash(state); 318 } 319 } 320 321 impl From<DeriveInput> for Item { from(input: DeriveInput) -> Item322 fn from(input: DeriveInput) -> Item { 323 match input.data { 324 Data::Struct(data) => Item::Struct(ItemStruct { 325 attrs: input.attrs, 326 vis: input.vis, 327 struct_token: data.struct_token, 328 ident: input.ident, 329 generics: input.generics, 330 fields: data.fields, 331 semi_token: data.semi_token, 332 }), 333 Data::Enum(data) => Item::Enum(ItemEnum { 334 attrs: input.attrs, 335 vis: input.vis, 336 enum_token: data.enum_token, 337 ident: input.ident, 338 generics: input.generics, 339 brace_token: data.brace_token, 340 variants: data.variants, 341 }), 342 Data::Union(data) => Item::Union(ItemUnion { 343 attrs: input.attrs, 344 vis: input.vis, 345 union_token: data.union_token, 346 ident: input.ident, 347 generics: input.generics, 348 fields: data.fields, 349 }), 350 } 351 } 352 } 353 354 ast_enum_of_structs! { 355 /// A suffix of an import tree in a `use` item: `Type as Renamed` or `*`. 356 /// 357 /// *This type is available if Syn is built with the `"full"` feature.* 358 /// 359 /// # Syntax tree enum 360 /// 361 /// This type is a [syntax tree enum]. 362 /// 363 /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums 364 pub enum UseTree { 365 /// A path prefix of imports in a `use` item: `std::...`. 366 /// 367 /// *This type is available if Syn is built with the `"full"` feature.* 368 pub Path(UsePath { 369 pub ident: Ident, 370 pub colon2_token: Token![::], 371 pub tree: Box<UseTree>, 372 }), 373 374 /// An identifier imported by a `use` item: `HashMap`. 375 /// 376 /// *This type is available if Syn is built with the `"full"` feature.* 377 pub Name(UseName { 378 pub ident: Ident, 379 }), 380 381 /// An renamed identifier imported by a `use` item: `HashMap as Map`. 382 /// 383 /// *This type is available if Syn is built with the `"full"` feature.* 384 pub Rename(UseRename { 385 pub ident: Ident, 386 pub as_token: Token![as], 387 pub rename: Ident, 388 }), 389 390 /// A glob import in a `use` item: `*`. 391 /// 392 /// *This type is available if Syn is built with the `"full"` feature.* 393 pub Glob(UseGlob { 394 pub star_token: Token![*], 395 }), 396 397 /// A braced group of imports in a `use` item: `{A, B, C}`. 398 /// 399 /// *This type is available if Syn is built with the `"full"` feature.* 400 pub Group(UseGroup { 401 pub brace_token: token::Brace, 402 pub items: Punctuated<UseTree, Token![,]>, 403 }), 404 } 405 } 406 407 ast_enum_of_structs! { 408 /// An item within an `extern` block. 409 /// 410 /// *This type is available if Syn is built with the `"full"` feature.* 411 /// 412 /// # Syntax tree enum 413 /// 414 /// This type is a [syntax tree enum]. 415 /// 416 /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums 417 pub enum ForeignItem { 418 /// A foreign function in an `extern` block. 419 /// 420 /// *This type is available if Syn is built with the `"full"` feature.* 421 pub Fn(ForeignItemFn { 422 pub attrs: Vec<Attribute>, 423 pub vis: Visibility, 424 pub ident: Ident, 425 pub decl: Box<FnDecl>, 426 pub semi_token: Token![;], 427 }), 428 429 /// A foreign static item in an `extern` block: `static ext: u8`. 430 /// 431 /// *This type is available if Syn is built with the `"full"` feature.* 432 pub Static(ForeignItemStatic { 433 pub attrs: Vec<Attribute>, 434 pub vis: Visibility, 435 pub static_token: Token![static], 436 pub mutability: Option<Token![mut]>, 437 pub ident: Ident, 438 pub colon_token: Token![:], 439 pub ty: Box<Type>, 440 pub semi_token: Token![;], 441 }), 442 443 /// A foreign type in an `extern` block: `type void`. 444 /// 445 /// *This type is available if Syn is built with the `"full"` feature.* 446 pub Type(ForeignItemType { 447 pub attrs: Vec<Attribute>, 448 pub vis: Visibility, 449 pub type_token: Token![type], 450 pub ident: Ident, 451 pub semi_token: Token![;], 452 }), 453 454 /// A macro invocation within an extern block. 455 /// 456 /// *This type is available if Syn is built with the `"full"` feature.* 457 pub Macro(ForeignItemMacro { 458 pub attrs: Vec<Attribute>, 459 pub mac: Macro, 460 pub semi_token: Option<Token![;]>, 461 }), 462 463 /// Tokens in an `extern` block not interpreted by Syn. 464 /// 465 /// *This type is available if Syn is built with the `"full"` feature.* 466 pub Verbatim(ForeignItemVerbatim #manual_extra_traits { 467 pub tts: TokenStream, 468 }), 469 } 470 } 471 472 #[cfg(feature = "extra-traits")] 473 impl Eq for ForeignItemVerbatim {} 474 475 #[cfg(feature = "extra-traits")] 476 impl PartialEq for ForeignItemVerbatim { eq(&self, other: &Self) -> bool477 fn eq(&self, other: &Self) -> bool { 478 TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts) 479 } 480 } 481 482 #[cfg(feature = "extra-traits")] 483 impl Hash for ForeignItemVerbatim { hash<H>(&self, state: &mut H) where H: Hasher,484 fn hash<H>(&self, state: &mut H) 485 where 486 H: Hasher, 487 { 488 TokenStreamHelper(&self.tts).hash(state); 489 } 490 } 491 492 ast_enum_of_structs! { 493 /// An item declaration within the definition of a trait. 494 /// 495 /// *This type is available if Syn is built with the `"full"` feature.* 496 /// 497 /// # Syntax tree enum 498 /// 499 /// This type is a [syntax tree enum]. 500 /// 501 /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums 502 pub enum TraitItem { 503 /// An associated constant within the definition of a trait. 504 /// 505 /// *This type is available if Syn is built with the `"full"` feature.* 506 pub Const(TraitItemConst { 507 pub attrs: Vec<Attribute>, 508 pub const_token: Token![const], 509 pub ident: Ident, 510 pub colon_token: Token![:], 511 pub ty: Type, 512 pub default: Option<(Token![=], Expr)>, 513 pub semi_token: Token![;], 514 }), 515 516 /// A trait method within the definition of a trait. 517 /// 518 /// *This type is available if Syn is built with the `"full"` feature.* 519 pub Method(TraitItemMethod { 520 pub attrs: Vec<Attribute>, 521 pub sig: MethodSig, 522 pub default: Option<Block>, 523 pub semi_token: Option<Token![;]>, 524 }), 525 526 /// An associated type within the definition of a trait. 527 /// 528 /// *This type is available if Syn is built with the `"full"` feature.* 529 pub Type(TraitItemType { 530 pub attrs: Vec<Attribute>, 531 pub type_token: Token![type], 532 pub ident: Ident, 533 pub generics: Generics, 534 pub colon_token: Option<Token![:]>, 535 pub bounds: Punctuated<TypeParamBound, Token![+]>, 536 pub default: Option<(Token![=], Type)>, 537 pub semi_token: Token![;], 538 }), 539 540 /// A macro invocation within the definition of a trait. 541 /// 542 /// *This type is available if Syn is built with the `"full"` feature.* 543 pub Macro(TraitItemMacro { 544 pub attrs: Vec<Attribute>, 545 pub mac: Macro, 546 pub semi_token: Option<Token![;]>, 547 }), 548 549 /// Tokens within the definition of a trait not interpreted by Syn. 550 /// 551 /// *This type is available if Syn is built with the `"full"` feature.* 552 pub Verbatim(TraitItemVerbatim #manual_extra_traits { 553 pub tts: TokenStream, 554 }), 555 } 556 } 557 558 #[cfg(feature = "extra-traits")] 559 impl Eq for TraitItemVerbatim {} 560 561 #[cfg(feature = "extra-traits")] 562 impl PartialEq for TraitItemVerbatim { eq(&self, other: &Self) -> bool563 fn eq(&self, other: &Self) -> bool { 564 TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts) 565 } 566 } 567 568 #[cfg(feature = "extra-traits")] 569 impl Hash for TraitItemVerbatim { hash<H>(&self, state: &mut H) where H: Hasher,570 fn hash<H>(&self, state: &mut H) 571 where 572 H: Hasher, 573 { 574 TokenStreamHelper(&self.tts).hash(state); 575 } 576 } 577 578 ast_enum_of_structs! { 579 /// An item within an impl block. 580 /// 581 /// *This type is available if Syn is built with the `"full"` feature.* 582 /// 583 /// # Syntax tree enum 584 /// 585 /// This type is a [syntax tree enum]. 586 /// 587 /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums 588 pub enum ImplItem { 589 /// An associated constant within an impl block. 590 /// 591 /// *This type is available if Syn is built with the `"full"` feature.* 592 pub Const(ImplItemConst { 593 pub attrs: Vec<Attribute>, 594 pub vis: Visibility, 595 pub defaultness: Option<Token![default]>, 596 pub const_token: Token![const], 597 pub ident: Ident, 598 pub colon_token: Token![:], 599 pub ty: Type, 600 pub eq_token: Token![=], 601 pub expr: Expr, 602 pub semi_token: Token![;], 603 }), 604 605 /// A method within an impl block. 606 /// 607 /// *This type is available if Syn is built with the `"full"` feature.* 608 pub Method(ImplItemMethod { 609 pub attrs: Vec<Attribute>, 610 pub vis: Visibility, 611 pub defaultness: Option<Token![default]>, 612 pub sig: MethodSig, 613 pub block: Block, 614 }), 615 616 /// An associated type within an impl block. 617 /// 618 /// *This type is available if Syn is built with the `"full"` feature.* 619 pub Type(ImplItemType { 620 pub attrs: Vec<Attribute>, 621 pub vis: Visibility, 622 pub defaultness: Option<Token![default]>, 623 pub type_token: Token![type], 624 pub ident: Ident, 625 pub generics: Generics, 626 pub eq_token: Token![=], 627 pub ty: Type, 628 pub semi_token: Token![;], 629 }), 630 631 /// An existential type within an impl block. 632 /// 633 /// *This type is available if Syn is built with the `"full"` feature.* 634 pub Existential(ImplItemExistential { 635 pub attrs: Vec<Attribute>, 636 pub existential_token: Token![existential], 637 pub type_token: Token![type], 638 pub ident: Ident, 639 pub generics: Generics, 640 pub colon_token: Option<Token![:]>, 641 pub bounds: Punctuated<TypeParamBound, Token![+]>, 642 pub semi_token: Token![;], 643 }), 644 645 /// A macro invocation within an impl block. 646 /// 647 /// *This type is available if Syn is built with the `"full"` feature.* 648 pub Macro(ImplItemMacro { 649 pub attrs: Vec<Attribute>, 650 pub mac: Macro, 651 pub semi_token: Option<Token![;]>, 652 }), 653 654 /// Tokens within an impl block not interpreted by Syn. 655 /// 656 /// *This type is available if Syn is built with the `"full"` feature.* 657 pub Verbatim(ImplItemVerbatim #manual_extra_traits { 658 pub tts: TokenStream, 659 }), 660 } 661 } 662 663 #[cfg(feature = "extra-traits")] 664 impl Eq for ImplItemVerbatim {} 665 666 #[cfg(feature = "extra-traits")] 667 impl PartialEq for ImplItemVerbatim { eq(&self, other: &Self) -> bool668 fn eq(&self, other: &Self) -> bool { 669 TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts) 670 } 671 } 672 673 #[cfg(feature = "extra-traits")] 674 impl Hash for ImplItemVerbatim { hash<H>(&self, state: &mut H) where H: Hasher,675 fn hash<H>(&self, state: &mut H) 676 where 677 H: Hasher, 678 { 679 TokenStreamHelper(&self.tts).hash(state); 680 } 681 } 682 683 ast_struct! { 684 /// A method's signature in a trait or implementation: `unsafe fn 685 /// initialize(&self)`. 686 /// 687 /// *This type is available if Syn is built with the `"full"` feature.* 688 pub struct MethodSig { 689 pub constness: Option<Token![const]>, 690 pub unsafety: Option<Token![unsafe]>, 691 pub asyncness: Option<Token![async]>, 692 pub abi: Option<Abi>, 693 pub ident: Ident, 694 pub decl: FnDecl, 695 } 696 } 697 698 ast_struct! { 699 /// Header of a function declaration, without including the body. 700 /// 701 /// *This type is available if Syn is built with the `"full"` feature.* 702 pub struct FnDecl { 703 pub fn_token: Token![fn], 704 pub generics: Generics, 705 pub paren_token: token::Paren, 706 pub inputs: Punctuated<FnArg, Token![,]>, 707 pub variadic: Option<Token![...]>, 708 pub output: ReturnType, 709 } 710 } 711 712 ast_enum_of_structs! { 713 /// An argument in a function signature: the `n: usize` in `fn f(n: usize)`. 714 /// 715 /// *This type is available if Syn is built with the `"full"` feature.* 716 /// 717 /// # Syntax tree enum 718 /// 719 /// This type is a [syntax tree enum]. 720 /// 721 /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums 722 pub enum FnArg { 723 /// Self captured by reference in a function signature: `&self` or `&mut 724 /// self`. 725 /// 726 /// *This type is available if Syn is built with the `"full"` feature.* 727 pub SelfRef(ArgSelfRef { 728 pub and_token: Token![&], 729 pub lifetime: Option<Lifetime>, 730 pub mutability: Option<Token![mut]>, 731 pub self_token: Token![self], 732 }), 733 734 /// Self captured by value in a function signature: `self` or `mut 735 /// self`. 736 /// 737 /// *This type is available if Syn is built with the `"full"` feature.* 738 pub SelfValue(ArgSelf { 739 pub mutability: Option<Token![mut]>, 740 pub self_token: Token![self], 741 }), 742 743 /// An explicitly typed pattern captured by a function signature. 744 /// 745 /// *This type is available if Syn is built with the `"full"` feature.* 746 pub Captured(ArgCaptured { 747 pub pat: Pat, 748 pub colon_token: Token![:], 749 pub ty: Type, 750 }), 751 752 /// A pattern whose type is inferred captured by a function signature. 753 pub Inferred(Pat), 754 /// A type not bound to any pattern in a function signature. 755 pub Ignored(Type), 756 } 757 } 758 759 #[cfg(feature = "parsing")] 760 pub mod parsing { 761 use super::*; 762 763 use ext::IdentExt; 764 use parse::{Parse, ParseStream, Result}; 765 use proc_macro2::{Punct, Spacing, TokenTree}; 766 use std::iter::FromIterator; 767 768 impl Parse for Item { parse(input: ParseStream) -> Result<Self>769 fn parse(input: ParseStream) -> Result<Self> { 770 let ahead = input.fork(); 771 ahead.call(Attribute::parse_outer)?; 772 let vis: Visibility = ahead.parse()?; 773 774 let lookahead = ahead.lookahead1(); 775 if lookahead.peek(Token![extern]) { 776 ahead.parse::<Token![extern]>()?; 777 let lookahead = ahead.lookahead1(); 778 if lookahead.peek(Token![crate]) { 779 input.parse().map(Item::ExternCrate) 780 } else if lookahead.peek(Token![fn]) { 781 input.parse().map(Item::Fn) 782 } else if lookahead.peek(token::Brace) { 783 input.parse().map(Item::ForeignMod) 784 } else if lookahead.peek(LitStr) { 785 ahead.parse::<LitStr>()?; 786 let lookahead = ahead.lookahead1(); 787 if lookahead.peek(token::Brace) { 788 input.parse().map(Item::ForeignMod) 789 } else if lookahead.peek(Token![fn]) { 790 input.parse().map(Item::Fn) 791 } else { 792 Err(lookahead.error()) 793 } 794 } else { 795 Err(lookahead.error()) 796 } 797 } else if lookahead.peek(Token![use]) { 798 input.parse().map(Item::Use) 799 } else if lookahead.peek(Token![static]) { 800 input.parse().map(Item::Static) 801 } else if lookahead.peek(Token![const]) { 802 ahead.parse::<Token![const]>()?; 803 let lookahead = ahead.lookahead1(); 804 if lookahead.peek(Ident) || lookahead.peek(Token![_]) { 805 input.parse().map(Item::Const) 806 } else if lookahead.peek(Token![unsafe]) 807 || lookahead.peek(Token![async]) 808 || lookahead.peek(Token![extern]) 809 || lookahead.peek(Token![fn]) 810 { 811 input.parse().map(Item::Fn) 812 } else { 813 Err(lookahead.error()) 814 } 815 } else if lookahead.peek(Token![unsafe]) { 816 ahead.parse::<Token![unsafe]>()?; 817 let lookahead = ahead.lookahead1(); 818 if lookahead.peek(Token![trait]) 819 || lookahead.peek(Token![auto]) && ahead.peek2(Token![trait]) 820 { 821 input.parse().map(Item::Trait) 822 } else if lookahead.peek(Token![impl ]) { 823 input.parse().map(Item::Impl) 824 } else if lookahead.peek(Token![async]) 825 || lookahead.peek(Token![extern]) 826 || lookahead.peek(Token![fn]) 827 { 828 input.parse().map(Item::Fn) 829 } else { 830 Err(lookahead.error()) 831 } 832 } else if lookahead.peek(Token![async]) || lookahead.peek(Token![fn]) { 833 input.parse().map(Item::Fn) 834 } else if lookahead.peek(Token![mod]) { 835 input.parse().map(Item::Mod) 836 } else if lookahead.peek(Token![type]) { 837 input.parse().map(Item::Type) 838 } else if lookahead.peek(Token![existential]) { 839 input.parse().map(Item::Existential) 840 } else if lookahead.peek(Token![struct]) { 841 input.parse().map(Item::Struct) 842 } else if lookahead.peek(Token![enum]) { 843 input.parse().map(Item::Enum) 844 } else if lookahead.peek(Token![union]) && ahead.peek2(Ident) { 845 input.parse().map(Item::Union) 846 } else if lookahead.peek(Token![trait]) { 847 input.call(parse_trait_or_trait_alias) 848 } else if lookahead.peek(Token![auto]) && ahead.peek2(Token![trait]) { 849 input.parse().map(Item::Trait) 850 } else if lookahead.peek(Token![impl ]) 851 || lookahead.peek(Token![default]) && !ahead.peek2(Token![!]) 852 { 853 input.parse().map(Item::Impl) 854 } else if lookahead.peek(Token![macro]) { 855 input.parse().map(Item::Macro2) 856 } else if vis.is_inherited() 857 && (lookahead.peek(Ident) 858 || lookahead.peek(Token![self]) 859 || lookahead.peek(Token![super]) 860 || lookahead.peek(Token![extern]) 861 || lookahead.peek(Token![crate]) 862 || lookahead.peek(Token![::])) 863 { 864 input.parse().map(Item::Macro) 865 } else { 866 Err(lookahead.error()) 867 } 868 } 869 } 870 871 impl Parse for ItemMacro { parse(input: ParseStream) -> Result<Self>872 fn parse(input: ParseStream) -> Result<Self> { 873 let attrs = input.call(Attribute::parse_outer)?; 874 let path = input.call(Path::parse_mod_style)?; 875 let bang_token: Token![!] = input.parse()?; 876 let ident: Option<Ident> = input.parse()?; 877 let (delimiter, tts) = input.call(mac::parse_delimiter)?; 878 let semi_token: Option<Token![;]> = if !delimiter.is_brace() { 879 Some(input.parse()?) 880 } else { 881 None 882 }; 883 Ok(ItemMacro { 884 attrs: attrs, 885 ident: ident, 886 mac: Macro { 887 path: path, 888 bang_token: bang_token, 889 delimiter: delimiter, 890 tts: tts, 891 }, 892 semi_token: semi_token, 893 }) 894 } 895 } 896 897 // TODO: figure out the actual grammar; is body required to be braced? 898 impl Parse for ItemMacro2 { parse(input: ParseStream) -> Result<Self>899 fn parse(input: ParseStream) -> Result<Self> { 900 let attrs = input.call(Attribute::parse_outer)?; 901 let vis: Visibility = input.parse()?; 902 let macro_token: Token![macro] = input.parse()?; 903 let ident: Ident = input.parse()?; 904 905 let paren_token; 906 let args; 907 let brace_token; 908 let body; 909 let lookahead = input.lookahead1(); 910 if lookahead.peek(token::Paren) { 911 let paren_content; 912 paren_token = parenthesized!(paren_content in input); 913 args = paren_content.parse()?; 914 915 let brace_content; 916 brace_token = braced!(brace_content in input); 917 body = brace_content.parse()?; 918 } else if lookahead.peek(token::Brace) { 919 // Hack: the ItemMacro2 syntax tree will need to change so that 920 // we can store None for the args. 921 // 922 // https://github.com/dtolnay/syn/issues/548 923 // 924 // For now, store some sentinel tokens that are otherwise 925 // illegal. 926 paren_token = token::Paren::default(); 927 args = TokenStream::from_iter(vec![ 928 TokenTree::Punct(Punct::new('$', Spacing::Alone)), 929 TokenTree::Punct(Punct::new('$', Spacing::Alone)), 930 ]); 931 932 let brace_content; 933 brace_token = braced!(brace_content in input); 934 body = brace_content.parse()?; 935 } else { 936 return Err(lookahead.error()); 937 } 938 939 Ok(ItemMacro2 { 940 attrs: attrs, 941 vis: vis, 942 macro_token: macro_token, 943 ident: ident, 944 paren_token: paren_token, 945 args: args, 946 brace_token: brace_token, 947 body: body, 948 }) 949 } 950 } 951 952 impl Parse for ItemExternCrate { parse(input: ParseStream) -> Result<Self>953 fn parse(input: ParseStream) -> Result<Self> { 954 Ok(ItemExternCrate { 955 attrs: input.call(Attribute::parse_outer)?, 956 vis: input.parse()?, 957 extern_token: input.parse()?, 958 crate_token: input.parse()?, 959 ident: { 960 if input.peek(Token![self]) { 961 input.call(Ident::parse_any)? 962 } else { 963 input.parse()? 964 } 965 }, 966 rename: { 967 if input.peek(Token![as]) { 968 let as_token: Token![as] = input.parse()?; 969 let rename: Ident = input.parse()?; 970 Some((as_token, rename)) 971 } else { 972 None 973 } 974 }, 975 semi_token: input.parse()?, 976 }) 977 } 978 } 979 980 impl Parse for ItemUse { parse(input: ParseStream) -> Result<Self>981 fn parse(input: ParseStream) -> Result<Self> { 982 Ok(ItemUse { 983 attrs: input.call(Attribute::parse_outer)?, 984 vis: input.parse()?, 985 use_token: input.parse()?, 986 leading_colon: input.parse()?, 987 tree: input.call(use_tree)?, 988 semi_token: input.parse()?, 989 }) 990 } 991 } 992 use_tree(input: ParseStream) -> Result<UseTree>993 fn use_tree(input: ParseStream) -> Result<UseTree> { 994 let lookahead = input.lookahead1(); 995 if lookahead.peek(Ident) 996 || lookahead.peek(Token![self]) 997 || lookahead.peek(Token![super]) 998 || lookahead.peek(Token![crate]) 999 || lookahead.peek(Token![extern]) 1000 { 1001 let ident = input.call(Ident::parse_any)?; 1002 if input.peek(Token![::]) { 1003 Ok(UseTree::Path(UsePath { 1004 ident: ident, 1005 colon2_token: input.parse()?, 1006 tree: Box::new(input.call(use_tree)?), 1007 })) 1008 } else if input.peek(Token![as]) { 1009 Ok(UseTree::Rename(UseRename { 1010 ident: ident, 1011 as_token: input.parse()?, 1012 rename: { 1013 if input.peek(Ident) { 1014 input.parse()? 1015 } else if input.peek(Token![_]) { 1016 Ident::from(input.parse::<Token![_]>()?) 1017 } else { 1018 return Err(input.error("expected identifier or underscore")); 1019 } 1020 }, 1021 })) 1022 } else { 1023 Ok(UseTree::Name(UseName { ident: ident })) 1024 } 1025 } else if lookahead.peek(Token![*]) { 1026 Ok(UseTree::Glob(UseGlob { 1027 star_token: input.parse()?, 1028 })) 1029 } else if lookahead.peek(token::Brace) { 1030 let content; 1031 Ok(UseTree::Group(UseGroup { 1032 brace_token: braced!(content in input), 1033 items: content.parse_terminated(use_tree)?, 1034 })) 1035 } else { 1036 Err(lookahead.error()) 1037 } 1038 } 1039 1040 impl Parse for ItemStatic { parse(input: ParseStream) -> Result<Self>1041 fn parse(input: ParseStream) -> Result<Self> { 1042 Ok(ItemStatic { 1043 attrs: input.call(Attribute::parse_outer)?, 1044 vis: input.parse()?, 1045 static_token: input.parse()?, 1046 mutability: input.parse()?, 1047 ident: input.parse()?, 1048 colon_token: input.parse()?, 1049 ty: input.parse()?, 1050 eq_token: input.parse()?, 1051 expr: input.parse()?, 1052 semi_token: input.parse()?, 1053 }) 1054 } 1055 } 1056 1057 impl Parse for ItemConst { parse(input: ParseStream) -> Result<Self>1058 fn parse(input: ParseStream) -> Result<Self> { 1059 Ok(ItemConst { 1060 attrs: input.call(Attribute::parse_outer)?, 1061 vis: input.parse()?, 1062 const_token: input.parse()?, 1063 ident: { 1064 let lookahead = input.lookahead1(); 1065 if lookahead.peek(Ident) || lookahead.peek(Token![_]) { 1066 input.call(Ident::parse_any)? 1067 } else { 1068 return Err(lookahead.error()); 1069 } 1070 }, 1071 colon_token: input.parse()?, 1072 ty: input.parse()?, 1073 eq_token: input.parse()?, 1074 expr: input.parse()?, 1075 semi_token: input.parse()?, 1076 }) 1077 } 1078 } 1079 1080 impl Parse for ItemFn { parse(input: ParseStream) -> Result<Self>1081 fn parse(input: ParseStream) -> Result<Self> { 1082 let outer_attrs = input.call(Attribute::parse_outer)?; 1083 let vis: Visibility = input.parse()?; 1084 let constness: Option<Token![const]> = input.parse()?; 1085 let unsafety: Option<Token![unsafe]> = input.parse()?; 1086 let asyncness: Option<Token![async]> = input.parse()?; 1087 let abi: Option<Abi> = input.parse()?; 1088 let fn_token: Token![fn] = input.parse()?; 1089 let ident: Ident = input.parse()?; 1090 let generics: Generics = input.parse()?; 1091 1092 let content; 1093 let paren_token = parenthesized!(content in input); 1094 let inputs = content.parse_terminated(FnArg::parse)?; 1095 let variadic: Option<Token![...]> = match inputs.last() { 1096 Some(punctuated::Pair::End(&FnArg::Captured(ArgCaptured { 1097 ty: Type::Verbatim(TypeVerbatim { ref tts }), 1098 .. 1099 }))) => parse2(tts.clone()).ok(), 1100 _ => None, 1101 }; 1102 1103 let output: ReturnType = input.parse()?; 1104 let where_clause: Option<WhereClause> = input.parse()?; 1105 1106 let content; 1107 let brace_token = braced!(content in input); 1108 let inner_attrs = content.call(Attribute::parse_inner)?; 1109 let stmts = content.call(Block::parse_within)?; 1110 1111 Ok(ItemFn { 1112 attrs: private::attrs(outer_attrs, inner_attrs), 1113 vis: vis, 1114 constness: constness, 1115 unsafety: unsafety, 1116 asyncness: asyncness, 1117 abi: abi, 1118 ident: ident, 1119 decl: Box::new(FnDecl { 1120 fn_token: fn_token, 1121 paren_token: paren_token, 1122 inputs: inputs, 1123 output: output, 1124 variadic: variadic, 1125 generics: Generics { 1126 where_clause: where_clause, 1127 ..generics 1128 }, 1129 }), 1130 block: Box::new(Block { 1131 brace_token: brace_token, 1132 stmts: stmts, 1133 }), 1134 }) 1135 } 1136 } 1137 1138 impl Parse for FnArg { parse(input: ParseStream) -> Result<Self>1139 fn parse(input: ParseStream) -> Result<Self> { 1140 if input.peek(Token![&]) { 1141 let ahead = input.fork(); 1142 if ahead.call(arg_self_ref).is_ok() && !ahead.peek(Token![:]) { 1143 return input.call(arg_self_ref).map(FnArg::SelfRef); 1144 } 1145 } 1146 1147 if input.peek(Token![mut]) || input.peek(Token![self]) { 1148 let ahead = input.fork(); 1149 if ahead.call(arg_self).is_ok() && !ahead.peek(Token![:]) { 1150 return input.call(arg_self).map(FnArg::SelfValue); 1151 } 1152 } 1153 1154 let ahead = input.fork(); 1155 let err = match ahead.call(arg_captured) { 1156 Ok(_) => return input.call(arg_captured).map(FnArg::Captured), 1157 Err(err) => err, 1158 }; 1159 1160 let ahead = input.fork(); 1161 if ahead.parse::<Type>().is_ok() { 1162 return input.parse().map(FnArg::Ignored); 1163 } 1164 1165 Err(err) 1166 } 1167 } 1168 arg_self_ref(input: ParseStream) -> Result<ArgSelfRef>1169 fn arg_self_ref(input: ParseStream) -> Result<ArgSelfRef> { 1170 Ok(ArgSelfRef { 1171 and_token: input.parse()?, 1172 lifetime: input.parse()?, 1173 mutability: input.parse()?, 1174 self_token: input.parse()?, 1175 }) 1176 } 1177 arg_self(input: ParseStream) -> Result<ArgSelf>1178 fn arg_self(input: ParseStream) -> Result<ArgSelf> { 1179 Ok(ArgSelf { 1180 mutability: input.parse()?, 1181 self_token: input.parse()?, 1182 }) 1183 } 1184 arg_captured(input: ParseStream) -> Result<ArgCaptured>1185 fn arg_captured(input: ParseStream) -> Result<ArgCaptured> { 1186 Ok(ArgCaptured { 1187 pat: input.parse()?, 1188 colon_token: input.parse()?, 1189 ty: match input.parse::<Token![...]>() { 1190 Ok(dot3) => { 1191 let mut args = vec![ 1192 TokenTree::Punct(Punct::new('.', Spacing::Joint)), 1193 TokenTree::Punct(Punct::new('.', Spacing::Joint)), 1194 TokenTree::Punct(Punct::new('.', Spacing::Alone)), 1195 ]; 1196 let tokens = TokenStream::from_iter(args.into_iter().zip(&dot3.spans).map( 1197 |(mut arg, span)| { 1198 arg.set_span(*span); 1199 arg 1200 }, 1201 )); 1202 Type::Verbatim(TypeVerbatim { tts: tokens }) 1203 } 1204 Err(_) => input.parse()?, 1205 }, 1206 }) 1207 } 1208 1209 impl Parse for ItemMod { parse(input: ParseStream) -> Result<Self>1210 fn parse(input: ParseStream) -> Result<Self> { 1211 let outer_attrs = input.call(Attribute::parse_outer)?; 1212 let vis: Visibility = input.parse()?; 1213 let mod_token: Token![mod] = input.parse()?; 1214 let ident: Ident = input.parse()?; 1215 1216 let lookahead = input.lookahead1(); 1217 if lookahead.peek(Token![;]) { 1218 Ok(ItemMod { 1219 attrs: outer_attrs, 1220 vis: vis, 1221 mod_token: mod_token, 1222 ident: ident, 1223 content: None, 1224 semi: Some(input.parse()?), 1225 }) 1226 } else if lookahead.peek(token::Brace) { 1227 let content; 1228 let brace_token = braced!(content in input); 1229 let inner_attrs = content.call(Attribute::parse_inner)?; 1230 1231 let mut items = Vec::new(); 1232 while !content.is_empty() { 1233 items.push(content.parse()?); 1234 } 1235 1236 Ok(ItemMod { 1237 attrs: private::attrs(outer_attrs, inner_attrs), 1238 vis: vis, 1239 mod_token: mod_token, 1240 ident: ident, 1241 content: Some((brace_token, items)), 1242 semi: None, 1243 }) 1244 } else { 1245 Err(lookahead.error()) 1246 } 1247 } 1248 } 1249 1250 impl Parse for ItemForeignMod { parse(input: ParseStream) -> Result<Self>1251 fn parse(input: ParseStream) -> Result<Self> { 1252 let outer_attrs = input.call(Attribute::parse_outer)?; 1253 let abi: Abi = input.parse()?; 1254 1255 let content; 1256 let brace_token = braced!(content in input); 1257 let inner_attrs = content.call(Attribute::parse_inner)?; 1258 let mut items = Vec::new(); 1259 while !content.is_empty() { 1260 items.push(content.parse()?); 1261 } 1262 1263 Ok(ItemForeignMod { 1264 attrs: private::attrs(outer_attrs, inner_attrs), 1265 abi: abi, 1266 brace_token: brace_token, 1267 items: items, 1268 }) 1269 } 1270 } 1271 1272 impl Parse for ForeignItem { parse(input: ParseStream) -> Result<Self>1273 fn parse(input: ParseStream) -> Result<Self> { 1274 let ahead = input.fork(); 1275 ahead.call(Attribute::parse_outer)?; 1276 let vis: Visibility = ahead.parse()?; 1277 1278 let lookahead = ahead.lookahead1(); 1279 if lookahead.peek(Token![fn]) { 1280 input.parse().map(ForeignItem::Fn) 1281 } else if lookahead.peek(Token![static]) { 1282 input.parse().map(ForeignItem::Static) 1283 } else if lookahead.peek(Token![type]) { 1284 input.parse().map(ForeignItem::Type) 1285 } else if vis.is_inherited() 1286 && (lookahead.peek(Ident) 1287 || lookahead.peek(Token![self]) 1288 || lookahead.peek(Token![super]) 1289 || lookahead.peek(Token![extern]) 1290 || lookahead.peek(Token![crate]) 1291 || lookahead.peek(Token![::])) 1292 { 1293 input.parse().map(ForeignItem::Macro) 1294 } else { 1295 Err(lookahead.error()) 1296 } 1297 } 1298 } 1299 1300 impl Parse for ForeignItemFn { parse(input: ParseStream) -> Result<Self>1301 fn parse(input: ParseStream) -> Result<Self> { 1302 let attrs = input.call(Attribute::parse_outer)?; 1303 let vis: Visibility = input.parse()?; 1304 let fn_token: Token![fn] = input.parse()?; 1305 let ident: Ident = input.parse()?; 1306 let generics: Generics = input.parse()?; 1307 1308 let content; 1309 let paren_token = parenthesized!(content in input); 1310 let mut inputs = Punctuated::new(); 1311 while !content.is_empty() && !content.peek(Token![...]) { 1312 inputs.push_value(content.parse()?); 1313 if content.is_empty() { 1314 break; 1315 } 1316 inputs.push_punct(content.parse()?); 1317 } 1318 let variadic: Option<Token![...]> = if inputs.empty_or_trailing() { 1319 content.parse()? 1320 } else { 1321 None 1322 }; 1323 1324 let output: ReturnType = input.parse()?; 1325 let where_clause: Option<WhereClause> = input.parse()?; 1326 let semi_token: Token![;] = input.parse()?; 1327 1328 Ok(ForeignItemFn { 1329 attrs: attrs, 1330 vis: vis, 1331 ident: ident, 1332 decl: Box::new(FnDecl { 1333 fn_token: fn_token, 1334 paren_token: paren_token, 1335 inputs: inputs, 1336 output: output, 1337 variadic: variadic, 1338 generics: Generics { 1339 where_clause: where_clause, 1340 ..generics 1341 }, 1342 }), 1343 semi_token: semi_token, 1344 }) 1345 } 1346 } 1347 1348 impl Parse for ForeignItemStatic { parse(input: ParseStream) -> Result<Self>1349 fn parse(input: ParseStream) -> Result<Self> { 1350 Ok(ForeignItemStatic { 1351 attrs: input.call(Attribute::parse_outer)?, 1352 vis: input.parse()?, 1353 static_token: input.parse()?, 1354 mutability: input.parse()?, 1355 ident: input.parse()?, 1356 colon_token: input.parse()?, 1357 ty: input.parse()?, 1358 semi_token: input.parse()?, 1359 }) 1360 } 1361 } 1362 1363 impl Parse for ForeignItemType { parse(input: ParseStream) -> Result<Self>1364 fn parse(input: ParseStream) -> Result<Self> { 1365 Ok(ForeignItemType { 1366 attrs: input.call(Attribute::parse_outer)?, 1367 vis: input.parse()?, 1368 type_token: input.parse()?, 1369 ident: input.parse()?, 1370 semi_token: input.parse()?, 1371 }) 1372 } 1373 } 1374 1375 impl Parse for ForeignItemMacro { parse(input: ParseStream) -> Result<Self>1376 fn parse(input: ParseStream) -> Result<Self> { 1377 let attrs = input.call(Attribute::parse_outer)?; 1378 let mac: Macro = input.parse()?; 1379 let semi_token: Option<Token![;]> = if mac.delimiter.is_brace() { 1380 None 1381 } else { 1382 Some(input.parse()?) 1383 }; 1384 Ok(ForeignItemMacro { 1385 attrs: attrs, 1386 mac: mac, 1387 semi_token: semi_token, 1388 }) 1389 } 1390 } 1391 1392 impl Parse for ItemType { parse(input: ParseStream) -> Result<Self>1393 fn parse(input: ParseStream) -> Result<Self> { 1394 Ok(ItemType { 1395 attrs: input.call(Attribute::parse_outer)?, 1396 vis: input.parse()?, 1397 type_token: input.parse()?, 1398 ident: input.parse()?, 1399 generics: { 1400 let mut generics: Generics = input.parse()?; 1401 generics.where_clause = input.parse()?; 1402 generics 1403 }, 1404 eq_token: input.parse()?, 1405 ty: input.parse()?, 1406 semi_token: input.parse()?, 1407 }) 1408 } 1409 } 1410 1411 impl Parse for ItemExistential { parse(input: ParseStream) -> Result<Self>1412 fn parse(input: ParseStream) -> Result<Self> { 1413 Ok(ItemExistential { 1414 attrs: input.call(Attribute::parse_outer)?, 1415 vis: input.parse()?, 1416 existential_token: input.parse()?, 1417 type_token: input.parse()?, 1418 ident: input.parse()?, 1419 generics: { 1420 let mut generics: Generics = input.parse()?; 1421 generics.where_clause = input.parse()?; 1422 generics 1423 }, 1424 colon_token: Some(input.parse()?), 1425 bounds: { 1426 let mut bounds = Punctuated::new(); 1427 while !input.peek(Token![;]) { 1428 if !bounds.is_empty() { 1429 bounds.push_punct(input.parse()?); 1430 } 1431 bounds.push_value(input.parse()?); 1432 } 1433 bounds 1434 }, 1435 semi_token: input.parse()?, 1436 }) 1437 } 1438 } 1439 1440 impl Parse for ItemStruct { parse(input: ParseStream) -> Result<Self>1441 fn parse(input: ParseStream) -> Result<Self> { 1442 let attrs = input.call(Attribute::parse_outer)?; 1443 let vis = input.parse::<Visibility>()?; 1444 let struct_token = input.parse::<Token![struct]>()?; 1445 let ident = input.parse::<Ident>()?; 1446 let generics = input.parse::<Generics>()?; 1447 let (where_clause, fields, semi_token) = derive::parsing::data_struct(input)?; 1448 Ok(ItemStruct { 1449 attrs: attrs, 1450 vis: vis, 1451 struct_token: struct_token, 1452 ident: ident, 1453 generics: Generics { 1454 where_clause: where_clause, 1455 ..generics 1456 }, 1457 fields: fields, 1458 semi_token: semi_token, 1459 }) 1460 } 1461 } 1462 1463 impl Parse for ItemEnum { parse(input: ParseStream) -> Result<Self>1464 fn parse(input: ParseStream) -> Result<Self> { 1465 let attrs = input.call(Attribute::parse_outer)?; 1466 let vis = input.parse::<Visibility>()?; 1467 let enum_token = input.parse::<Token![enum]>()?; 1468 let ident = input.parse::<Ident>()?; 1469 let generics = input.parse::<Generics>()?; 1470 let (where_clause, brace_token, variants) = derive::parsing::data_enum(input)?; 1471 Ok(ItemEnum { 1472 attrs: attrs, 1473 vis: vis, 1474 enum_token: enum_token, 1475 ident: ident, 1476 generics: Generics { 1477 where_clause: where_clause, 1478 ..generics 1479 }, 1480 brace_token: brace_token, 1481 variants: variants, 1482 }) 1483 } 1484 } 1485 1486 impl Parse for ItemUnion { parse(input: ParseStream) -> Result<Self>1487 fn parse(input: ParseStream) -> Result<Self> { 1488 let attrs = input.call(Attribute::parse_outer)?; 1489 let vis = input.parse::<Visibility>()?; 1490 let union_token = input.parse::<Token![union]>()?; 1491 let ident = input.parse::<Ident>()?; 1492 let generics = input.parse::<Generics>()?; 1493 let (where_clause, fields) = derive::parsing::data_union(input)?; 1494 Ok(ItemUnion { 1495 attrs: attrs, 1496 vis: vis, 1497 union_token: union_token, 1498 ident: ident, 1499 generics: Generics { 1500 where_clause: where_clause, 1501 ..generics 1502 }, 1503 fields: fields, 1504 }) 1505 } 1506 } 1507 parse_trait_or_trait_alias(input: ParseStream) -> Result<Item>1508 fn parse_trait_or_trait_alias(input: ParseStream) -> Result<Item> { 1509 let (attrs, vis, trait_token, ident, generics) = parse_start_of_trait_alias(input)?; 1510 let lookahead = input.lookahead1(); 1511 if lookahead.peek(token::Brace) 1512 || lookahead.peek(Token![:]) 1513 || lookahead.peek(Token![where]) 1514 { 1515 let unsafety = None; 1516 let auto_token = None; 1517 parse_rest_of_trait( 1518 input, 1519 attrs, 1520 vis, 1521 unsafety, 1522 auto_token, 1523 trait_token, 1524 ident, 1525 generics, 1526 ) 1527 .map(Item::Trait) 1528 } else if lookahead.peek(Token![=]) { 1529 parse_rest_of_trait_alias(input, attrs, vis, trait_token, ident, generics) 1530 .map(Item::TraitAlias) 1531 } else { 1532 Err(lookahead.error()) 1533 } 1534 } 1535 1536 impl Parse for ItemTrait { parse(input: ParseStream) -> Result<Self>1537 fn parse(input: ParseStream) -> Result<Self> { 1538 let attrs = input.call(Attribute::parse_outer)?; 1539 let vis: Visibility = input.parse()?; 1540 let unsafety: Option<Token![unsafe]> = input.parse()?; 1541 let auto_token: Option<Token![auto]> = input.parse()?; 1542 let trait_token: Token![trait] = input.parse()?; 1543 let ident: Ident = input.parse()?; 1544 let generics: Generics = input.parse()?; 1545 parse_rest_of_trait( 1546 input, 1547 attrs, 1548 vis, 1549 unsafety, 1550 auto_token, 1551 trait_token, 1552 ident, 1553 generics, 1554 ) 1555 } 1556 } 1557 parse_rest_of_trait( input: ParseStream, 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>1558 fn parse_rest_of_trait( 1559 input: ParseStream, 1560 attrs: Vec<Attribute>, 1561 vis: Visibility, 1562 unsafety: Option<Token![unsafe]>, 1563 auto_token: Option<Token![auto]>, 1564 trait_token: Token![trait], 1565 ident: Ident, 1566 mut generics: Generics, 1567 ) -> Result<ItemTrait> { 1568 let colon_token: Option<Token![:]> = input.parse()?; 1569 1570 let mut supertraits = Punctuated::new(); 1571 if colon_token.is_some() { 1572 loop { 1573 supertraits.push_value(input.parse()?); 1574 if input.peek(Token![where]) || input.peek(token::Brace) { 1575 break; 1576 } 1577 supertraits.push_punct(input.parse()?); 1578 if input.peek(Token![where]) || input.peek(token::Brace) { 1579 break; 1580 } 1581 } 1582 } 1583 1584 generics.where_clause = input.parse()?; 1585 1586 let content; 1587 let brace_token = braced!(content in input); 1588 let mut items = Vec::new(); 1589 while !content.is_empty() { 1590 items.push(content.parse()?); 1591 } 1592 1593 Ok(ItemTrait { 1594 attrs: attrs, 1595 vis: vis, 1596 unsafety: unsafety, 1597 auto_token: auto_token, 1598 trait_token: trait_token, 1599 ident: ident, 1600 generics: generics, 1601 colon_token: colon_token, 1602 supertraits: supertraits, 1603 brace_token: brace_token, 1604 items: items, 1605 }) 1606 } 1607 1608 impl Parse for ItemTraitAlias { parse(input: ParseStream) -> Result<Self>1609 fn parse(input: ParseStream) -> Result<Self> { 1610 let (attrs, vis, trait_token, ident, generics) = parse_start_of_trait_alias(input)?; 1611 parse_rest_of_trait_alias(input, attrs, vis, trait_token, ident, generics) 1612 } 1613 } 1614 parse_start_of_trait_alias( input: ParseStream, ) -> Result<(Vec<Attribute>, Visibility, Token![trait], Ident, Generics)>1615 fn parse_start_of_trait_alias( 1616 input: ParseStream, 1617 ) -> Result<(Vec<Attribute>, Visibility, Token![trait], Ident, Generics)> { 1618 let attrs = input.call(Attribute::parse_outer)?; 1619 let vis: Visibility = input.parse()?; 1620 let trait_token: Token![trait] = input.parse()?; 1621 let ident: Ident = input.parse()?; 1622 let generics: Generics = input.parse()?; 1623 Ok((attrs, vis, trait_token, ident, generics)) 1624 } 1625 parse_rest_of_trait_alias( input: ParseStream, attrs: Vec<Attribute>, vis: Visibility, trait_token: Token![trait], ident: Ident, mut generics: Generics, ) -> Result<ItemTraitAlias>1626 fn parse_rest_of_trait_alias( 1627 input: ParseStream, 1628 attrs: Vec<Attribute>, 1629 vis: Visibility, 1630 trait_token: Token![trait], 1631 ident: Ident, 1632 mut generics: Generics, 1633 ) -> Result<ItemTraitAlias> { 1634 let eq_token: Token![=] = input.parse()?; 1635 1636 let mut bounds = Punctuated::new(); 1637 loop { 1638 if input.peek(Token![where]) || input.peek(Token![;]) { 1639 break; 1640 } 1641 bounds.push_value(input.parse()?); 1642 if input.peek(Token![where]) || input.peek(Token![;]) { 1643 break; 1644 } 1645 bounds.push_punct(input.parse()?); 1646 } 1647 1648 generics.where_clause = input.parse()?; 1649 let semi_token: Token![;] = input.parse()?; 1650 1651 Ok(ItemTraitAlias { 1652 attrs: attrs, 1653 vis: vis, 1654 trait_token: trait_token, 1655 ident: ident, 1656 generics: generics, 1657 eq_token: eq_token, 1658 bounds: bounds, 1659 semi_token: semi_token, 1660 }) 1661 } 1662 1663 impl Parse for TraitItem { parse(input: ParseStream) -> Result<Self>1664 fn parse(input: ParseStream) -> Result<Self> { 1665 let ahead = input.fork(); 1666 ahead.call(Attribute::parse_outer)?; 1667 1668 let lookahead = ahead.lookahead1(); 1669 if lookahead.peek(Token![const]) { 1670 ahead.parse::<Token![const]>()?; 1671 let lookahead = ahead.lookahead1(); 1672 if lookahead.peek(Ident) { 1673 input.parse().map(TraitItem::Const) 1674 } else if lookahead.peek(Token![unsafe]) 1675 || lookahead.peek(Token![extern]) 1676 || lookahead.peek(Token![fn]) 1677 { 1678 input.parse().map(TraitItem::Method) 1679 } else { 1680 Err(lookahead.error()) 1681 } 1682 } else if lookahead.peek(Token![unsafe]) 1683 || lookahead.peek(Token![extern]) 1684 || lookahead.peek(Token![fn]) 1685 { 1686 input.parse().map(TraitItem::Method) 1687 } else if lookahead.peek(Token![type]) { 1688 input.parse().map(TraitItem::Type) 1689 } else if lookahead.peek(Ident) 1690 || lookahead.peek(Token![self]) 1691 || lookahead.peek(Token![super]) 1692 || lookahead.peek(Token![extern]) 1693 || lookahead.peek(Token![crate]) 1694 || lookahead.peek(Token![::]) 1695 { 1696 input.parse().map(TraitItem::Macro) 1697 } else { 1698 Err(lookahead.error()) 1699 } 1700 } 1701 } 1702 1703 impl Parse for TraitItemConst { parse(input: ParseStream) -> Result<Self>1704 fn parse(input: ParseStream) -> Result<Self> { 1705 Ok(TraitItemConst { 1706 attrs: input.call(Attribute::parse_outer)?, 1707 const_token: input.parse()?, 1708 ident: input.parse()?, 1709 colon_token: input.parse()?, 1710 ty: input.parse()?, 1711 default: { 1712 if input.peek(Token![=]) { 1713 let eq_token: Token![=] = input.parse()?; 1714 let default: Expr = input.parse()?; 1715 Some((eq_token, default)) 1716 } else { 1717 None 1718 } 1719 }, 1720 semi_token: input.parse()?, 1721 }) 1722 } 1723 } 1724 1725 impl Parse for TraitItemMethod { parse(input: ParseStream) -> Result<Self>1726 fn parse(input: ParseStream) -> Result<Self> { 1727 let outer_attrs = input.call(Attribute::parse_outer)?; 1728 let constness: Option<Token![const]> = input.parse()?; 1729 let unsafety: Option<Token![unsafe]> = input.parse()?; 1730 let abi: Option<Abi> = input.parse()?; 1731 let fn_token: Token![fn] = input.parse()?; 1732 let ident: Ident = input.parse()?; 1733 let generics: Generics = input.parse()?; 1734 1735 let content; 1736 let paren_token = parenthesized!(content in input); 1737 let inputs = content.parse_terminated(FnArg::parse)?; 1738 1739 let output: ReturnType = input.parse()?; 1740 let where_clause: Option<WhereClause> = input.parse()?; 1741 1742 let lookahead = input.lookahead1(); 1743 let (brace_token, inner_attrs, stmts, semi_token) = if lookahead.peek(token::Brace) { 1744 let content; 1745 let brace_token = braced!(content in input); 1746 let inner_attrs = content.call(Attribute::parse_inner)?; 1747 let stmts = content.call(Block::parse_within)?; 1748 (Some(brace_token), inner_attrs, stmts, None) 1749 } else if lookahead.peek(Token![;]) { 1750 let semi_token: Token![;] = input.parse()?; 1751 (None, Vec::new(), Vec::new(), Some(semi_token)) 1752 } else { 1753 return Err(lookahead.error()); 1754 }; 1755 1756 Ok(TraitItemMethod { 1757 attrs: private::attrs(outer_attrs, inner_attrs), 1758 sig: MethodSig { 1759 constness: constness, 1760 unsafety: unsafety, 1761 asyncness: None, 1762 abi: abi, 1763 ident: ident, 1764 decl: FnDecl { 1765 fn_token: fn_token, 1766 paren_token: paren_token, 1767 inputs: inputs, 1768 output: output, 1769 variadic: None, 1770 generics: Generics { 1771 where_clause: where_clause, 1772 ..generics 1773 }, 1774 }, 1775 }, 1776 default: brace_token.map(|brace_token| Block { 1777 brace_token: brace_token, 1778 stmts: stmts, 1779 }), 1780 semi_token: semi_token, 1781 }) 1782 } 1783 } 1784 1785 impl Parse for TraitItemType { parse(input: ParseStream) -> Result<Self>1786 fn parse(input: ParseStream) -> Result<Self> { 1787 let attrs = input.call(Attribute::parse_outer)?; 1788 let type_token: Token![type] = input.parse()?; 1789 let ident: Ident = input.parse()?; 1790 let mut generics: Generics = input.parse()?; 1791 let colon_token: Option<Token![:]> = input.parse()?; 1792 1793 let mut bounds = Punctuated::new(); 1794 if colon_token.is_some() { 1795 while !input.peek(Token![where]) && !input.peek(Token![=]) && !input.peek(Token![;]) 1796 { 1797 if !bounds.is_empty() { 1798 bounds.push_punct(input.parse()?); 1799 } 1800 bounds.push_value(input.parse()?); 1801 } 1802 } 1803 1804 generics.where_clause = input.parse()?; 1805 let default = if input.peek(Token![=]) { 1806 let eq_token: Token![=] = input.parse()?; 1807 let default: Type = input.parse()?; 1808 Some((eq_token, default)) 1809 } else { 1810 None 1811 }; 1812 let semi_token: Token![;] = input.parse()?; 1813 1814 Ok(TraitItemType { 1815 attrs: attrs, 1816 type_token: type_token, 1817 ident: ident, 1818 generics: generics, 1819 colon_token: colon_token, 1820 bounds: bounds, 1821 default: default, 1822 semi_token: semi_token, 1823 }) 1824 } 1825 } 1826 1827 impl Parse for TraitItemMacro { parse(input: ParseStream) -> Result<Self>1828 fn parse(input: ParseStream) -> Result<Self> { 1829 let attrs = input.call(Attribute::parse_outer)?; 1830 let mac: Macro = input.parse()?; 1831 let semi_token: Option<Token![;]> = if mac.delimiter.is_brace() { 1832 None 1833 } else { 1834 Some(input.parse()?) 1835 }; 1836 Ok(TraitItemMacro { 1837 attrs: attrs, 1838 mac: mac, 1839 semi_token: semi_token, 1840 }) 1841 } 1842 } 1843 1844 impl Parse for ItemImpl { parse(input: ParseStream) -> Result<Self>1845 fn parse(input: ParseStream) -> Result<Self> { 1846 let outer_attrs = input.call(Attribute::parse_outer)?; 1847 let defaultness: Option<Token![default]> = input.parse()?; 1848 let unsafety: Option<Token![unsafe]> = input.parse()?; 1849 let impl_token: Token![impl ] = input.parse()?; 1850 1851 let has_generics = input.peek(Token![<]) 1852 && (input.peek2(Token![>]) 1853 || input.peek2(Token![#]) 1854 || (input.peek2(Ident) || input.peek2(Lifetime)) 1855 && (input.peek3(Token![:]) 1856 || input.peek3(Token![,]) 1857 || input.peek3(Token![>]))); 1858 let generics: Generics = if has_generics { 1859 input.parse()? 1860 } else { 1861 Generics::default() 1862 }; 1863 1864 let trait_ = { 1865 let ahead = input.fork(); 1866 if ahead.parse::<Option<Token![!]>>().is_ok() 1867 && ahead.parse::<Path>().is_ok() 1868 && ahead.parse::<Token![for]>().is_ok() 1869 { 1870 let polarity: Option<Token![!]> = input.parse()?; 1871 let path: Path = input.parse()?; 1872 let for_token: Token![for] = input.parse()?; 1873 Some((polarity, path, for_token)) 1874 } else { 1875 None 1876 } 1877 }; 1878 let self_ty: Type = input.parse()?; 1879 let where_clause: Option<WhereClause> = input.parse()?; 1880 1881 let content; 1882 let brace_token = braced!(content in input); 1883 let inner_attrs = content.call(Attribute::parse_inner)?; 1884 1885 let mut items = Vec::new(); 1886 while !content.is_empty() { 1887 items.push(content.parse()?); 1888 } 1889 1890 Ok(ItemImpl { 1891 attrs: private::attrs(outer_attrs, inner_attrs), 1892 defaultness: defaultness, 1893 unsafety: unsafety, 1894 impl_token: impl_token, 1895 generics: Generics { 1896 where_clause: where_clause, 1897 ..generics 1898 }, 1899 trait_: trait_, 1900 self_ty: Box::new(self_ty), 1901 brace_token: brace_token, 1902 items: items, 1903 }) 1904 } 1905 } 1906 1907 impl Parse for ImplItem { parse(input: ParseStream) -> Result<Self>1908 fn parse(input: ParseStream) -> Result<Self> { 1909 let ahead = input.fork(); 1910 ahead.call(Attribute::parse_outer)?; 1911 let vis: Visibility = ahead.parse()?; 1912 1913 let mut lookahead = ahead.lookahead1(); 1914 let defaultness = if lookahead.peek(Token![default]) && !ahead.peek2(Token![!]) { 1915 let defaultness: Token![default] = ahead.parse()?; 1916 lookahead = ahead.lookahead1(); 1917 Some(defaultness) 1918 } else { 1919 None 1920 }; 1921 1922 if lookahead.peek(Token![const]) { 1923 ahead.parse::<Token![const]>()?; 1924 let lookahead = ahead.lookahead1(); 1925 if lookahead.peek(Ident) { 1926 input.parse().map(ImplItem::Const) 1927 } else if lookahead.peek(Token![unsafe]) 1928 || lookahead.peek(Token![async]) 1929 || lookahead.peek(Token![extern]) 1930 || lookahead.peek(Token![fn]) 1931 { 1932 input.parse().map(ImplItem::Method) 1933 } else { 1934 Err(lookahead.error()) 1935 } 1936 } else if lookahead.peek(Token![unsafe]) 1937 || lookahead.peek(Token![async]) 1938 || lookahead.peek(Token![extern]) 1939 || lookahead.peek(Token![fn]) 1940 { 1941 input.parse().map(ImplItem::Method) 1942 } else if lookahead.peek(Token![type]) { 1943 input.parse().map(ImplItem::Type) 1944 } else if vis.is_inherited() 1945 && defaultness.is_none() 1946 && lookahead.peek(Token![existential]) 1947 { 1948 input.parse().map(ImplItem::Existential) 1949 } else if vis.is_inherited() 1950 && defaultness.is_none() 1951 && (lookahead.peek(Ident) 1952 || lookahead.peek(Token![self]) 1953 || lookahead.peek(Token![super]) 1954 || lookahead.peek(Token![extern]) 1955 || lookahead.peek(Token![crate]) 1956 || lookahead.peek(Token![::])) 1957 { 1958 input.parse().map(ImplItem::Macro) 1959 } else { 1960 Err(lookahead.error()) 1961 } 1962 } 1963 } 1964 1965 impl Parse for ImplItemConst { parse(input: ParseStream) -> Result<Self>1966 fn parse(input: ParseStream) -> Result<Self> { 1967 Ok(ImplItemConst { 1968 attrs: input.call(Attribute::parse_outer)?, 1969 vis: input.parse()?, 1970 defaultness: input.parse()?, 1971 const_token: input.parse()?, 1972 ident: input.parse()?, 1973 colon_token: input.parse()?, 1974 ty: input.parse()?, 1975 eq_token: input.parse()?, 1976 expr: input.parse()?, 1977 semi_token: input.parse()?, 1978 }) 1979 } 1980 } 1981 1982 impl Parse for ImplItemMethod { parse(input: ParseStream) -> Result<Self>1983 fn parse(input: ParseStream) -> Result<Self> { 1984 let outer_attrs = input.call(Attribute::parse_outer)?; 1985 let vis: Visibility = input.parse()?; 1986 let defaultness: Option<Token![default]> = input.parse()?; 1987 let constness: Option<Token![const]> = input.parse()?; 1988 let unsafety: Option<Token![unsafe]> = input.parse()?; 1989 let asyncness: Option<Token![async]> = input.parse()?; 1990 let abi: Option<Abi> = input.parse()?; 1991 let fn_token: Token![fn] = input.parse()?; 1992 let ident: Ident = input.parse()?; 1993 let generics: Generics = input.parse()?; 1994 1995 let content; 1996 let paren_token = parenthesized!(content in input); 1997 let inputs = content.parse_terminated(FnArg::parse)?; 1998 1999 let output: ReturnType = input.parse()?; 2000 let where_clause: Option<WhereClause> = input.parse()?; 2001 2002 let content; 2003 let brace_token = braced!(content in input); 2004 let inner_attrs = content.call(Attribute::parse_inner)?; 2005 let stmts = content.call(Block::parse_within)?; 2006 2007 Ok(ImplItemMethod { 2008 attrs: private::attrs(outer_attrs, inner_attrs), 2009 vis: vis, 2010 defaultness: defaultness, 2011 sig: MethodSig { 2012 constness: constness, 2013 unsafety: unsafety, 2014 asyncness: asyncness, 2015 abi: abi, 2016 ident: ident, 2017 decl: FnDecl { 2018 fn_token: fn_token, 2019 paren_token: paren_token, 2020 inputs: inputs, 2021 output: output, 2022 variadic: None, 2023 generics: Generics { 2024 where_clause: where_clause, 2025 ..generics 2026 }, 2027 }, 2028 }, 2029 block: Block { 2030 brace_token: brace_token, 2031 stmts: stmts, 2032 }, 2033 }) 2034 } 2035 } 2036 2037 impl Parse for ImplItemType { parse(input: ParseStream) -> Result<Self>2038 fn parse(input: ParseStream) -> Result<Self> { 2039 Ok(ImplItemType { 2040 attrs: input.call(Attribute::parse_outer)?, 2041 vis: input.parse()?, 2042 defaultness: input.parse()?, 2043 type_token: input.parse()?, 2044 ident: input.parse()?, 2045 generics: { 2046 let mut generics: Generics = input.parse()?; 2047 generics.where_clause = input.parse()?; 2048 generics 2049 }, 2050 eq_token: input.parse()?, 2051 ty: input.parse()?, 2052 semi_token: input.parse()?, 2053 }) 2054 } 2055 } 2056 2057 impl Parse for ImplItemExistential { parse(input: ParseStream) -> Result<Self>2058 fn parse(input: ParseStream) -> Result<Self> { 2059 let ety: ItemExistential = input.parse()?; 2060 Ok(ImplItemExistential { 2061 attrs: ety.attrs, 2062 existential_token: ety.existential_token, 2063 type_token: ety.type_token, 2064 ident: ety.ident, 2065 generics: ety.generics, 2066 colon_token: ety.colon_token, 2067 bounds: ety.bounds, 2068 semi_token: ety.semi_token, 2069 }) 2070 } 2071 } 2072 2073 impl Parse for ImplItemMacro { parse(input: ParseStream) -> Result<Self>2074 fn parse(input: ParseStream) -> Result<Self> { 2075 let attrs = input.call(Attribute::parse_outer)?; 2076 let mac: Macro = input.parse()?; 2077 let semi_token: Option<Token![;]> = if mac.delimiter.is_brace() { 2078 None 2079 } else { 2080 Some(input.parse()?) 2081 }; 2082 Ok(ImplItemMacro { 2083 attrs: attrs, 2084 mac: mac, 2085 semi_token: semi_token, 2086 }) 2087 } 2088 } 2089 2090 impl Visibility { is_inherited(&self) -> bool2091 fn is_inherited(&self) -> bool { 2092 match *self { 2093 Visibility::Inherited => true, 2094 _ => false, 2095 } 2096 } 2097 } 2098 2099 impl MacroDelimiter { is_brace(&self) -> bool2100 fn is_brace(&self) -> bool { 2101 match *self { 2102 MacroDelimiter::Brace(_) => true, 2103 MacroDelimiter::Paren(_) | MacroDelimiter::Bracket(_) => false, 2104 } 2105 } 2106 } 2107 } 2108 2109 #[cfg(feature = "printing")] 2110 mod printing { 2111 use super::*; 2112 2113 use proc_macro2::TokenStream; 2114 use quote::{ToTokens, TokenStreamExt}; 2115 2116 use attr::FilterAttrs; 2117 use print::TokensOrDefault; 2118 2119 impl ToTokens for ItemExternCrate { to_tokens(&self, tokens: &mut TokenStream)2120 fn to_tokens(&self, tokens: &mut TokenStream) { 2121 tokens.append_all(self.attrs.outer()); 2122 self.vis.to_tokens(tokens); 2123 self.extern_token.to_tokens(tokens); 2124 self.crate_token.to_tokens(tokens); 2125 self.ident.to_tokens(tokens); 2126 if let Some((ref as_token, ref rename)) = self.rename { 2127 as_token.to_tokens(tokens); 2128 rename.to_tokens(tokens); 2129 } 2130 self.semi_token.to_tokens(tokens); 2131 } 2132 } 2133 2134 impl ToTokens for ItemUse { to_tokens(&self, tokens: &mut TokenStream)2135 fn to_tokens(&self, tokens: &mut TokenStream) { 2136 tokens.append_all(self.attrs.outer()); 2137 self.vis.to_tokens(tokens); 2138 self.use_token.to_tokens(tokens); 2139 self.leading_colon.to_tokens(tokens); 2140 self.tree.to_tokens(tokens); 2141 self.semi_token.to_tokens(tokens); 2142 } 2143 } 2144 2145 impl ToTokens for ItemStatic { to_tokens(&self, tokens: &mut TokenStream)2146 fn to_tokens(&self, tokens: &mut TokenStream) { 2147 tokens.append_all(self.attrs.outer()); 2148 self.vis.to_tokens(tokens); 2149 self.static_token.to_tokens(tokens); 2150 self.mutability.to_tokens(tokens); 2151 self.ident.to_tokens(tokens); 2152 self.colon_token.to_tokens(tokens); 2153 self.ty.to_tokens(tokens); 2154 self.eq_token.to_tokens(tokens); 2155 self.expr.to_tokens(tokens); 2156 self.semi_token.to_tokens(tokens); 2157 } 2158 } 2159 2160 impl ToTokens for ItemConst { to_tokens(&self, tokens: &mut TokenStream)2161 fn to_tokens(&self, tokens: &mut TokenStream) { 2162 tokens.append_all(self.attrs.outer()); 2163 self.vis.to_tokens(tokens); 2164 self.const_token.to_tokens(tokens); 2165 self.ident.to_tokens(tokens); 2166 self.colon_token.to_tokens(tokens); 2167 self.ty.to_tokens(tokens); 2168 self.eq_token.to_tokens(tokens); 2169 self.expr.to_tokens(tokens); 2170 self.semi_token.to_tokens(tokens); 2171 } 2172 } 2173 2174 impl ToTokens for ItemFn { to_tokens(&self, tokens: &mut TokenStream)2175 fn to_tokens(&self, tokens: &mut TokenStream) { 2176 tokens.append_all(self.attrs.outer()); 2177 self.vis.to_tokens(tokens); 2178 self.constness.to_tokens(tokens); 2179 self.unsafety.to_tokens(tokens); 2180 self.asyncness.to_tokens(tokens); 2181 self.abi.to_tokens(tokens); 2182 NamedDecl(&self.decl, &self.ident).to_tokens(tokens); 2183 self.block.brace_token.surround(tokens, |tokens| { 2184 tokens.append_all(self.attrs.inner()); 2185 tokens.append_all(&self.block.stmts); 2186 }); 2187 } 2188 } 2189 2190 impl ToTokens for ItemMod { to_tokens(&self, tokens: &mut TokenStream)2191 fn to_tokens(&self, tokens: &mut TokenStream) { 2192 tokens.append_all(self.attrs.outer()); 2193 self.vis.to_tokens(tokens); 2194 self.mod_token.to_tokens(tokens); 2195 self.ident.to_tokens(tokens); 2196 if let Some((ref brace, ref items)) = self.content { 2197 brace.surround(tokens, |tokens| { 2198 tokens.append_all(self.attrs.inner()); 2199 tokens.append_all(items); 2200 }); 2201 } else { 2202 TokensOrDefault(&self.semi).to_tokens(tokens); 2203 } 2204 } 2205 } 2206 2207 impl ToTokens for ItemForeignMod { to_tokens(&self, tokens: &mut TokenStream)2208 fn to_tokens(&self, tokens: &mut TokenStream) { 2209 tokens.append_all(self.attrs.outer()); 2210 self.abi.to_tokens(tokens); 2211 self.brace_token.surround(tokens, |tokens| { 2212 tokens.append_all(self.attrs.inner()); 2213 tokens.append_all(&self.items); 2214 }); 2215 } 2216 } 2217 2218 impl ToTokens for ItemType { to_tokens(&self, tokens: &mut TokenStream)2219 fn to_tokens(&self, tokens: &mut TokenStream) { 2220 tokens.append_all(self.attrs.outer()); 2221 self.vis.to_tokens(tokens); 2222 self.type_token.to_tokens(tokens); 2223 self.ident.to_tokens(tokens); 2224 self.generics.to_tokens(tokens); 2225 self.generics.where_clause.to_tokens(tokens); 2226 self.eq_token.to_tokens(tokens); 2227 self.ty.to_tokens(tokens); 2228 self.semi_token.to_tokens(tokens); 2229 } 2230 } 2231 2232 impl ToTokens for ItemExistential { to_tokens(&self, tokens: &mut TokenStream)2233 fn to_tokens(&self, tokens: &mut TokenStream) { 2234 tokens.append_all(self.attrs.outer()); 2235 self.vis.to_tokens(tokens); 2236 self.existential_token.to_tokens(tokens); 2237 self.type_token.to_tokens(tokens); 2238 self.ident.to_tokens(tokens); 2239 self.generics.to_tokens(tokens); 2240 self.generics.where_clause.to_tokens(tokens); 2241 if !self.bounds.is_empty() { 2242 TokensOrDefault(&self.colon_token).to_tokens(tokens); 2243 self.bounds.to_tokens(tokens); 2244 } 2245 self.semi_token.to_tokens(tokens); 2246 } 2247 } 2248 2249 impl ToTokens for ItemEnum { to_tokens(&self, tokens: &mut TokenStream)2250 fn to_tokens(&self, tokens: &mut TokenStream) { 2251 tokens.append_all(self.attrs.outer()); 2252 self.vis.to_tokens(tokens); 2253 self.enum_token.to_tokens(tokens); 2254 self.ident.to_tokens(tokens); 2255 self.generics.to_tokens(tokens); 2256 self.generics.where_clause.to_tokens(tokens); 2257 self.brace_token.surround(tokens, |tokens| { 2258 self.variants.to_tokens(tokens); 2259 }); 2260 } 2261 } 2262 2263 impl ToTokens for ItemStruct { to_tokens(&self, tokens: &mut TokenStream)2264 fn to_tokens(&self, tokens: &mut TokenStream) { 2265 tokens.append_all(self.attrs.outer()); 2266 self.vis.to_tokens(tokens); 2267 self.struct_token.to_tokens(tokens); 2268 self.ident.to_tokens(tokens); 2269 self.generics.to_tokens(tokens); 2270 match self.fields { 2271 Fields::Named(ref fields) => { 2272 self.generics.where_clause.to_tokens(tokens); 2273 fields.to_tokens(tokens); 2274 } 2275 Fields::Unnamed(ref fields) => { 2276 fields.to_tokens(tokens); 2277 self.generics.where_clause.to_tokens(tokens); 2278 TokensOrDefault(&self.semi_token).to_tokens(tokens); 2279 } 2280 Fields::Unit => { 2281 self.generics.where_clause.to_tokens(tokens); 2282 TokensOrDefault(&self.semi_token).to_tokens(tokens); 2283 } 2284 } 2285 } 2286 } 2287 2288 impl ToTokens for ItemUnion { to_tokens(&self, tokens: &mut TokenStream)2289 fn to_tokens(&self, tokens: &mut TokenStream) { 2290 tokens.append_all(self.attrs.outer()); 2291 self.vis.to_tokens(tokens); 2292 self.union_token.to_tokens(tokens); 2293 self.ident.to_tokens(tokens); 2294 self.generics.to_tokens(tokens); 2295 self.generics.where_clause.to_tokens(tokens); 2296 self.fields.to_tokens(tokens); 2297 } 2298 } 2299 2300 impl ToTokens for ItemTrait { to_tokens(&self, tokens: &mut TokenStream)2301 fn to_tokens(&self, tokens: &mut TokenStream) { 2302 tokens.append_all(self.attrs.outer()); 2303 self.vis.to_tokens(tokens); 2304 self.unsafety.to_tokens(tokens); 2305 self.auto_token.to_tokens(tokens); 2306 self.trait_token.to_tokens(tokens); 2307 self.ident.to_tokens(tokens); 2308 self.generics.to_tokens(tokens); 2309 if !self.supertraits.is_empty() { 2310 TokensOrDefault(&self.colon_token).to_tokens(tokens); 2311 self.supertraits.to_tokens(tokens); 2312 } 2313 self.generics.where_clause.to_tokens(tokens); 2314 self.brace_token.surround(tokens, |tokens| { 2315 tokens.append_all(&self.items); 2316 }); 2317 } 2318 } 2319 2320 impl ToTokens for ItemTraitAlias { to_tokens(&self, tokens: &mut TokenStream)2321 fn to_tokens(&self, tokens: &mut TokenStream) { 2322 tokens.append_all(self.attrs.outer()); 2323 self.vis.to_tokens(tokens); 2324 self.trait_token.to_tokens(tokens); 2325 self.ident.to_tokens(tokens); 2326 self.generics.to_tokens(tokens); 2327 self.eq_token.to_tokens(tokens); 2328 self.bounds.to_tokens(tokens); 2329 self.generics.where_clause.to_tokens(tokens); 2330 self.semi_token.to_tokens(tokens); 2331 } 2332 } 2333 2334 impl ToTokens for ItemImpl { to_tokens(&self, tokens: &mut TokenStream)2335 fn to_tokens(&self, tokens: &mut TokenStream) { 2336 tokens.append_all(self.attrs.outer()); 2337 self.defaultness.to_tokens(tokens); 2338 self.unsafety.to_tokens(tokens); 2339 self.impl_token.to_tokens(tokens); 2340 self.generics.to_tokens(tokens); 2341 if let Some((ref polarity, ref path, ref for_token)) = self.trait_ { 2342 polarity.to_tokens(tokens); 2343 path.to_tokens(tokens); 2344 for_token.to_tokens(tokens); 2345 } 2346 self.self_ty.to_tokens(tokens); 2347 self.generics.where_clause.to_tokens(tokens); 2348 self.brace_token.surround(tokens, |tokens| { 2349 tokens.append_all(self.attrs.inner()); 2350 tokens.append_all(&self.items); 2351 }); 2352 } 2353 } 2354 2355 impl ToTokens for ItemMacro { to_tokens(&self, tokens: &mut TokenStream)2356 fn to_tokens(&self, tokens: &mut TokenStream) { 2357 tokens.append_all(self.attrs.outer()); 2358 self.mac.path.to_tokens(tokens); 2359 self.mac.bang_token.to_tokens(tokens); 2360 self.ident.to_tokens(tokens); 2361 match self.mac.delimiter { 2362 MacroDelimiter::Paren(ref paren) => { 2363 paren.surround(tokens, |tokens| self.mac.tts.to_tokens(tokens)); 2364 } 2365 MacroDelimiter::Brace(ref brace) => { 2366 brace.surround(tokens, |tokens| self.mac.tts.to_tokens(tokens)); 2367 } 2368 MacroDelimiter::Bracket(ref bracket) => { 2369 bracket.surround(tokens, |tokens| self.mac.tts.to_tokens(tokens)); 2370 } 2371 } 2372 self.semi_token.to_tokens(tokens); 2373 } 2374 } 2375 2376 impl ToTokens for ItemMacro2 { to_tokens(&self, tokens: &mut TokenStream)2377 fn to_tokens(&self, tokens: &mut TokenStream) { 2378 tokens.append_all(self.attrs.outer()); 2379 self.vis.to_tokens(tokens); 2380 self.macro_token.to_tokens(tokens); 2381 self.ident.to_tokens(tokens); 2382 2383 // Hack: see comment in impl Parse for ItemMacro2. 2384 if self.args.to_string() != "$ $" { 2385 self.paren_token.surround(tokens, |tokens| { 2386 self.args.to_tokens(tokens); 2387 }); 2388 } 2389 2390 self.brace_token.surround(tokens, |tokens| { 2391 self.body.to_tokens(tokens); 2392 }); 2393 } 2394 } 2395 2396 impl ToTokens for ItemVerbatim { to_tokens(&self, tokens: &mut TokenStream)2397 fn to_tokens(&self, tokens: &mut TokenStream) { 2398 self.tts.to_tokens(tokens); 2399 } 2400 } 2401 2402 impl ToTokens for UsePath { to_tokens(&self, tokens: &mut TokenStream)2403 fn to_tokens(&self, tokens: &mut TokenStream) { 2404 self.ident.to_tokens(tokens); 2405 self.colon2_token.to_tokens(tokens); 2406 self.tree.to_tokens(tokens); 2407 } 2408 } 2409 2410 impl ToTokens for UseName { to_tokens(&self, tokens: &mut TokenStream)2411 fn to_tokens(&self, tokens: &mut TokenStream) { 2412 self.ident.to_tokens(tokens); 2413 } 2414 } 2415 2416 impl ToTokens for UseRename { to_tokens(&self, tokens: &mut TokenStream)2417 fn to_tokens(&self, tokens: &mut TokenStream) { 2418 self.ident.to_tokens(tokens); 2419 self.as_token.to_tokens(tokens); 2420 self.rename.to_tokens(tokens); 2421 } 2422 } 2423 2424 impl ToTokens for UseGlob { to_tokens(&self, tokens: &mut TokenStream)2425 fn to_tokens(&self, tokens: &mut TokenStream) { 2426 self.star_token.to_tokens(tokens); 2427 } 2428 } 2429 2430 impl ToTokens for UseGroup { to_tokens(&self, tokens: &mut TokenStream)2431 fn to_tokens(&self, tokens: &mut TokenStream) { 2432 self.brace_token.surround(tokens, |tokens| { 2433 self.items.to_tokens(tokens); 2434 }); 2435 } 2436 } 2437 2438 impl ToTokens for TraitItemConst { to_tokens(&self, tokens: &mut TokenStream)2439 fn to_tokens(&self, tokens: &mut TokenStream) { 2440 tokens.append_all(self.attrs.outer()); 2441 self.const_token.to_tokens(tokens); 2442 self.ident.to_tokens(tokens); 2443 self.colon_token.to_tokens(tokens); 2444 self.ty.to_tokens(tokens); 2445 if let Some((ref eq_token, ref default)) = self.default { 2446 eq_token.to_tokens(tokens); 2447 default.to_tokens(tokens); 2448 } 2449 self.semi_token.to_tokens(tokens); 2450 } 2451 } 2452 2453 impl ToTokens for TraitItemMethod { to_tokens(&self, tokens: &mut TokenStream)2454 fn to_tokens(&self, tokens: &mut TokenStream) { 2455 tokens.append_all(self.attrs.outer()); 2456 self.sig.to_tokens(tokens); 2457 match self.default { 2458 Some(ref block) => { 2459 block.brace_token.surround(tokens, |tokens| { 2460 tokens.append_all(self.attrs.inner()); 2461 tokens.append_all(&block.stmts); 2462 }); 2463 } 2464 None => { 2465 TokensOrDefault(&self.semi_token).to_tokens(tokens); 2466 } 2467 } 2468 } 2469 } 2470 2471 impl ToTokens for TraitItemType { to_tokens(&self, tokens: &mut TokenStream)2472 fn to_tokens(&self, tokens: &mut TokenStream) { 2473 tokens.append_all(self.attrs.outer()); 2474 self.type_token.to_tokens(tokens); 2475 self.ident.to_tokens(tokens); 2476 self.generics.to_tokens(tokens); 2477 if !self.bounds.is_empty() { 2478 TokensOrDefault(&self.colon_token).to_tokens(tokens); 2479 self.bounds.to_tokens(tokens); 2480 } 2481 self.generics.where_clause.to_tokens(tokens); 2482 if let Some((ref eq_token, ref default)) = self.default { 2483 eq_token.to_tokens(tokens); 2484 default.to_tokens(tokens); 2485 } 2486 self.semi_token.to_tokens(tokens); 2487 } 2488 } 2489 2490 impl ToTokens for TraitItemMacro { to_tokens(&self, tokens: &mut TokenStream)2491 fn to_tokens(&self, tokens: &mut TokenStream) { 2492 tokens.append_all(self.attrs.outer()); 2493 self.mac.to_tokens(tokens); 2494 self.semi_token.to_tokens(tokens); 2495 } 2496 } 2497 2498 impl ToTokens for TraitItemVerbatim { to_tokens(&self, tokens: &mut TokenStream)2499 fn to_tokens(&self, tokens: &mut TokenStream) { 2500 self.tts.to_tokens(tokens); 2501 } 2502 } 2503 2504 impl ToTokens for ImplItemConst { to_tokens(&self, tokens: &mut TokenStream)2505 fn to_tokens(&self, tokens: &mut TokenStream) { 2506 tokens.append_all(self.attrs.outer()); 2507 self.vis.to_tokens(tokens); 2508 self.defaultness.to_tokens(tokens); 2509 self.const_token.to_tokens(tokens); 2510 self.ident.to_tokens(tokens); 2511 self.colon_token.to_tokens(tokens); 2512 self.ty.to_tokens(tokens); 2513 self.eq_token.to_tokens(tokens); 2514 self.expr.to_tokens(tokens); 2515 self.semi_token.to_tokens(tokens); 2516 } 2517 } 2518 2519 impl ToTokens for ImplItemMethod { to_tokens(&self, tokens: &mut TokenStream)2520 fn to_tokens(&self, tokens: &mut TokenStream) { 2521 tokens.append_all(self.attrs.outer()); 2522 self.vis.to_tokens(tokens); 2523 self.defaultness.to_tokens(tokens); 2524 self.sig.to_tokens(tokens); 2525 self.block.brace_token.surround(tokens, |tokens| { 2526 tokens.append_all(self.attrs.inner()); 2527 tokens.append_all(&self.block.stmts); 2528 }); 2529 } 2530 } 2531 2532 impl ToTokens for ImplItemType { to_tokens(&self, tokens: &mut TokenStream)2533 fn to_tokens(&self, tokens: &mut TokenStream) { 2534 tokens.append_all(self.attrs.outer()); 2535 self.vis.to_tokens(tokens); 2536 self.defaultness.to_tokens(tokens); 2537 self.type_token.to_tokens(tokens); 2538 self.ident.to_tokens(tokens); 2539 self.generics.to_tokens(tokens); 2540 self.generics.where_clause.to_tokens(tokens); 2541 self.eq_token.to_tokens(tokens); 2542 self.ty.to_tokens(tokens); 2543 self.semi_token.to_tokens(tokens); 2544 } 2545 } 2546 2547 impl ToTokens for ImplItemExistential { to_tokens(&self, tokens: &mut TokenStream)2548 fn to_tokens(&self, tokens: &mut TokenStream) { 2549 tokens.append_all(self.attrs.outer()); 2550 self.existential_token.to_tokens(tokens); 2551 self.type_token.to_tokens(tokens); 2552 self.ident.to_tokens(tokens); 2553 self.generics.to_tokens(tokens); 2554 self.generics.where_clause.to_tokens(tokens); 2555 if !self.bounds.is_empty() { 2556 TokensOrDefault(&self.colon_token).to_tokens(tokens); 2557 self.bounds.to_tokens(tokens); 2558 } 2559 self.semi_token.to_tokens(tokens); 2560 } 2561 } 2562 2563 impl ToTokens for ImplItemMacro { to_tokens(&self, tokens: &mut TokenStream)2564 fn to_tokens(&self, tokens: &mut TokenStream) { 2565 tokens.append_all(self.attrs.outer()); 2566 self.mac.to_tokens(tokens); 2567 self.semi_token.to_tokens(tokens); 2568 } 2569 } 2570 2571 impl ToTokens for ImplItemVerbatim { to_tokens(&self, tokens: &mut TokenStream)2572 fn to_tokens(&self, tokens: &mut TokenStream) { 2573 self.tts.to_tokens(tokens); 2574 } 2575 } 2576 2577 impl ToTokens for ForeignItemFn { to_tokens(&self, tokens: &mut TokenStream)2578 fn to_tokens(&self, tokens: &mut TokenStream) { 2579 tokens.append_all(self.attrs.outer()); 2580 self.vis.to_tokens(tokens); 2581 NamedDecl(&self.decl, &self.ident).to_tokens(tokens); 2582 self.semi_token.to_tokens(tokens); 2583 } 2584 } 2585 2586 impl ToTokens for ForeignItemStatic { to_tokens(&self, tokens: &mut TokenStream)2587 fn to_tokens(&self, tokens: &mut TokenStream) { 2588 tokens.append_all(self.attrs.outer()); 2589 self.vis.to_tokens(tokens); 2590 self.static_token.to_tokens(tokens); 2591 self.mutability.to_tokens(tokens); 2592 self.ident.to_tokens(tokens); 2593 self.colon_token.to_tokens(tokens); 2594 self.ty.to_tokens(tokens); 2595 self.semi_token.to_tokens(tokens); 2596 } 2597 } 2598 2599 impl ToTokens for ForeignItemType { to_tokens(&self, tokens: &mut TokenStream)2600 fn to_tokens(&self, tokens: &mut TokenStream) { 2601 tokens.append_all(self.attrs.outer()); 2602 self.vis.to_tokens(tokens); 2603 self.type_token.to_tokens(tokens); 2604 self.ident.to_tokens(tokens); 2605 self.semi_token.to_tokens(tokens); 2606 } 2607 } 2608 2609 impl ToTokens for ForeignItemMacro { to_tokens(&self, tokens: &mut TokenStream)2610 fn to_tokens(&self, tokens: &mut TokenStream) { 2611 tokens.append_all(self.attrs.outer()); 2612 self.mac.to_tokens(tokens); 2613 self.semi_token.to_tokens(tokens); 2614 } 2615 } 2616 2617 impl ToTokens for ForeignItemVerbatim { to_tokens(&self, tokens: &mut TokenStream)2618 fn to_tokens(&self, tokens: &mut TokenStream) { 2619 self.tts.to_tokens(tokens); 2620 } 2621 } 2622 2623 impl ToTokens for MethodSig { to_tokens(&self, tokens: &mut TokenStream)2624 fn to_tokens(&self, tokens: &mut TokenStream) { 2625 self.constness.to_tokens(tokens); 2626 self.unsafety.to_tokens(tokens); 2627 self.asyncness.to_tokens(tokens); 2628 self.abi.to_tokens(tokens); 2629 NamedDecl(&self.decl, &self.ident).to_tokens(tokens); 2630 } 2631 } 2632 2633 struct NamedDecl<'a>(&'a FnDecl, &'a Ident); 2634 2635 impl<'a> ToTokens for NamedDecl<'a> { to_tokens(&self, tokens: &mut TokenStream)2636 fn to_tokens(&self, tokens: &mut TokenStream) { 2637 self.0.fn_token.to_tokens(tokens); 2638 self.1.to_tokens(tokens); 2639 self.0.generics.to_tokens(tokens); 2640 self.0.paren_token.surround(tokens, |tokens| { 2641 self.0.inputs.to_tokens(tokens); 2642 if self.0.variadic.is_some() && !self.0.inputs.empty_or_trailing() { 2643 <Token![,]>::default().to_tokens(tokens); 2644 } 2645 self.0.variadic.to_tokens(tokens); 2646 }); 2647 self.0.output.to_tokens(tokens); 2648 self.0.generics.where_clause.to_tokens(tokens); 2649 } 2650 } 2651 2652 impl ToTokens for ArgSelfRef { to_tokens(&self, tokens: &mut TokenStream)2653 fn to_tokens(&self, tokens: &mut TokenStream) { 2654 self.and_token.to_tokens(tokens); 2655 self.lifetime.to_tokens(tokens); 2656 self.mutability.to_tokens(tokens); 2657 self.self_token.to_tokens(tokens); 2658 } 2659 } 2660 2661 impl ToTokens for ArgSelf { to_tokens(&self, tokens: &mut TokenStream)2662 fn to_tokens(&self, tokens: &mut TokenStream) { 2663 self.mutability.to_tokens(tokens); 2664 self.self_token.to_tokens(tokens); 2665 } 2666 } 2667 2668 impl ToTokens for ArgCaptured { to_tokens(&self, tokens: &mut TokenStream)2669 fn to_tokens(&self, tokens: &mut TokenStream) { 2670 self.pat.to_tokens(tokens); 2671 self.colon_token.to_tokens(tokens); 2672 self.ty.to_tokens(tokens); 2673 } 2674 } 2675 } 2676