1 use crate::algorithm::Printer; 2 use crate::iter::IterDelimited; 3 use crate::path::PathKind; 4 use crate::INDENT; 5 use proc_macro2::TokenStream; 6 use syn::{ 7 Fields, FnArg, ForeignItem, ForeignItemFn, ForeignItemMacro, ForeignItemStatic, 8 ForeignItemType, ImplItem, ImplItemConst, ImplItemFn, ImplItemMacro, ImplItemType, Item, 9 ItemConst, ItemEnum, ItemExternCrate, ItemFn, ItemForeignMod, ItemImpl, ItemMacro, ItemMod, 10 ItemStatic, ItemStruct, ItemTrait, ItemTraitAlias, ItemType, ItemUnion, ItemUse, Receiver, 11 Signature, StaticMutability, TraitItem, TraitItemConst, TraitItemFn, TraitItemMacro, 12 TraitItemType, Type, UseGlob, UseGroup, UseName, UsePath, UseRename, UseTree, Variadic, 13 }; 14 15 impl Printer { item(&mut self, item: &Item)16 pub fn item(&mut self, item: &Item) { 17 match item { 18 #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))] 19 Item::Const(item) => self.item_const(item), 20 Item::Enum(item) => self.item_enum(item), 21 Item::ExternCrate(item) => self.item_extern_crate(item), 22 Item::Fn(item) => self.item_fn(item), 23 Item::ForeignMod(item) => self.item_foreign_mod(item), 24 Item::Impl(item) => self.item_impl(item), 25 Item::Macro(item) => self.item_macro(item), 26 Item::Mod(item) => self.item_mod(item), 27 Item::Static(item) => self.item_static(item), 28 Item::Struct(item) => self.item_struct(item), 29 Item::Trait(item) => self.item_trait(item), 30 Item::TraitAlias(item) => self.item_trait_alias(item), 31 Item::Type(item) => self.item_type(item), 32 Item::Union(item) => self.item_union(item), 33 Item::Use(item) => self.item_use(item), 34 Item::Verbatim(item) => self.item_verbatim(item), 35 _ => unimplemented!("unknown Item"), 36 } 37 } 38 item_const(&mut self, item: &ItemConst)39 fn item_const(&mut self, item: &ItemConst) { 40 self.outer_attrs(&item.attrs); 41 self.cbox(0); 42 self.visibility(&item.vis); 43 self.word("const "); 44 self.ident(&item.ident); 45 self.generics(&item.generics); 46 self.word(": "); 47 self.ty(&item.ty); 48 self.word(" = "); 49 self.neverbreak(); 50 self.expr(&item.expr); 51 self.word(";"); 52 self.end(); 53 self.hardbreak(); 54 } 55 item_enum(&mut self, item: &ItemEnum)56 fn item_enum(&mut self, item: &ItemEnum) { 57 self.outer_attrs(&item.attrs); 58 self.cbox(INDENT); 59 self.visibility(&item.vis); 60 self.word("enum "); 61 self.ident(&item.ident); 62 self.generics(&item.generics); 63 self.where_clause_for_body(&item.generics.where_clause); 64 self.word("{"); 65 self.hardbreak_if_nonempty(); 66 for variant in &item.variants { 67 self.variant(variant); 68 self.word(","); 69 self.hardbreak(); 70 } 71 self.offset(-INDENT); 72 self.end(); 73 self.word("}"); 74 self.hardbreak(); 75 } 76 item_extern_crate(&mut self, item: &ItemExternCrate)77 fn item_extern_crate(&mut self, item: &ItemExternCrate) { 78 self.outer_attrs(&item.attrs); 79 self.visibility(&item.vis); 80 self.word("extern crate "); 81 self.ident(&item.ident); 82 if let Some((_as_token, rename)) = &item.rename { 83 self.word(" as "); 84 self.ident(rename); 85 } 86 self.word(";"); 87 self.hardbreak(); 88 } 89 item_fn(&mut self, item: &ItemFn)90 fn item_fn(&mut self, item: &ItemFn) { 91 self.outer_attrs(&item.attrs); 92 self.cbox(INDENT); 93 self.visibility(&item.vis); 94 self.signature(&item.sig); 95 self.where_clause_for_body(&item.sig.generics.where_clause); 96 self.word("{"); 97 self.hardbreak_if_nonempty(); 98 self.inner_attrs(&item.attrs); 99 for stmt in &item.block.stmts { 100 self.stmt(stmt); 101 } 102 self.offset(-INDENT); 103 self.end(); 104 self.word("}"); 105 self.hardbreak(); 106 } 107 item_foreign_mod(&mut self, item: &ItemForeignMod)108 fn item_foreign_mod(&mut self, item: &ItemForeignMod) { 109 self.outer_attrs(&item.attrs); 110 self.cbox(INDENT); 111 if item.unsafety.is_some() { 112 self.word("unsafe "); 113 } 114 self.abi(&item.abi); 115 self.word("{"); 116 self.hardbreak_if_nonempty(); 117 self.inner_attrs(&item.attrs); 118 for foreign_item in &item.items { 119 self.foreign_item(foreign_item); 120 } 121 self.offset(-INDENT); 122 self.end(); 123 self.word("}"); 124 self.hardbreak(); 125 } 126 item_impl(&mut self, item: &ItemImpl)127 fn item_impl(&mut self, item: &ItemImpl) { 128 self.outer_attrs(&item.attrs); 129 self.cbox(INDENT); 130 self.ibox(-INDENT); 131 self.cbox(INDENT); 132 if item.defaultness.is_some() { 133 self.word("default "); 134 } 135 if item.unsafety.is_some() { 136 self.word("unsafe "); 137 } 138 self.word("impl"); 139 self.generics(&item.generics); 140 self.end(); 141 self.nbsp(); 142 if let Some((negative_polarity, path, _for_token)) = &item.trait_ { 143 if negative_polarity.is_some() { 144 self.word("!"); 145 } 146 self.path(path, PathKind::Type); 147 self.space(); 148 self.word("for "); 149 } 150 self.ty(&item.self_ty); 151 self.end(); 152 self.where_clause_for_body(&item.generics.where_clause); 153 self.word("{"); 154 self.hardbreak_if_nonempty(); 155 self.inner_attrs(&item.attrs); 156 for impl_item in &item.items { 157 self.impl_item(impl_item); 158 } 159 self.offset(-INDENT); 160 self.end(); 161 self.word("}"); 162 self.hardbreak(); 163 } 164 item_macro(&mut self, item: &ItemMacro)165 fn item_macro(&mut self, item: &ItemMacro) { 166 self.outer_attrs(&item.attrs); 167 let semicolon = true; 168 self.mac(&item.mac, item.ident.as_ref(), semicolon); 169 self.hardbreak(); 170 } 171 item_mod(&mut self, item: &ItemMod)172 fn item_mod(&mut self, item: &ItemMod) { 173 self.outer_attrs(&item.attrs); 174 self.cbox(INDENT); 175 self.visibility(&item.vis); 176 if item.unsafety.is_some() { 177 self.word("unsafe "); 178 } 179 self.word("mod "); 180 self.ident(&item.ident); 181 if let Some((_brace, items)) = &item.content { 182 self.word(" {"); 183 self.hardbreak_if_nonempty(); 184 self.inner_attrs(&item.attrs); 185 for item in items { 186 self.item(item); 187 } 188 self.offset(-INDENT); 189 self.end(); 190 self.word("}"); 191 } else { 192 self.word(";"); 193 self.end(); 194 } 195 self.hardbreak(); 196 } 197 item_static(&mut self, item: &ItemStatic)198 fn item_static(&mut self, item: &ItemStatic) { 199 self.outer_attrs(&item.attrs); 200 self.cbox(0); 201 self.visibility(&item.vis); 202 self.word("static "); 203 self.static_mutability(&item.mutability); 204 self.ident(&item.ident); 205 self.word(": "); 206 self.ty(&item.ty); 207 self.word(" = "); 208 self.neverbreak(); 209 self.expr(&item.expr); 210 self.word(";"); 211 self.end(); 212 self.hardbreak(); 213 } 214 item_struct(&mut self, item: &ItemStruct)215 fn item_struct(&mut self, item: &ItemStruct) { 216 self.outer_attrs(&item.attrs); 217 self.cbox(INDENT); 218 self.visibility(&item.vis); 219 self.word("struct "); 220 self.ident(&item.ident); 221 self.generics(&item.generics); 222 match &item.fields { 223 Fields::Named(fields) => { 224 self.where_clause_for_body(&item.generics.where_clause); 225 self.word("{"); 226 self.hardbreak_if_nonempty(); 227 for field in &fields.named { 228 self.field(field); 229 self.word(","); 230 self.hardbreak(); 231 } 232 self.offset(-INDENT); 233 self.end(); 234 self.word("}"); 235 } 236 Fields::Unnamed(fields) => { 237 self.fields_unnamed(fields); 238 self.where_clause_semi(&item.generics.where_clause); 239 self.end(); 240 } 241 Fields::Unit => { 242 self.where_clause_semi(&item.generics.where_clause); 243 self.end(); 244 } 245 } 246 self.hardbreak(); 247 } 248 item_trait(&mut self, item: &ItemTrait)249 fn item_trait(&mut self, item: &ItemTrait) { 250 self.outer_attrs(&item.attrs); 251 self.cbox(INDENT); 252 self.visibility(&item.vis); 253 if item.unsafety.is_some() { 254 self.word("unsafe "); 255 } 256 if item.auto_token.is_some() { 257 self.word("auto "); 258 } 259 self.word("trait "); 260 self.ident(&item.ident); 261 self.generics(&item.generics); 262 for supertrait in item.supertraits.iter().delimited() { 263 if supertrait.is_first { 264 self.word(": "); 265 } else { 266 self.word(" + "); 267 } 268 self.type_param_bound(&supertrait); 269 } 270 self.where_clause_for_body(&item.generics.where_clause); 271 self.word("{"); 272 self.hardbreak_if_nonempty(); 273 self.inner_attrs(&item.attrs); 274 for trait_item in &item.items { 275 self.trait_item(trait_item); 276 } 277 self.offset(-INDENT); 278 self.end(); 279 self.word("}"); 280 self.hardbreak(); 281 } 282 item_trait_alias(&mut self, item: &ItemTraitAlias)283 fn item_trait_alias(&mut self, item: &ItemTraitAlias) { 284 self.outer_attrs(&item.attrs); 285 self.cbox(INDENT); 286 self.visibility(&item.vis); 287 self.word("trait "); 288 self.ident(&item.ident); 289 self.generics(&item.generics); 290 self.word(" = "); 291 self.neverbreak(); 292 for bound in item.bounds.iter().delimited() { 293 if !bound.is_first { 294 self.space(); 295 self.word("+ "); 296 } 297 self.type_param_bound(&bound); 298 } 299 self.where_clause_semi(&item.generics.where_clause); 300 self.end(); 301 self.hardbreak(); 302 } 303 item_type(&mut self, item: &ItemType)304 fn item_type(&mut self, item: &ItemType) { 305 self.outer_attrs(&item.attrs); 306 self.cbox(INDENT); 307 self.visibility(&item.vis); 308 self.word("type "); 309 self.ident(&item.ident); 310 self.generics(&item.generics); 311 self.where_clause_oneline(&item.generics.where_clause); 312 self.word("= "); 313 self.neverbreak(); 314 self.ibox(-INDENT); 315 self.ty(&item.ty); 316 self.end(); 317 self.word(";"); 318 self.end(); 319 self.hardbreak(); 320 } 321 item_union(&mut self, item: &ItemUnion)322 fn item_union(&mut self, item: &ItemUnion) { 323 self.outer_attrs(&item.attrs); 324 self.cbox(INDENT); 325 self.visibility(&item.vis); 326 self.word("union "); 327 self.ident(&item.ident); 328 self.generics(&item.generics); 329 self.where_clause_for_body(&item.generics.where_clause); 330 self.word("{"); 331 self.hardbreak_if_nonempty(); 332 for field in &item.fields.named { 333 self.field(field); 334 self.word(","); 335 self.hardbreak(); 336 } 337 self.offset(-INDENT); 338 self.end(); 339 self.word("}"); 340 self.hardbreak(); 341 } 342 item_use(&mut self, item: &ItemUse)343 fn item_use(&mut self, item: &ItemUse) { 344 self.outer_attrs(&item.attrs); 345 self.visibility(&item.vis); 346 self.word("use "); 347 if item.leading_colon.is_some() { 348 self.word("::"); 349 } 350 self.use_tree(&item.tree); 351 self.word(";"); 352 self.hardbreak(); 353 } 354 355 #[cfg(not(feature = "verbatim"))] item_verbatim(&mut self, item: &TokenStream)356 fn item_verbatim(&mut self, item: &TokenStream) { 357 if !item.is_empty() { 358 unimplemented!("Item::Verbatim `{}`", item); 359 } 360 self.hardbreak(); 361 } 362 363 #[cfg(feature = "verbatim")] item_verbatim(&mut self, tokens: &TokenStream)364 fn item_verbatim(&mut self, tokens: &TokenStream) { 365 use syn::parse::{Parse, ParseStream, Result}; 366 use syn::punctuated::Punctuated; 367 use syn::{ 368 braced, parenthesized, token, Attribute, Generics, Ident, Lifetime, Token, Visibility, 369 }; 370 use verbatim::{ 371 FlexibleItemConst, FlexibleItemFn, FlexibleItemStatic, FlexibleItemType, 372 WhereClauseLocation, 373 }; 374 375 enum ItemVerbatim { 376 Empty, 377 Ellipsis, 378 ConstFlexible(FlexibleItemConst), 379 FnFlexible(FlexibleItemFn), 380 ImplFlexible(ImplFlexible), 381 Macro2(Macro2), 382 StaticFlexible(FlexibleItemStatic), 383 TypeFlexible(FlexibleItemType), 384 UseBrace(UseBrace), 385 } 386 387 struct ImplFlexible { 388 attrs: Vec<Attribute>, 389 vis: Visibility, 390 defaultness: bool, 391 unsafety: bool, 392 generics: Generics, 393 constness: ImplConstness, 394 negative_impl: bool, 395 trait_: Option<Type>, 396 self_ty: Type, 397 items: Vec<ImplItem>, 398 } 399 400 enum ImplConstness { 401 None, 402 MaybeConst, 403 Const, 404 } 405 406 struct Macro2 { 407 attrs: Vec<Attribute>, 408 vis: Visibility, 409 ident: Ident, 410 args: Option<TokenStream>, 411 body: TokenStream, 412 } 413 414 struct UseBrace { 415 attrs: Vec<Attribute>, 416 vis: Visibility, 417 trees: Punctuated<RootUseTree, Token![,]>, 418 } 419 420 struct RootUseTree { 421 leading_colon: Option<Token![::]>, 422 inner: UseTree, 423 } 424 425 impl Parse for ImplConstness { 426 fn parse(input: ParseStream) -> Result<Self> { 427 if input.parse::<Option<Token![?]>>()?.is_some() { 428 input.parse::<Token![const]>()?; 429 Ok(ImplConstness::MaybeConst) 430 } else if input.parse::<Option<Token![const]>>()?.is_some() { 431 Ok(ImplConstness::Const) 432 } else { 433 Ok(ImplConstness::None) 434 } 435 } 436 } 437 438 impl Parse for RootUseTree { 439 fn parse(input: ParseStream) -> Result<Self> { 440 Ok(RootUseTree { 441 leading_colon: input.parse()?, 442 inner: input.parse()?, 443 }) 444 } 445 } 446 447 impl Parse for ItemVerbatim { 448 fn parse(input: ParseStream) -> Result<Self> { 449 if input.is_empty() { 450 return Ok(ItemVerbatim::Empty); 451 } else if input.peek(Token![...]) { 452 input.parse::<Token![...]>()?; 453 return Ok(ItemVerbatim::Ellipsis); 454 } 455 456 let mut attrs = input.call(Attribute::parse_outer)?; 457 let vis: Visibility = input.parse()?; 458 459 let lookahead = input.lookahead1(); 460 if lookahead.peek(Token![const]) && (input.peek2(Ident) || input.peek2(Token![_])) { 461 let defaultness = false; 462 let flexible_item = FlexibleItemConst::parse(attrs, vis, defaultness, input)?; 463 Ok(ItemVerbatim::ConstFlexible(flexible_item)) 464 } else if input.peek(Token![const]) 465 || lookahead.peek(Token![async]) 466 || lookahead.peek(Token![unsafe]) && !input.peek2(Token![impl]) 467 || lookahead.peek(Token![extern]) 468 || lookahead.peek(Token![fn]) 469 { 470 let defaultness = false; 471 let flexible_item = FlexibleItemFn::parse(attrs, vis, defaultness, input)?; 472 Ok(ItemVerbatim::FnFlexible(flexible_item)) 473 } else if lookahead.peek(Token![default]) 474 || input.peek(Token![unsafe]) 475 || lookahead.peek(Token![impl]) 476 { 477 let defaultness = input.parse::<Option<Token![default]>>()?.is_some(); 478 let unsafety = input.parse::<Option<Token![unsafe]>>()?.is_some(); 479 input.parse::<Token![impl]>()?; 480 let has_generics = input.peek(Token![<]) 481 && (input.peek2(Token![>]) 482 || input.peek2(Token![#]) 483 || (input.peek2(Ident) || input.peek2(Lifetime)) 484 && (input.peek3(Token![:]) 485 || input.peek3(Token![,]) 486 || input.peek3(Token![>]) 487 || input.peek3(Token![=])) 488 || input.peek2(Token![const])); 489 let mut generics: Generics = if has_generics { 490 input.parse()? 491 } else { 492 Generics::default() 493 }; 494 let constness: ImplConstness = input.parse()?; 495 let negative_impl = 496 !input.peek2(token::Brace) && input.parse::<Option<Token![!]>>()?.is_some(); 497 let first_ty: Type = input.parse()?; 498 let (trait_, self_ty) = if input.parse::<Option<Token![for]>>()?.is_some() { 499 (Some(first_ty), input.parse()?) 500 } else { 501 (None, first_ty) 502 }; 503 generics.where_clause = input.parse()?; 504 let content; 505 braced!(content in input); 506 let inner_attrs = content.call(Attribute::parse_inner)?; 507 attrs.extend(inner_attrs); 508 let mut items = Vec::new(); 509 while !content.is_empty() { 510 items.push(content.parse()?); 511 } 512 Ok(ItemVerbatim::ImplFlexible(ImplFlexible { 513 attrs, 514 vis, 515 defaultness, 516 unsafety, 517 generics, 518 constness, 519 negative_impl, 520 trait_, 521 self_ty, 522 items, 523 })) 524 } else if lookahead.peek(Token![macro]) { 525 input.parse::<Token![macro]>()?; 526 let ident: Ident = input.parse()?; 527 let args = if input.peek(token::Paren) { 528 let paren_content; 529 parenthesized!(paren_content in input); 530 Some(paren_content.parse::<TokenStream>()?) 531 } else { 532 None 533 }; 534 let brace_content; 535 braced!(brace_content in input); 536 let body: TokenStream = brace_content.parse()?; 537 Ok(ItemVerbatim::Macro2(Macro2 { 538 attrs, 539 vis, 540 ident, 541 args, 542 body, 543 })) 544 } else if lookahead.peek(Token![static]) { 545 let flexible_item = FlexibleItemStatic::parse(attrs, vis, input)?; 546 Ok(ItemVerbatim::StaticFlexible(flexible_item)) 547 } else if lookahead.peek(Token![type]) { 548 let defaultness = false; 549 let flexible_item = FlexibleItemType::parse( 550 attrs, 551 vis, 552 defaultness, 553 input, 554 WhereClauseLocation::BeforeEq, 555 )?; 556 Ok(ItemVerbatim::TypeFlexible(flexible_item)) 557 } else if lookahead.peek(Token![use]) { 558 input.parse::<Token![use]>()?; 559 let content; 560 braced!(content in input); 561 let trees = content.parse_terminated(RootUseTree::parse, Token![,])?; 562 input.parse::<Token![;]>()?; 563 Ok(ItemVerbatim::UseBrace(UseBrace { attrs, vis, trees })) 564 } else { 565 Err(lookahead.error()) 566 } 567 } 568 } 569 570 let item: ItemVerbatim = match syn::parse2(tokens.clone()) { 571 Ok(item) => item, 572 Err(_) => unimplemented!("Item::Verbatim `{}`", tokens), 573 }; 574 575 match item { 576 ItemVerbatim::Empty => { 577 self.hardbreak(); 578 } 579 ItemVerbatim::Ellipsis => { 580 self.word("..."); 581 self.hardbreak(); 582 } 583 ItemVerbatim::ConstFlexible(item) => { 584 self.flexible_item_const(&item); 585 } 586 ItemVerbatim::FnFlexible(item) => { 587 self.flexible_item_fn(&item); 588 } 589 ItemVerbatim::ImplFlexible(item) => { 590 self.outer_attrs(&item.attrs); 591 self.cbox(INDENT); 592 self.ibox(-INDENT); 593 self.cbox(INDENT); 594 self.visibility(&item.vis); 595 if item.defaultness { 596 self.word("default "); 597 } 598 if item.unsafety { 599 self.word("unsafe "); 600 } 601 self.word("impl"); 602 self.generics(&item.generics); 603 self.end(); 604 self.nbsp(); 605 match item.constness { 606 ImplConstness::None => {} 607 ImplConstness::MaybeConst => self.word("?const "), 608 ImplConstness::Const => self.word("const "), 609 } 610 if item.negative_impl { 611 self.word("!"); 612 } 613 if let Some(trait_) = &item.trait_ { 614 self.ty(trait_); 615 self.space(); 616 self.word("for "); 617 } 618 self.ty(&item.self_ty); 619 self.end(); 620 self.where_clause_for_body(&item.generics.where_clause); 621 self.word("{"); 622 self.hardbreak_if_nonempty(); 623 self.inner_attrs(&item.attrs); 624 for impl_item in &item.items { 625 self.impl_item(impl_item); 626 } 627 self.offset(-INDENT); 628 self.end(); 629 self.word("}"); 630 self.hardbreak(); 631 } 632 ItemVerbatim::Macro2(item) => { 633 self.outer_attrs(&item.attrs); 634 self.visibility(&item.vis); 635 self.word("macro "); 636 self.ident(&item.ident); 637 if let Some(args) = &item.args { 638 self.word("("); 639 self.cbox(INDENT); 640 self.zerobreak(); 641 self.ibox(0); 642 self.macro_rules_tokens(args.clone(), true); 643 self.end(); 644 self.zerobreak(); 645 self.offset(-INDENT); 646 self.end(); 647 self.word(")"); 648 } 649 self.word(" {"); 650 if !item.body.is_empty() { 651 self.neverbreak(); 652 self.cbox(INDENT); 653 self.hardbreak(); 654 self.ibox(0); 655 self.macro_rules_tokens(item.body.clone(), false); 656 self.end(); 657 self.hardbreak(); 658 self.offset(-INDENT); 659 self.end(); 660 } 661 self.word("}"); 662 self.hardbreak(); 663 } 664 ItemVerbatim::StaticFlexible(item) => { 665 self.flexible_item_static(&item); 666 } 667 ItemVerbatim::TypeFlexible(item) => { 668 self.flexible_item_type(&item); 669 } 670 ItemVerbatim::UseBrace(item) => { 671 self.outer_attrs(&item.attrs); 672 self.visibility(&item.vis); 673 self.word("use "); 674 if item.trees.len() == 1 { 675 self.word("::"); 676 self.use_tree(&item.trees[0].inner); 677 } else { 678 self.cbox(INDENT); 679 self.word("{"); 680 self.zerobreak(); 681 self.ibox(0); 682 for use_tree in item.trees.iter().delimited() { 683 if use_tree.leading_colon.is_some() { 684 self.word("::"); 685 } 686 self.use_tree(&use_tree.inner); 687 if !use_tree.is_last { 688 self.word(","); 689 let mut use_tree = &use_tree.inner; 690 while let UseTree::Path(use_path) = use_tree { 691 use_tree = &use_path.tree; 692 } 693 if let UseTree::Group(_) = use_tree { 694 self.hardbreak(); 695 } else { 696 self.space(); 697 } 698 } 699 } 700 self.end(); 701 self.trailing_comma(true); 702 self.offset(-INDENT); 703 self.word("}"); 704 self.end(); 705 } 706 self.word(";"); 707 self.hardbreak(); 708 } 709 } 710 } 711 use_tree(&mut self, use_tree: &UseTree)712 fn use_tree(&mut self, use_tree: &UseTree) { 713 match use_tree { 714 UseTree::Path(use_path) => self.use_path(use_path), 715 UseTree::Name(use_name) => self.use_name(use_name), 716 UseTree::Rename(use_rename) => self.use_rename(use_rename), 717 UseTree::Glob(use_glob) => self.use_glob(use_glob), 718 UseTree::Group(use_group) => self.use_group(use_group), 719 } 720 } 721 use_path(&mut self, use_path: &UsePath)722 fn use_path(&mut self, use_path: &UsePath) { 723 self.ident(&use_path.ident); 724 self.word("::"); 725 self.use_tree(&use_path.tree); 726 } 727 use_name(&mut self, use_name: &UseName)728 fn use_name(&mut self, use_name: &UseName) { 729 self.ident(&use_name.ident); 730 } 731 use_rename(&mut self, use_rename: &UseRename)732 fn use_rename(&mut self, use_rename: &UseRename) { 733 self.ident(&use_rename.ident); 734 self.word(" as "); 735 self.ident(&use_rename.rename); 736 } 737 use_glob(&mut self, use_glob: &UseGlob)738 fn use_glob(&mut self, use_glob: &UseGlob) { 739 let _ = use_glob; 740 self.word("*"); 741 } 742 use_group(&mut self, use_group: &UseGroup)743 fn use_group(&mut self, use_group: &UseGroup) { 744 if use_group.items.is_empty() { 745 self.word("{}"); 746 } else if use_group.items.len() == 1 747 && match &use_group.items[0] { 748 UseTree::Rename(use_rename) => use_rename.ident != "self", 749 _ => true, 750 } 751 { 752 self.use_tree(&use_group.items[0]); 753 } else { 754 self.cbox(INDENT); 755 self.word("{"); 756 self.zerobreak(); 757 self.ibox(0); 758 for use_tree in use_group.items.iter().delimited() { 759 self.use_tree(&use_tree); 760 if !use_tree.is_last { 761 self.word(","); 762 let mut use_tree = *use_tree; 763 while let UseTree::Path(use_path) = use_tree { 764 use_tree = &use_path.tree; 765 } 766 if let UseTree::Group(_) = use_tree { 767 self.hardbreak(); 768 } else { 769 self.space(); 770 } 771 } 772 } 773 self.end(); 774 self.trailing_comma(true); 775 self.offset(-INDENT); 776 self.word("}"); 777 self.end(); 778 } 779 } 780 foreign_item(&mut self, foreign_item: &ForeignItem)781 fn foreign_item(&mut self, foreign_item: &ForeignItem) { 782 match foreign_item { 783 #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))] 784 ForeignItem::Fn(item) => self.foreign_item_fn(item), 785 ForeignItem::Static(item) => self.foreign_item_static(item), 786 ForeignItem::Type(item) => self.foreign_item_type(item), 787 ForeignItem::Macro(item) => self.foreign_item_macro(item), 788 ForeignItem::Verbatim(item) => self.foreign_item_verbatim(item), 789 _ => unimplemented!("unknown ForeignItem"), 790 } 791 } 792 foreign_item_fn(&mut self, foreign_item: &ForeignItemFn)793 fn foreign_item_fn(&mut self, foreign_item: &ForeignItemFn) { 794 self.outer_attrs(&foreign_item.attrs); 795 self.cbox(INDENT); 796 self.visibility(&foreign_item.vis); 797 self.signature(&foreign_item.sig); 798 self.where_clause_semi(&foreign_item.sig.generics.where_clause); 799 self.end(); 800 self.hardbreak(); 801 } 802 foreign_item_static(&mut self, foreign_item: &ForeignItemStatic)803 fn foreign_item_static(&mut self, foreign_item: &ForeignItemStatic) { 804 self.outer_attrs(&foreign_item.attrs); 805 self.cbox(0); 806 self.visibility(&foreign_item.vis); 807 self.word("static "); 808 self.static_mutability(&foreign_item.mutability); 809 self.ident(&foreign_item.ident); 810 self.word(": "); 811 self.ty(&foreign_item.ty); 812 self.word(";"); 813 self.end(); 814 self.hardbreak(); 815 } 816 foreign_item_type(&mut self, foreign_item: &ForeignItemType)817 fn foreign_item_type(&mut self, foreign_item: &ForeignItemType) { 818 self.outer_attrs(&foreign_item.attrs); 819 self.cbox(0); 820 self.visibility(&foreign_item.vis); 821 self.word("type "); 822 self.ident(&foreign_item.ident); 823 self.generics(&foreign_item.generics); 824 self.word(";"); 825 self.end(); 826 self.hardbreak(); 827 } 828 foreign_item_macro(&mut self, foreign_item: &ForeignItemMacro)829 fn foreign_item_macro(&mut self, foreign_item: &ForeignItemMacro) { 830 self.outer_attrs(&foreign_item.attrs); 831 let semicolon = true; 832 self.mac(&foreign_item.mac, None, semicolon); 833 self.hardbreak(); 834 } 835 836 #[cfg(not(feature = "verbatim"))] foreign_item_verbatim(&mut self, foreign_item: &TokenStream)837 fn foreign_item_verbatim(&mut self, foreign_item: &TokenStream) { 838 if !foreign_item.is_empty() { 839 unimplemented!("ForeignItem::Verbatim `{}`", foreign_item); 840 } 841 self.hardbreak(); 842 } 843 844 #[cfg(feature = "verbatim")] foreign_item_verbatim(&mut self, tokens: &TokenStream)845 fn foreign_item_verbatim(&mut self, tokens: &TokenStream) { 846 use syn::parse::{Parse, ParseStream, Result}; 847 use syn::{Attribute, Token, Visibility}; 848 use verbatim::{FlexibleItemFn, FlexibleItemStatic, FlexibleItemType, WhereClauseLocation}; 849 850 enum ForeignItemVerbatim { 851 Empty, 852 Ellipsis, 853 FnFlexible(FlexibleItemFn), 854 StaticFlexible(FlexibleItemStatic), 855 TypeFlexible(FlexibleItemType), 856 } 857 858 impl Parse for ForeignItemVerbatim { 859 fn parse(input: ParseStream) -> Result<Self> { 860 if input.is_empty() { 861 return Ok(ForeignItemVerbatim::Empty); 862 } else if input.peek(Token![...]) { 863 input.parse::<Token![...]>()?; 864 return Ok(ForeignItemVerbatim::Ellipsis); 865 } 866 867 let attrs = input.call(Attribute::parse_outer)?; 868 let vis: Visibility = input.parse()?; 869 let defaultness = false; 870 871 let lookahead = input.lookahead1(); 872 if lookahead.peek(Token![const]) 873 || lookahead.peek(Token![async]) 874 || lookahead.peek(Token![unsafe]) 875 || lookahead.peek(Token![extern]) 876 || lookahead.peek(Token![fn]) 877 { 878 let flexible_item = FlexibleItemFn::parse(attrs, vis, defaultness, input)?; 879 Ok(ForeignItemVerbatim::FnFlexible(flexible_item)) 880 } else if lookahead.peek(Token![static]) { 881 let flexible_item = FlexibleItemStatic::parse(attrs, vis, input)?; 882 Ok(ForeignItemVerbatim::StaticFlexible(flexible_item)) 883 } else if lookahead.peek(Token![type]) { 884 let flexible_item = FlexibleItemType::parse( 885 attrs, 886 vis, 887 defaultness, 888 input, 889 WhereClauseLocation::Both, 890 )?; 891 Ok(ForeignItemVerbatim::TypeFlexible(flexible_item)) 892 } else { 893 Err(lookahead.error()) 894 } 895 } 896 } 897 898 let foreign_item: ForeignItemVerbatim = match syn::parse2(tokens.clone()) { 899 Ok(foreign_item) => foreign_item, 900 Err(_) => unimplemented!("ForeignItem::Verbatim `{}`", tokens), 901 }; 902 903 match foreign_item { 904 ForeignItemVerbatim::Empty => { 905 self.hardbreak(); 906 } 907 ForeignItemVerbatim::Ellipsis => { 908 self.word("..."); 909 self.hardbreak(); 910 } 911 ForeignItemVerbatim::FnFlexible(foreign_item) => { 912 self.flexible_item_fn(&foreign_item); 913 } 914 ForeignItemVerbatim::StaticFlexible(foreign_item) => { 915 self.flexible_item_static(&foreign_item); 916 } 917 ForeignItemVerbatim::TypeFlexible(foreign_item) => { 918 self.flexible_item_type(&foreign_item); 919 } 920 } 921 } 922 trait_item(&mut self, trait_item: &TraitItem)923 fn trait_item(&mut self, trait_item: &TraitItem) { 924 match trait_item { 925 #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))] 926 TraitItem::Const(item) => self.trait_item_const(item), 927 TraitItem::Fn(item) => self.trait_item_fn(item), 928 TraitItem::Type(item) => self.trait_item_type(item), 929 TraitItem::Macro(item) => self.trait_item_macro(item), 930 TraitItem::Verbatim(item) => self.trait_item_verbatim(item), 931 _ => unimplemented!("unknown TraitItem"), 932 } 933 } 934 trait_item_const(&mut self, trait_item: &TraitItemConst)935 fn trait_item_const(&mut self, trait_item: &TraitItemConst) { 936 self.outer_attrs(&trait_item.attrs); 937 self.cbox(0); 938 self.word("const "); 939 self.ident(&trait_item.ident); 940 self.generics(&trait_item.generics); 941 self.word(": "); 942 self.ty(&trait_item.ty); 943 if let Some((_eq_token, default)) = &trait_item.default { 944 self.word(" = "); 945 self.neverbreak(); 946 self.expr(default); 947 } 948 self.word(";"); 949 self.end(); 950 self.hardbreak(); 951 } 952 trait_item_fn(&mut self, trait_item: &TraitItemFn)953 fn trait_item_fn(&mut self, trait_item: &TraitItemFn) { 954 self.outer_attrs(&trait_item.attrs); 955 self.cbox(INDENT); 956 self.signature(&trait_item.sig); 957 if let Some(block) = &trait_item.default { 958 self.where_clause_for_body(&trait_item.sig.generics.where_clause); 959 self.word("{"); 960 self.hardbreak_if_nonempty(); 961 self.inner_attrs(&trait_item.attrs); 962 for stmt in &block.stmts { 963 self.stmt(stmt); 964 } 965 self.offset(-INDENT); 966 self.end(); 967 self.word("}"); 968 } else { 969 self.where_clause_semi(&trait_item.sig.generics.where_clause); 970 self.end(); 971 } 972 self.hardbreak(); 973 } 974 trait_item_type(&mut self, trait_item: &TraitItemType)975 fn trait_item_type(&mut self, trait_item: &TraitItemType) { 976 self.outer_attrs(&trait_item.attrs); 977 self.cbox(INDENT); 978 self.word("type "); 979 self.ident(&trait_item.ident); 980 self.generics(&trait_item.generics); 981 for bound in trait_item.bounds.iter().delimited() { 982 if bound.is_first { 983 self.word(": "); 984 } else { 985 self.space(); 986 self.word("+ "); 987 } 988 self.type_param_bound(&bound); 989 } 990 if let Some((_eq_token, default)) = &trait_item.default { 991 self.word(" = "); 992 self.neverbreak(); 993 self.ibox(-INDENT); 994 self.ty(default); 995 self.end(); 996 } 997 self.where_clause_oneline_semi(&trait_item.generics.where_clause); 998 self.end(); 999 self.hardbreak(); 1000 } 1001 trait_item_macro(&mut self, trait_item: &TraitItemMacro)1002 fn trait_item_macro(&mut self, trait_item: &TraitItemMacro) { 1003 self.outer_attrs(&trait_item.attrs); 1004 let semicolon = true; 1005 self.mac(&trait_item.mac, None, semicolon); 1006 self.hardbreak(); 1007 } 1008 1009 #[cfg(not(feature = "verbatim"))] trait_item_verbatim(&mut self, trait_item: &TokenStream)1010 fn trait_item_verbatim(&mut self, trait_item: &TokenStream) { 1011 if !trait_item.is_empty() { 1012 unimplemented!("TraitItem::Verbatim `{}`", trait_item); 1013 } 1014 self.hardbreak(); 1015 } 1016 1017 #[cfg(feature = "verbatim")] trait_item_verbatim(&mut self, tokens: &TokenStream)1018 fn trait_item_verbatim(&mut self, tokens: &TokenStream) { 1019 use syn::parse::{Parse, ParseStream, Result}; 1020 use syn::{Attribute, Ident, Token, Visibility}; 1021 use verbatim::{FlexibleItemConst, FlexibleItemType, WhereClauseLocation}; 1022 1023 enum TraitItemVerbatim { 1024 Empty, 1025 Ellipsis, 1026 ConstFlexible(FlexibleItemConst), 1027 TypeFlexible(FlexibleItemType), 1028 PubOrDefault(PubOrDefaultTraitItem), 1029 } 1030 1031 struct PubOrDefaultTraitItem { 1032 attrs: Vec<Attribute>, 1033 vis: Visibility, 1034 defaultness: bool, 1035 trait_item: TraitItem, 1036 } 1037 1038 impl Parse for TraitItemVerbatim { 1039 fn parse(input: ParseStream) -> Result<Self> { 1040 if input.is_empty() { 1041 return Ok(TraitItemVerbatim::Empty); 1042 } else if input.peek(Token![...]) { 1043 input.parse::<Token![...]>()?; 1044 return Ok(TraitItemVerbatim::Ellipsis); 1045 } 1046 1047 let attrs = input.call(Attribute::parse_outer)?; 1048 let vis: Visibility = input.parse()?; 1049 let defaultness = input.parse::<Option<Token![default]>>()?.is_some(); 1050 1051 let lookahead = input.lookahead1(); 1052 if lookahead.peek(Token![const]) && (input.peek2(Ident) || input.peek2(Token![_])) { 1053 let flexible_item = FlexibleItemConst::parse(attrs, vis, defaultness, input)?; 1054 Ok(TraitItemVerbatim::ConstFlexible(flexible_item)) 1055 } else if lookahead.peek(Token![type]) { 1056 let flexible_item = FlexibleItemType::parse( 1057 attrs, 1058 vis, 1059 defaultness, 1060 input, 1061 WhereClauseLocation::AfterEq, 1062 )?; 1063 Ok(TraitItemVerbatim::TypeFlexible(flexible_item)) 1064 } else if (input.peek(Token![const]) 1065 || lookahead.peek(Token![async]) 1066 || lookahead.peek(Token![unsafe]) 1067 || lookahead.peek(Token![extern]) 1068 || lookahead.peek(Token![fn])) 1069 && (!matches!(vis, Visibility::Inherited) || defaultness) 1070 { 1071 Ok(TraitItemVerbatim::PubOrDefault(PubOrDefaultTraitItem { 1072 attrs, 1073 vis, 1074 defaultness, 1075 trait_item: input.parse()?, 1076 })) 1077 } else { 1078 Err(lookahead.error()) 1079 } 1080 } 1081 } 1082 1083 let impl_item: TraitItemVerbatim = match syn::parse2(tokens.clone()) { 1084 Ok(impl_item) => impl_item, 1085 Err(_) => unimplemented!("TraitItem::Verbatim `{}`", tokens), 1086 }; 1087 1088 match impl_item { 1089 TraitItemVerbatim::Empty => { 1090 self.hardbreak(); 1091 } 1092 TraitItemVerbatim::Ellipsis => { 1093 self.word("..."); 1094 self.hardbreak(); 1095 } 1096 TraitItemVerbatim::ConstFlexible(trait_item) => { 1097 self.flexible_item_const(&trait_item); 1098 } 1099 TraitItemVerbatim::TypeFlexible(trait_item) => { 1100 self.flexible_item_type(&trait_item); 1101 } 1102 TraitItemVerbatim::PubOrDefault(trait_item) => { 1103 self.outer_attrs(&trait_item.attrs); 1104 self.visibility(&trait_item.vis); 1105 if trait_item.defaultness { 1106 self.word("default "); 1107 } 1108 self.trait_item(&trait_item.trait_item); 1109 } 1110 } 1111 } 1112 impl_item(&mut self, impl_item: &ImplItem)1113 fn impl_item(&mut self, impl_item: &ImplItem) { 1114 match impl_item { 1115 #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))] 1116 ImplItem::Const(item) => self.impl_item_const(item), 1117 ImplItem::Fn(item) => self.impl_item_fn(item), 1118 ImplItem::Type(item) => self.impl_item_type(item), 1119 ImplItem::Macro(item) => self.impl_item_macro(item), 1120 ImplItem::Verbatim(item) => self.impl_item_verbatim(item), 1121 _ => unimplemented!("unknown ImplItem"), 1122 } 1123 } 1124 impl_item_const(&mut self, impl_item: &ImplItemConst)1125 fn impl_item_const(&mut self, impl_item: &ImplItemConst) { 1126 self.outer_attrs(&impl_item.attrs); 1127 self.cbox(0); 1128 self.visibility(&impl_item.vis); 1129 if impl_item.defaultness.is_some() { 1130 self.word("default "); 1131 } 1132 self.word("const "); 1133 self.ident(&impl_item.ident); 1134 self.generics(&impl_item.generics); 1135 self.word(": "); 1136 self.ty(&impl_item.ty); 1137 self.word(" = "); 1138 self.neverbreak(); 1139 self.expr(&impl_item.expr); 1140 self.word(";"); 1141 self.end(); 1142 self.hardbreak(); 1143 } 1144 impl_item_fn(&mut self, impl_item: &ImplItemFn)1145 fn impl_item_fn(&mut self, impl_item: &ImplItemFn) { 1146 self.outer_attrs(&impl_item.attrs); 1147 self.cbox(INDENT); 1148 self.visibility(&impl_item.vis); 1149 if impl_item.defaultness.is_some() { 1150 self.word("default "); 1151 } 1152 self.signature(&impl_item.sig); 1153 self.where_clause_for_body(&impl_item.sig.generics.where_clause); 1154 self.word("{"); 1155 self.hardbreak_if_nonempty(); 1156 self.inner_attrs(&impl_item.attrs); 1157 for stmt in &impl_item.block.stmts { 1158 self.stmt(stmt); 1159 } 1160 self.offset(-INDENT); 1161 self.end(); 1162 self.word("}"); 1163 self.hardbreak(); 1164 } 1165 impl_item_type(&mut self, impl_item: &ImplItemType)1166 fn impl_item_type(&mut self, impl_item: &ImplItemType) { 1167 self.outer_attrs(&impl_item.attrs); 1168 self.cbox(INDENT); 1169 self.visibility(&impl_item.vis); 1170 if impl_item.defaultness.is_some() { 1171 self.word("default "); 1172 } 1173 self.word("type "); 1174 self.ident(&impl_item.ident); 1175 self.generics(&impl_item.generics); 1176 self.word(" = "); 1177 self.neverbreak(); 1178 self.ibox(-INDENT); 1179 self.ty(&impl_item.ty); 1180 self.end(); 1181 self.where_clause_oneline_semi(&impl_item.generics.where_clause); 1182 self.end(); 1183 self.hardbreak(); 1184 } 1185 impl_item_macro(&mut self, impl_item: &ImplItemMacro)1186 fn impl_item_macro(&mut self, impl_item: &ImplItemMacro) { 1187 self.outer_attrs(&impl_item.attrs); 1188 let semicolon = true; 1189 self.mac(&impl_item.mac, None, semicolon); 1190 self.hardbreak(); 1191 } 1192 1193 #[cfg(not(feature = "verbatim"))] impl_item_verbatim(&mut self, impl_item: &TokenStream)1194 fn impl_item_verbatim(&mut self, impl_item: &TokenStream) { 1195 if !impl_item.is_empty() { 1196 unimplemented!("ImplItem::Verbatim `{}`", impl_item); 1197 } 1198 self.hardbreak(); 1199 } 1200 1201 #[cfg(feature = "verbatim")] impl_item_verbatim(&mut self, tokens: &TokenStream)1202 fn impl_item_verbatim(&mut self, tokens: &TokenStream) { 1203 use syn::parse::{Parse, ParseStream, Result}; 1204 use syn::{Attribute, Ident, Token, Visibility}; 1205 use verbatim::{FlexibleItemConst, FlexibleItemFn, FlexibleItemType, WhereClauseLocation}; 1206 1207 enum ImplItemVerbatim { 1208 Empty, 1209 Ellipsis, 1210 ConstFlexible(FlexibleItemConst), 1211 FnFlexible(FlexibleItemFn), 1212 TypeFlexible(FlexibleItemType), 1213 } 1214 1215 impl Parse for ImplItemVerbatim { 1216 fn parse(input: ParseStream) -> Result<Self> { 1217 if input.is_empty() { 1218 return Ok(ImplItemVerbatim::Empty); 1219 } else if input.peek(Token![...]) { 1220 input.parse::<Token![...]>()?; 1221 return Ok(ImplItemVerbatim::Ellipsis); 1222 } 1223 1224 let attrs = input.call(Attribute::parse_outer)?; 1225 let vis: Visibility = input.parse()?; 1226 let defaultness = input.parse::<Option<Token![default]>>()?.is_some(); 1227 1228 let lookahead = input.lookahead1(); 1229 if lookahead.peek(Token![const]) && (input.peek2(Ident) || input.peek2(Token![_])) { 1230 let flexible_item = FlexibleItemConst::parse(attrs, vis, defaultness, input)?; 1231 Ok(ImplItemVerbatim::ConstFlexible(flexible_item)) 1232 } else if input.peek(Token![const]) 1233 || lookahead.peek(Token![async]) 1234 || lookahead.peek(Token![unsafe]) 1235 || lookahead.peek(Token![extern]) 1236 || lookahead.peek(Token![fn]) 1237 { 1238 let flexible_item = FlexibleItemFn::parse(attrs, vis, defaultness, input)?; 1239 Ok(ImplItemVerbatim::FnFlexible(flexible_item)) 1240 } else if lookahead.peek(Token![type]) { 1241 let flexible_item = FlexibleItemType::parse( 1242 attrs, 1243 vis, 1244 defaultness, 1245 input, 1246 WhereClauseLocation::AfterEq, 1247 )?; 1248 Ok(ImplItemVerbatim::TypeFlexible(flexible_item)) 1249 } else { 1250 Err(lookahead.error()) 1251 } 1252 } 1253 } 1254 1255 let impl_item: ImplItemVerbatim = match syn::parse2(tokens.clone()) { 1256 Ok(impl_item) => impl_item, 1257 Err(_) => unimplemented!("ImplItem::Verbatim `{}`", tokens), 1258 }; 1259 1260 match impl_item { 1261 ImplItemVerbatim::Empty => { 1262 self.hardbreak(); 1263 } 1264 ImplItemVerbatim::Ellipsis => { 1265 self.word("..."); 1266 self.hardbreak(); 1267 } 1268 ImplItemVerbatim::ConstFlexible(impl_item) => { 1269 self.flexible_item_const(&impl_item); 1270 } 1271 ImplItemVerbatim::FnFlexible(impl_item) => { 1272 self.flexible_item_fn(&impl_item); 1273 } 1274 ImplItemVerbatim::TypeFlexible(impl_item) => { 1275 self.flexible_item_type(&impl_item); 1276 } 1277 } 1278 } 1279 signature(&mut self, signature: &Signature)1280 fn signature(&mut self, signature: &Signature) { 1281 if signature.constness.is_some() { 1282 self.word("const "); 1283 } 1284 if signature.asyncness.is_some() { 1285 self.word("async "); 1286 } 1287 if signature.unsafety.is_some() { 1288 self.word("unsafe "); 1289 } 1290 if let Some(abi) = &signature.abi { 1291 self.abi(abi); 1292 } 1293 self.word("fn "); 1294 self.ident(&signature.ident); 1295 self.generics(&signature.generics); 1296 self.word("("); 1297 self.neverbreak(); 1298 self.cbox(0); 1299 self.zerobreak(); 1300 for input in signature.inputs.iter().delimited() { 1301 self.fn_arg(&input); 1302 let is_last = input.is_last && signature.variadic.is_none(); 1303 self.trailing_comma(is_last); 1304 } 1305 if let Some(variadic) = &signature.variadic { 1306 self.variadic(variadic); 1307 self.zerobreak(); 1308 } 1309 self.offset(-INDENT); 1310 self.end(); 1311 self.word(")"); 1312 self.cbox(-INDENT); 1313 self.return_type(&signature.output); 1314 self.end(); 1315 } 1316 fn_arg(&mut self, fn_arg: &FnArg)1317 fn fn_arg(&mut self, fn_arg: &FnArg) { 1318 match fn_arg { 1319 FnArg::Receiver(receiver) => self.receiver(receiver), 1320 FnArg::Typed(pat_type) => self.pat_type(pat_type), 1321 } 1322 } 1323 receiver(&mut self, receiver: &Receiver)1324 fn receiver(&mut self, receiver: &Receiver) { 1325 self.outer_attrs(&receiver.attrs); 1326 if let Some((_ampersand, lifetime)) = &receiver.reference { 1327 self.word("&"); 1328 if let Some(lifetime) = lifetime { 1329 self.lifetime(lifetime); 1330 self.nbsp(); 1331 } 1332 } 1333 if receiver.mutability.is_some() { 1334 self.word("mut "); 1335 } 1336 self.word("self"); 1337 if receiver.colon_token.is_some() { 1338 self.word(": "); 1339 self.ty(&receiver.ty); 1340 } else { 1341 let consistent = match (&receiver.reference, &receiver.mutability, &*receiver.ty) { 1342 (Some(_), mutability, Type::Reference(ty)) => { 1343 mutability.is_some() == ty.mutability.is_some() 1344 && match &*ty.elem { 1345 Type::Path(ty) => ty.qself.is_none() && ty.path.is_ident("Self"), 1346 _ => false, 1347 } 1348 } 1349 (None, _, Type::Path(ty)) => ty.qself.is_none() && ty.path.is_ident("Self"), 1350 _ => false, 1351 }; 1352 if !consistent { 1353 self.word(": "); 1354 self.ty(&receiver.ty); 1355 } 1356 } 1357 } 1358 variadic(&mut self, variadic: &Variadic)1359 fn variadic(&mut self, variadic: &Variadic) { 1360 self.outer_attrs(&variadic.attrs); 1361 if let Some((pat, _colon)) = &variadic.pat { 1362 self.pat(pat); 1363 self.word(": "); 1364 } 1365 self.word("..."); 1366 } 1367 static_mutability(&mut self, mutability: &StaticMutability)1368 fn static_mutability(&mut self, mutability: &StaticMutability) { 1369 match mutability { 1370 #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))] 1371 StaticMutability::Mut(_) => self.word("mut "), 1372 StaticMutability::None => {} 1373 _ => unimplemented!("unknown StaticMutability"), 1374 } 1375 } 1376 } 1377 1378 #[cfg(feature = "verbatim")] 1379 mod verbatim { 1380 use crate::algorithm::Printer; 1381 use crate::iter::IterDelimited; 1382 use crate::INDENT; 1383 use syn::ext::IdentExt; 1384 use syn::parse::{ParseStream, Result}; 1385 use syn::{ 1386 braced, token, Attribute, Block, Expr, Generics, Ident, Signature, StaticMutability, Stmt, 1387 Token, Type, TypeParamBound, Visibility, WhereClause, 1388 }; 1389 1390 pub struct FlexibleItemConst { 1391 pub attrs: Vec<Attribute>, 1392 pub vis: Visibility, 1393 pub defaultness: bool, 1394 pub ident: Ident, 1395 pub generics: Generics, 1396 pub ty: Type, 1397 pub value: Option<Expr>, 1398 } 1399 1400 pub struct FlexibleItemFn { 1401 pub attrs: Vec<Attribute>, 1402 pub vis: Visibility, 1403 pub defaultness: bool, 1404 pub sig: Signature, 1405 pub body: Option<Vec<Stmt>>, 1406 } 1407 1408 pub struct FlexibleItemStatic { 1409 pub attrs: Vec<Attribute>, 1410 pub vis: Visibility, 1411 pub mutability: StaticMutability, 1412 pub ident: Ident, 1413 pub ty: Option<Type>, 1414 pub expr: Option<Expr>, 1415 } 1416 1417 pub struct FlexibleItemType { 1418 pub attrs: Vec<Attribute>, 1419 pub vis: Visibility, 1420 pub defaultness: bool, 1421 pub ident: Ident, 1422 pub generics: Generics, 1423 pub bounds: Vec<TypeParamBound>, 1424 pub definition: Option<Type>, 1425 pub where_clause_after_eq: Option<WhereClause>, 1426 } 1427 1428 pub enum WhereClauseLocation { 1429 // type Ty<T> where T: 'static = T; 1430 BeforeEq, 1431 // type Ty<T> = T where T: 'static; 1432 AfterEq, 1433 // TODO: goes away once the migration period on rust-lang/rust#89122 is over 1434 Both, 1435 } 1436 1437 impl FlexibleItemConst { parse( attrs: Vec<Attribute>, vis: Visibility, defaultness: bool, input: ParseStream, ) -> Result<Self>1438 pub fn parse( 1439 attrs: Vec<Attribute>, 1440 vis: Visibility, 1441 defaultness: bool, 1442 input: ParseStream, 1443 ) -> Result<Self> { 1444 input.parse::<Token![const]>()?; 1445 let ident = input.call(Ident::parse_any)?; 1446 let mut generics: Generics = input.parse()?; 1447 input.parse::<Token![:]>()?; 1448 let ty: Type = input.parse()?; 1449 let value = if input.parse::<Option<Token![=]>>()?.is_some() { 1450 let expr: Expr = input.parse()?; 1451 Some(expr) 1452 } else { 1453 None 1454 }; 1455 generics.where_clause = input.parse()?; 1456 input.parse::<Token![;]>()?; 1457 1458 Ok(FlexibleItemConst { 1459 attrs, 1460 vis, 1461 defaultness, 1462 ident, 1463 generics, 1464 ty, 1465 value, 1466 }) 1467 } 1468 } 1469 1470 impl FlexibleItemFn { parse( mut attrs: Vec<Attribute>, vis: Visibility, defaultness: bool, input: ParseStream, ) -> Result<Self>1471 pub fn parse( 1472 mut attrs: Vec<Attribute>, 1473 vis: Visibility, 1474 defaultness: bool, 1475 input: ParseStream, 1476 ) -> Result<Self> { 1477 let sig: Signature = input.parse()?; 1478 1479 let lookahead = input.lookahead1(); 1480 let body = if lookahead.peek(Token![;]) { 1481 input.parse::<Token![;]>()?; 1482 None 1483 } else if lookahead.peek(token::Brace) { 1484 let content; 1485 braced!(content in input); 1486 attrs.extend(content.call(Attribute::parse_inner)?); 1487 Some(content.call(Block::parse_within)?) 1488 } else { 1489 return Err(lookahead.error()); 1490 }; 1491 1492 Ok(FlexibleItemFn { 1493 attrs, 1494 vis, 1495 defaultness, 1496 sig, 1497 body, 1498 }) 1499 } 1500 } 1501 1502 impl FlexibleItemStatic { parse(attrs: Vec<Attribute>, vis: Visibility, input: ParseStream) -> Result<Self>1503 pub fn parse(attrs: Vec<Attribute>, vis: Visibility, input: ParseStream) -> Result<Self> { 1504 input.parse::<Token![static]>()?; 1505 let mutability: StaticMutability = input.parse()?; 1506 let ident = input.parse()?; 1507 1508 let lookahead = input.lookahead1(); 1509 let has_type = lookahead.peek(Token![:]); 1510 let has_expr = lookahead.peek(Token![=]); 1511 if !has_type && !has_expr { 1512 return Err(lookahead.error()); 1513 } 1514 1515 let ty: Option<Type> = if has_type { 1516 input.parse::<Token![:]>()?; 1517 input.parse().map(Some)? 1518 } else { 1519 None 1520 }; 1521 1522 let expr: Option<Expr> = if input.parse::<Option<Token![=]>>()?.is_some() { 1523 input.parse().map(Some)? 1524 } else { 1525 None 1526 }; 1527 1528 input.parse::<Token![;]>()?; 1529 1530 Ok(FlexibleItemStatic { 1531 attrs, 1532 vis, 1533 mutability, 1534 ident, 1535 ty, 1536 expr, 1537 }) 1538 } 1539 } 1540 1541 impl FlexibleItemType { parse( attrs: Vec<Attribute>, vis: Visibility, defaultness: bool, input: ParseStream, where_clause_location: WhereClauseLocation, ) -> Result<Self>1542 pub fn parse( 1543 attrs: Vec<Attribute>, 1544 vis: Visibility, 1545 defaultness: bool, 1546 input: ParseStream, 1547 where_clause_location: WhereClauseLocation, 1548 ) -> Result<Self> { 1549 input.parse::<Token![type]>()?; 1550 let ident: Ident = input.parse()?; 1551 let mut generics: Generics = input.parse()?; 1552 1553 let mut bounds = Vec::new(); 1554 if input.parse::<Option<Token![:]>>()?.is_some() { 1555 loop { 1556 if input.peek(Token![where]) || input.peek(Token![=]) || input.peek(Token![;]) { 1557 break; 1558 } 1559 bounds.push(input.parse::<TypeParamBound>()?); 1560 if input.peek(Token![where]) || input.peek(Token![=]) || input.peek(Token![;]) { 1561 break; 1562 } 1563 input.parse::<Token![+]>()?; 1564 } 1565 } 1566 1567 match where_clause_location { 1568 WhereClauseLocation::BeforeEq | WhereClauseLocation::Both => { 1569 generics.where_clause = input.parse()?; 1570 } 1571 WhereClauseLocation::AfterEq => {} 1572 } 1573 1574 let definition = if input.parse::<Option<Token![=]>>()?.is_some() { 1575 Some(input.parse()?) 1576 } else { 1577 None 1578 }; 1579 1580 let where_clause_after_eq = match where_clause_location { 1581 WhereClauseLocation::AfterEq | WhereClauseLocation::Both 1582 if generics.where_clause.is_none() => 1583 { 1584 input.parse()? 1585 } 1586 _ => None, 1587 }; 1588 1589 input.parse::<Token![;]>()?; 1590 1591 Ok(FlexibleItemType { 1592 attrs, 1593 vis, 1594 defaultness, 1595 ident, 1596 generics, 1597 bounds, 1598 definition, 1599 where_clause_after_eq, 1600 }) 1601 } 1602 } 1603 1604 impl Printer { flexible_item_const(&mut self, item: &FlexibleItemConst)1605 pub fn flexible_item_const(&mut self, item: &FlexibleItemConst) { 1606 self.outer_attrs(&item.attrs); 1607 self.cbox(INDENT); 1608 self.visibility(&item.vis); 1609 if item.defaultness { 1610 self.word("default "); 1611 } 1612 self.word("const "); 1613 self.ident(&item.ident); 1614 self.generics(&item.generics); 1615 self.word(": "); 1616 self.cbox(-INDENT); 1617 self.ty(&item.ty); 1618 self.end(); 1619 if let Some(value) = &item.value { 1620 self.word(" = "); 1621 self.neverbreak(); 1622 self.ibox(-INDENT); 1623 self.expr(value); 1624 self.end(); 1625 } 1626 self.where_clause_oneline_semi(&item.generics.where_clause); 1627 self.end(); 1628 self.hardbreak(); 1629 } 1630 flexible_item_fn(&mut self, item: &FlexibleItemFn)1631 pub fn flexible_item_fn(&mut self, item: &FlexibleItemFn) { 1632 self.outer_attrs(&item.attrs); 1633 self.cbox(INDENT); 1634 self.visibility(&item.vis); 1635 if item.defaultness { 1636 self.word("default "); 1637 } 1638 self.signature(&item.sig); 1639 if let Some(body) = &item.body { 1640 self.where_clause_for_body(&item.sig.generics.where_clause); 1641 self.word("{"); 1642 self.hardbreak_if_nonempty(); 1643 self.inner_attrs(&item.attrs); 1644 for stmt in body { 1645 self.stmt(stmt); 1646 } 1647 self.offset(-INDENT); 1648 self.end(); 1649 self.word("}"); 1650 } else { 1651 self.where_clause_semi(&item.sig.generics.where_clause); 1652 self.end(); 1653 } 1654 self.hardbreak(); 1655 } 1656 flexible_item_static(&mut self, item: &FlexibleItemStatic)1657 pub fn flexible_item_static(&mut self, item: &FlexibleItemStatic) { 1658 self.outer_attrs(&item.attrs); 1659 self.cbox(0); 1660 self.visibility(&item.vis); 1661 self.word("static "); 1662 self.static_mutability(&item.mutability); 1663 self.ident(&item.ident); 1664 if let Some(ty) = &item.ty { 1665 self.word(": "); 1666 self.ty(ty); 1667 } 1668 if let Some(expr) = &item.expr { 1669 self.word(" = "); 1670 self.neverbreak(); 1671 self.expr(expr); 1672 } 1673 self.word(";"); 1674 self.end(); 1675 self.hardbreak(); 1676 } 1677 flexible_item_type(&mut self, item: &FlexibleItemType)1678 pub fn flexible_item_type(&mut self, item: &FlexibleItemType) { 1679 self.outer_attrs(&item.attrs); 1680 self.cbox(INDENT); 1681 self.visibility(&item.vis); 1682 if item.defaultness { 1683 self.word("default "); 1684 } 1685 self.word("type "); 1686 self.ident(&item.ident); 1687 self.generics(&item.generics); 1688 for bound in item.bounds.iter().delimited() { 1689 if bound.is_first { 1690 self.word(": "); 1691 } else { 1692 self.space(); 1693 self.word("+ "); 1694 } 1695 self.type_param_bound(&bound); 1696 } 1697 if let Some(definition) = &item.definition { 1698 self.where_clause_oneline(&item.generics.where_clause); 1699 self.word("= "); 1700 self.neverbreak(); 1701 self.ibox(-INDENT); 1702 self.ty(definition); 1703 self.end(); 1704 self.where_clause_oneline_semi(&item.where_clause_after_eq); 1705 } else { 1706 self.where_clause_oneline_semi(&item.generics.where_clause); 1707 } 1708 self.end(); 1709 self.hardbreak(); 1710 } 1711 } 1712 } 1713