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 Item::Const(item) => self.item_const(item), 19 Item::Enum(item) => self.item_enum(item), 20 Item::ExternCrate(item) => self.item_extern_crate(item), 21 Item::Fn(item) => self.item_fn(item), 22 Item::ForeignMod(item) => self.item_foreign_mod(item), 23 Item::Impl(item) => self.item_impl(item), 24 Item::Macro(item) => self.item_macro(item), 25 Item::Mod(item) => self.item_mod(item), 26 Item::Static(item) => self.item_static(item), 27 Item::Struct(item) => self.item_struct(item), 28 Item::Trait(item) => self.item_trait(item), 29 Item::TraitAlias(item) => self.item_trait_alias(item), 30 Item::Type(item) => self.item_type(item), 31 Item::Union(item) => self.item_union(item), 32 Item::Use(item) => self.item_use(item), 33 Item::Verbatim(item) => self.item_verbatim(item), 34 #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))] 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 ConstFlexible(FlexibleItemConst), 378 FnFlexible(FlexibleItemFn), 379 ImplFlexible(ImplFlexible), 380 Macro2(Macro2), 381 StaticFlexible(FlexibleItemStatic), 382 TypeFlexible(FlexibleItemType), 383 UseBrace(UseBrace), 384 } 385 386 struct ImplFlexible { 387 attrs: Vec<Attribute>, 388 vis: Visibility, 389 defaultness: bool, 390 unsafety: bool, 391 generics: Generics, 392 constness: ImplConstness, 393 negative_impl: bool, 394 trait_: Option<Type>, 395 self_ty: Type, 396 items: Vec<ImplItem>, 397 } 398 399 enum ImplConstness { 400 None, 401 MaybeConst, 402 Const, 403 } 404 405 struct Macro2 { 406 attrs: Vec<Attribute>, 407 vis: Visibility, 408 ident: Ident, 409 args: Option<TokenStream>, 410 body: TokenStream, 411 } 412 413 struct UseBrace { 414 attrs: Vec<Attribute>, 415 vis: Visibility, 416 trees: Punctuated<RootUseTree, Token![,]>, 417 } 418 419 struct RootUseTree { 420 leading_colon: Option<Token![::]>, 421 inner: UseTree, 422 } 423 424 impl Parse for ImplConstness { 425 fn parse(input: ParseStream) -> Result<Self> { 426 if input.parse::<Option<Token![?]>>()?.is_some() { 427 input.parse::<Token![const]>()?; 428 Ok(ImplConstness::MaybeConst) 429 } else if input.parse::<Option<Token![const]>>()?.is_some() { 430 Ok(ImplConstness::Const) 431 } else { 432 Ok(ImplConstness::None) 433 } 434 } 435 } 436 437 impl Parse for RootUseTree { 438 fn parse(input: ParseStream) -> Result<Self> { 439 Ok(RootUseTree { 440 leading_colon: input.parse()?, 441 inner: input.parse()?, 442 }) 443 } 444 } 445 446 impl Parse for ItemVerbatim { 447 fn parse(input: ParseStream) -> Result<Self> { 448 if input.is_empty() { 449 return Ok(ItemVerbatim::Empty); 450 } 451 452 let mut attrs = input.call(Attribute::parse_outer)?; 453 let vis: Visibility = input.parse()?; 454 455 let lookahead = input.lookahead1(); 456 if lookahead.peek(Token![const]) && (input.peek2(Ident) || input.peek2(Token![_])) { 457 let defaultness = false; 458 let flexible_item = FlexibleItemConst::parse(attrs, vis, defaultness, input)?; 459 Ok(ItemVerbatim::ConstFlexible(flexible_item)) 460 } else if input.peek(Token![const]) 461 || lookahead.peek(Token![async]) 462 || lookahead.peek(Token![unsafe]) && !input.peek2(Token![impl]) 463 || lookahead.peek(Token![extern]) 464 || lookahead.peek(Token![fn]) 465 { 466 let defaultness = false; 467 let flexible_item = FlexibleItemFn::parse(attrs, vis, defaultness, input)?; 468 Ok(ItemVerbatim::FnFlexible(flexible_item)) 469 } else if lookahead.peek(Token![default]) 470 || input.peek(Token![unsafe]) 471 || lookahead.peek(Token![impl]) 472 { 473 let defaultness = input.parse::<Option<Token![default]>>()?.is_some(); 474 let unsafety = input.parse::<Option<Token![unsafe]>>()?.is_some(); 475 input.parse::<Token![impl]>()?; 476 let has_generics = input.peek(Token![<]) 477 && (input.peek2(Token![>]) 478 || input.peek2(Token![#]) 479 || (input.peek2(Ident) || input.peek2(Lifetime)) 480 && (input.peek3(Token![:]) 481 || input.peek3(Token![,]) 482 || input.peek3(Token![>]) 483 || input.peek3(Token![=])) 484 || input.peek2(Token![const])); 485 let mut generics: Generics = if has_generics { 486 input.parse()? 487 } else { 488 Generics::default() 489 }; 490 let constness: ImplConstness = input.parse()?; 491 let negative_impl = 492 !input.peek2(token::Brace) && input.parse::<Option<Token![!]>>()?.is_some(); 493 let first_ty: Type = input.parse()?; 494 let (trait_, self_ty) = if input.parse::<Option<Token![for]>>()?.is_some() { 495 (Some(first_ty), input.parse()?) 496 } else { 497 (None, first_ty) 498 }; 499 generics.where_clause = input.parse()?; 500 let content; 501 braced!(content in input); 502 let inner_attrs = content.call(Attribute::parse_inner)?; 503 attrs.extend(inner_attrs); 504 let mut items = Vec::new(); 505 while !content.is_empty() { 506 items.push(content.parse()?); 507 } 508 Ok(ItemVerbatim::ImplFlexible(ImplFlexible { 509 attrs, 510 vis, 511 defaultness, 512 unsafety, 513 generics, 514 constness, 515 negative_impl, 516 trait_, 517 self_ty, 518 items, 519 })) 520 } else if lookahead.peek(Token![macro]) { 521 input.parse::<Token![macro]>()?; 522 let ident: Ident = input.parse()?; 523 let args = if input.peek(token::Paren) { 524 let paren_content; 525 parenthesized!(paren_content in input); 526 Some(paren_content.parse::<TokenStream>()?) 527 } else { 528 None 529 }; 530 let brace_content; 531 braced!(brace_content in input); 532 let body: TokenStream = brace_content.parse()?; 533 Ok(ItemVerbatim::Macro2(Macro2 { 534 attrs, 535 vis, 536 ident, 537 args, 538 body, 539 })) 540 } else if lookahead.peek(Token![static]) { 541 let flexible_item = FlexibleItemStatic::parse(attrs, vis, input)?; 542 Ok(ItemVerbatim::StaticFlexible(flexible_item)) 543 } else if lookahead.peek(Token![type]) { 544 let defaultness = false; 545 let flexible_item = FlexibleItemType::parse( 546 attrs, 547 vis, 548 defaultness, 549 input, 550 WhereClauseLocation::BeforeEq, 551 )?; 552 Ok(ItemVerbatim::TypeFlexible(flexible_item)) 553 } else if lookahead.peek(Token![use]) { 554 input.parse::<Token![use]>()?; 555 let content; 556 braced!(content in input); 557 let trees = content.parse_terminated(RootUseTree::parse, Token![,])?; 558 input.parse::<Token![;]>()?; 559 Ok(ItemVerbatim::UseBrace(UseBrace { attrs, vis, trees })) 560 } else { 561 Err(lookahead.error()) 562 } 563 } 564 } 565 566 let item: ItemVerbatim = match syn::parse2(tokens.clone()) { 567 Ok(item) => item, 568 Err(_) => unimplemented!("Item::Verbatim `{}`", tokens), 569 }; 570 571 match item { 572 ItemVerbatim::Empty => { 573 self.hardbreak(); 574 } 575 ItemVerbatim::ConstFlexible(item) => { 576 self.flexible_item_const(&item); 577 } 578 ItemVerbatim::FnFlexible(item) => { 579 self.flexible_item_fn(&item); 580 } 581 ItemVerbatim::ImplFlexible(item) => { 582 self.outer_attrs(&item.attrs); 583 self.cbox(INDENT); 584 self.ibox(-INDENT); 585 self.cbox(INDENT); 586 self.visibility(&item.vis); 587 if item.defaultness { 588 self.word("default "); 589 } 590 if item.unsafety { 591 self.word("unsafe "); 592 } 593 self.word("impl"); 594 self.generics(&item.generics); 595 self.end(); 596 self.nbsp(); 597 match item.constness { 598 ImplConstness::None => {} 599 ImplConstness::MaybeConst => self.word("?const "), 600 ImplConstness::Const => self.word("const "), 601 } 602 if item.negative_impl { 603 self.word("!"); 604 } 605 if let Some(trait_) = &item.trait_ { 606 self.ty(trait_); 607 self.space(); 608 self.word("for "); 609 } 610 self.ty(&item.self_ty); 611 self.end(); 612 self.where_clause_for_body(&item.generics.where_clause); 613 self.word("{"); 614 self.hardbreak_if_nonempty(); 615 self.inner_attrs(&item.attrs); 616 for impl_item in &item.items { 617 self.impl_item(impl_item); 618 } 619 self.offset(-INDENT); 620 self.end(); 621 self.word("}"); 622 self.hardbreak(); 623 } 624 ItemVerbatim::Macro2(item) => { 625 self.outer_attrs(&item.attrs); 626 self.visibility(&item.vis); 627 self.word("macro "); 628 self.ident(&item.ident); 629 if let Some(args) = &item.args { 630 self.word("("); 631 self.cbox(INDENT); 632 self.zerobreak(); 633 self.ibox(0); 634 self.macro_rules_tokens(args.clone(), true); 635 self.end(); 636 self.zerobreak(); 637 self.offset(-INDENT); 638 self.end(); 639 self.word(")"); 640 } 641 self.word(" {"); 642 if !item.body.is_empty() { 643 self.neverbreak(); 644 self.cbox(INDENT); 645 self.hardbreak(); 646 self.ibox(0); 647 self.macro_rules_tokens(item.body.clone(), false); 648 self.end(); 649 self.hardbreak(); 650 self.offset(-INDENT); 651 self.end(); 652 } 653 self.word("}"); 654 self.hardbreak(); 655 } 656 ItemVerbatim::StaticFlexible(item) => { 657 self.flexible_item_static(&item); 658 } 659 ItemVerbatim::TypeFlexible(item) => { 660 self.flexible_item_type(&item); 661 } 662 ItemVerbatim::UseBrace(item) => { 663 self.outer_attrs(&item.attrs); 664 self.visibility(&item.vis); 665 self.word("use "); 666 if item.trees.len() == 1 { 667 self.word("::"); 668 self.use_tree(&item.trees[0].inner); 669 } else { 670 self.cbox(INDENT); 671 self.word("{"); 672 self.zerobreak(); 673 self.ibox(0); 674 for use_tree in item.trees.iter().delimited() { 675 if use_tree.leading_colon.is_some() { 676 self.word("::"); 677 } 678 self.use_tree(&use_tree.inner); 679 if !use_tree.is_last { 680 self.word(","); 681 let mut use_tree = &use_tree.inner; 682 while let UseTree::Path(use_path) = use_tree { 683 use_tree = &use_path.tree; 684 } 685 if let UseTree::Group(_) = use_tree { 686 self.hardbreak(); 687 } else { 688 self.space(); 689 } 690 } 691 } 692 self.end(); 693 self.trailing_comma(true); 694 self.offset(-INDENT); 695 self.word("}"); 696 self.end(); 697 } 698 self.word(";"); 699 self.hardbreak(); 700 } 701 } 702 } 703 use_tree(&mut self, use_tree: &UseTree)704 fn use_tree(&mut self, use_tree: &UseTree) { 705 match use_tree { 706 UseTree::Path(use_path) => self.use_path(use_path), 707 UseTree::Name(use_name) => self.use_name(use_name), 708 UseTree::Rename(use_rename) => self.use_rename(use_rename), 709 UseTree::Glob(use_glob) => self.use_glob(use_glob), 710 UseTree::Group(use_group) => self.use_group(use_group), 711 } 712 } 713 use_path(&mut self, use_path: &UsePath)714 fn use_path(&mut self, use_path: &UsePath) { 715 self.ident(&use_path.ident); 716 self.word("::"); 717 self.use_tree(&use_path.tree); 718 } 719 use_name(&mut self, use_name: &UseName)720 fn use_name(&mut self, use_name: &UseName) { 721 self.ident(&use_name.ident); 722 } 723 use_rename(&mut self, use_rename: &UseRename)724 fn use_rename(&mut self, use_rename: &UseRename) { 725 self.ident(&use_rename.ident); 726 self.word(" as "); 727 self.ident(&use_rename.rename); 728 } 729 use_glob(&mut self, use_glob: &UseGlob)730 fn use_glob(&mut self, use_glob: &UseGlob) { 731 let _ = use_glob; 732 self.word("*"); 733 } 734 use_group(&mut self, use_group: &UseGroup)735 fn use_group(&mut self, use_group: &UseGroup) { 736 if use_group.items.is_empty() { 737 self.word("{}"); 738 } else if use_group.items.len() == 1 { 739 self.use_tree(&use_group.items[0]); 740 } else { 741 self.cbox(INDENT); 742 self.word("{"); 743 self.zerobreak(); 744 self.ibox(0); 745 for use_tree in use_group.items.iter().delimited() { 746 self.use_tree(&use_tree); 747 if !use_tree.is_last { 748 self.word(","); 749 let mut use_tree = *use_tree; 750 while let UseTree::Path(use_path) = use_tree { 751 use_tree = &use_path.tree; 752 } 753 if let UseTree::Group(_) = use_tree { 754 self.hardbreak(); 755 } else { 756 self.space(); 757 } 758 } 759 } 760 self.end(); 761 self.trailing_comma(true); 762 self.offset(-INDENT); 763 self.word("}"); 764 self.end(); 765 } 766 } 767 foreign_item(&mut self, foreign_item: &ForeignItem)768 fn foreign_item(&mut self, foreign_item: &ForeignItem) { 769 match foreign_item { 770 ForeignItem::Fn(item) => self.foreign_item_fn(item), 771 ForeignItem::Static(item) => self.foreign_item_static(item), 772 ForeignItem::Type(item) => self.foreign_item_type(item), 773 ForeignItem::Macro(item) => self.foreign_item_macro(item), 774 ForeignItem::Verbatim(item) => self.foreign_item_verbatim(item), 775 #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))] 776 _ => unimplemented!("unknown ForeignItem"), 777 } 778 } 779 foreign_item_fn(&mut self, foreign_item: &ForeignItemFn)780 fn foreign_item_fn(&mut self, foreign_item: &ForeignItemFn) { 781 self.outer_attrs(&foreign_item.attrs); 782 self.cbox(INDENT); 783 self.visibility(&foreign_item.vis); 784 self.signature(&foreign_item.sig); 785 self.where_clause_semi(&foreign_item.sig.generics.where_clause); 786 self.end(); 787 self.hardbreak(); 788 } 789 foreign_item_static(&mut self, foreign_item: &ForeignItemStatic)790 fn foreign_item_static(&mut self, foreign_item: &ForeignItemStatic) { 791 self.outer_attrs(&foreign_item.attrs); 792 self.cbox(0); 793 self.visibility(&foreign_item.vis); 794 self.word("static "); 795 self.static_mutability(&foreign_item.mutability); 796 self.ident(&foreign_item.ident); 797 self.word(": "); 798 self.ty(&foreign_item.ty); 799 self.word(";"); 800 self.end(); 801 self.hardbreak(); 802 } 803 foreign_item_type(&mut self, foreign_item: &ForeignItemType)804 fn foreign_item_type(&mut self, foreign_item: &ForeignItemType) { 805 self.outer_attrs(&foreign_item.attrs); 806 self.cbox(0); 807 self.visibility(&foreign_item.vis); 808 self.word("type "); 809 self.ident(&foreign_item.ident); 810 self.generics(&foreign_item.generics); 811 self.word(";"); 812 self.end(); 813 self.hardbreak(); 814 } 815 foreign_item_macro(&mut self, foreign_item: &ForeignItemMacro)816 fn foreign_item_macro(&mut self, foreign_item: &ForeignItemMacro) { 817 self.outer_attrs(&foreign_item.attrs); 818 let semicolon = true; 819 self.mac(&foreign_item.mac, None, semicolon); 820 self.hardbreak(); 821 } 822 823 #[cfg(not(feature = "verbatim"))] foreign_item_verbatim(&mut self, foreign_item: &TokenStream)824 fn foreign_item_verbatim(&mut self, foreign_item: &TokenStream) { 825 if !foreign_item.is_empty() { 826 unimplemented!("ForeignItem::Verbatim `{}`", foreign_item); 827 } 828 self.hardbreak(); 829 } 830 831 #[cfg(feature = "verbatim")] foreign_item_verbatim(&mut self, tokens: &TokenStream)832 fn foreign_item_verbatim(&mut self, tokens: &TokenStream) { 833 use syn::parse::{Parse, ParseStream, Result}; 834 use syn::{Attribute, Token, Visibility}; 835 use verbatim::{FlexibleItemFn, FlexibleItemStatic, FlexibleItemType, WhereClauseLocation}; 836 837 enum ForeignItemVerbatim { 838 Empty, 839 FnFlexible(FlexibleItemFn), 840 StaticFlexible(FlexibleItemStatic), 841 TypeFlexible(FlexibleItemType), 842 } 843 844 impl Parse for ForeignItemVerbatim { 845 fn parse(input: ParseStream) -> Result<Self> { 846 if input.is_empty() { 847 return Ok(ForeignItemVerbatim::Empty); 848 } 849 850 let attrs = input.call(Attribute::parse_outer)?; 851 let vis: Visibility = input.parse()?; 852 let defaultness = false; 853 854 let lookahead = input.lookahead1(); 855 if lookahead.peek(Token![const]) 856 || lookahead.peek(Token![async]) 857 || lookahead.peek(Token![unsafe]) 858 || lookahead.peek(Token![extern]) 859 || lookahead.peek(Token![fn]) 860 { 861 let flexible_item = FlexibleItemFn::parse(attrs, vis, defaultness, input)?; 862 Ok(ForeignItemVerbatim::FnFlexible(flexible_item)) 863 } else if lookahead.peek(Token![static]) { 864 let flexible_item = FlexibleItemStatic::parse(attrs, vis, input)?; 865 Ok(ForeignItemVerbatim::StaticFlexible(flexible_item)) 866 } else if lookahead.peek(Token![type]) { 867 let flexible_item = FlexibleItemType::parse( 868 attrs, 869 vis, 870 defaultness, 871 input, 872 WhereClauseLocation::Both, 873 )?; 874 Ok(ForeignItemVerbatim::TypeFlexible(flexible_item)) 875 } else { 876 Err(lookahead.error()) 877 } 878 } 879 } 880 881 let foreign_item: ForeignItemVerbatim = match syn::parse2(tokens.clone()) { 882 Ok(foreign_item) => foreign_item, 883 Err(_) => unimplemented!("ForeignItem::Verbatim `{}`", tokens), 884 }; 885 886 match foreign_item { 887 ForeignItemVerbatim::Empty => { 888 self.hardbreak(); 889 } 890 ForeignItemVerbatim::FnFlexible(foreign_item) => { 891 self.flexible_item_fn(&foreign_item); 892 } 893 ForeignItemVerbatim::StaticFlexible(foreign_item) => { 894 self.flexible_item_static(&foreign_item); 895 } 896 ForeignItemVerbatim::TypeFlexible(foreign_item) => { 897 self.flexible_item_type(&foreign_item); 898 } 899 } 900 } 901 trait_item(&mut self, trait_item: &TraitItem)902 fn trait_item(&mut self, trait_item: &TraitItem) { 903 match trait_item { 904 TraitItem::Const(item) => self.trait_item_const(item), 905 TraitItem::Fn(item) => self.trait_item_fn(item), 906 TraitItem::Type(item) => self.trait_item_type(item), 907 TraitItem::Macro(item) => self.trait_item_macro(item), 908 TraitItem::Verbatim(item) => self.trait_item_verbatim(item), 909 #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))] 910 _ => unimplemented!("unknown TraitItem"), 911 } 912 } 913 trait_item_const(&mut self, trait_item: &TraitItemConst)914 fn trait_item_const(&mut self, trait_item: &TraitItemConst) { 915 self.outer_attrs(&trait_item.attrs); 916 self.cbox(0); 917 self.word("const "); 918 self.ident(&trait_item.ident); 919 self.generics(&trait_item.generics); 920 self.word(": "); 921 self.ty(&trait_item.ty); 922 if let Some((_eq_token, default)) = &trait_item.default { 923 self.word(" = "); 924 self.neverbreak(); 925 self.expr(default); 926 } 927 self.word(";"); 928 self.end(); 929 self.hardbreak(); 930 } 931 trait_item_fn(&mut self, trait_item: &TraitItemFn)932 fn trait_item_fn(&mut self, trait_item: &TraitItemFn) { 933 self.outer_attrs(&trait_item.attrs); 934 self.cbox(INDENT); 935 self.signature(&trait_item.sig); 936 if let Some(block) = &trait_item.default { 937 self.where_clause_for_body(&trait_item.sig.generics.where_clause); 938 self.word("{"); 939 self.hardbreak_if_nonempty(); 940 self.inner_attrs(&trait_item.attrs); 941 for stmt in &block.stmts { 942 self.stmt(stmt); 943 } 944 self.offset(-INDENT); 945 self.end(); 946 self.word("}"); 947 } else { 948 self.where_clause_semi(&trait_item.sig.generics.where_clause); 949 self.end(); 950 } 951 self.hardbreak(); 952 } 953 trait_item_type(&mut self, trait_item: &TraitItemType)954 fn trait_item_type(&mut self, trait_item: &TraitItemType) { 955 self.outer_attrs(&trait_item.attrs); 956 self.cbox(INDENT); 957 self.word("type "); 958 self.ident(&trait_item.ident); 959 self.generics(&trait_item.generics); 960 for bound in trait_item.bounds.iter().delimited() { 961 if bound.is_first { 962 self.word(": "); 963 } else { 964 self.space(); 965 self.word("+ "); 966 } 967 self.type_param_bound(&bound); 968 } 969 if let Some((_eq_token, default)) = &trait_item.default { 970 self.word(" = "); 971 self.neverbreak(); 972 self.ibox(-INDENT); 973 self.ty(default); 974 self.end(); 975 } 976 self.where_clause_oneline_semi(&trait_item.generics.where_clause); 977 self.end(); 978 self.hardbreak(); 979 } 980 trait_item_macro(&mut self, trait_item: &TraitItemMacro)981 fn trait_item_macro(&mut self, trait_item: &TraitItemMacro) { 982 self.outer_attrs(&trait_item.attrs); 983 let semicolon = true; 984 self.mac(&trait_item.mac, None, semicolon); 985 self.hardbreak(); 986 } 987 988 #[cfg(not(feature = "verbatim"))] trait_item_verbatim(&mut self, trait_item: &TokenStream)989 fn trait_item_verbatim(&mut self, trait_item: &TokenStream) { 990 if !trait_item.is_empty() { 991 unimplemented!("TraitItem::Verbatim `{}`", trait_item); 992 } 993 self.hardbreak(); 994 } 995 996 #[cfg(feature = "verbatim")] trait_item_verbatim(&mut self, tokens: &TokenStream)997 fn trait_item_verbatim(&mut self, tokens: &TokenStream) { 998 use syn::parse::{Parse, ParseStream, Result}; 999 use syn::{Attribute, Token, Visibility}; 1000 use verbatim::{FlexibleItemType, WhereClauseLocation}; 1001 1002 enum TraitItemVerbatim { 1003 Empty, 1004 TypeFlexible(FlexibleItemType), 1005 PubOrDefault(PubOrDefaultTraitItem), 1006 } 1007 1008 struct PubOrDefaultTraitItem { 1009 attrs: Vec<Attribute>, 1010 vis: Visibility, 1011 defaultness: bool, 1012 trait_item: TraitItem, 1013 } 1014 1015 impl Parse for TraitItemVerbatim { 1016 fn parse(input: ParseStream) -> Result<Self> { 1017 if input.is_empty() { 1018 return Ok(TraitItemVerbatim::Empty); 1019 } 1020 1021 let attrs = input.call(Attribute::parse_outer)?; 1022 let vis: Visibility = input.parse()?; 1023 let defaultness = input.parse::<Option<Token![default]>>()?.is_some(); 1024 1025 let lookahead = input.lookahead1(); 1026 if lookahead.peek(Token![type]) { 1027 let flexible_item = FlexibleItemType::parse( 1028 attrs, 1029 vis, 1030 defaultness, 1031 input, 1032 WhereClauseLocation::AfterEq, 1033 )?; 1034 Ok(TraitItemVerbatim::TypeFlexible(flexible_item)) 1035 } else if (lookahead.peek(Token![const]) 1036 || lookahead.peek(Token![async]) 1037 || lookahead.peek(Token![unsafe]) 1038 || lookahead.peek(Token![extern]) 1039 || lookahead.peek(Token![fn])) 1040 && (!matches!(vis, Visibility::Inherited) || defaultness) 1041 { 1042 Ok(TraitItemVerbatim::PubOrDefault(PubOrDefaultTraitItem { 1043 attrs, 1044 vis, 1045 defaultness, 1046 trait_item: input.parse()?, 1047 })) 1048 } else { 1049 Err(lookahead.error()) 1050 } 1051 } 1052 } 1053 1054 let impl_item: TraitItemVerbatim = match syn::parse2(tokens.clone()) { 1055 Ok(impl_item) => impl_item, 1056 Err(_) => unimplemented!("TraitItem::Verbatim `{}`", tokens), 1057 }; 1058 1059 match impl_item { 1060 TraitItemVerbatim::Empty => { 1061 self.hardbreak(); 1062 } 1063 TraitItemVerbatim::TypeFlexible(trait_item) => { 1064 self.flexible_item_type(&trait_item); 1065 } 1066 TraitItemVerbatim::PubOrDefault(trait_item) => { 1067 self.outer_attrs(&trait_item.attrs); 1068 self.visibility(&trait_item.vis); 1069 if trait_item.defaultness { 1070 self.word("default "); 1071 } 1072 self.trait_item(&trait_item.trait_item); 1073 } 1074 } 1075 } 1076 impl_item(&mut self, impl_item: &ImplItem)1077 fn impl_item(&mut self, impl_item: &ImplItem) { 1078 match impl_item { 1079 ImplItem::Const(item) => self.impl_item_const(item), 1080 ImplItem::Fn(item) => self.impl_item_fn(item), 1081 ImplItem::Type(item) => self.impl_item_type(item), 1082 ImplItem::Macro(item) => self.impl_item_macro(item), 1083 ImplItem::Verbatim(item) => self.impl_item_verbatim(item), 1084 #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))] 1085 _ => unimplemented!("unknown ImplItem"), 1086 } 1087 } 1088 impl_item_const(&mut self, impl_item: &ImplItemConst)1089 fn impl_item_const(&mut self, impl_item: &ImplItemConst) { 1090 self.outer_attrs(&impl_item.attrs); 1091 self.cbox(0); 1092 self.visibility(&impl_item.vis); 1093 if impl_item.defaultness.is_some() { 1094 self.word("default "); 1095 } 1096 self.word("const "); 1097 self.ident(&impl_item.ident); 1098 self.generics(&impl_item.generics); 1099 self.word(": "); 1100 self.ty(&impl_item.ty); 1101 self.word(" = "); 1102 self.neverbreak(); 1103 self.expr(&impl_item.expr); 1104 self.word(";"); 1105 self.end(); 1106 self.hardbreak(); 1107 } 1108 impl_item_fn(&mut self, impl_item: &ImplItemFn)1109 fn impl_item_fn(&mut self, impl_item: &ImplItemFn) { 1110 self.outer_attrs(&impl_item.attrs); 1111 self.cbox(INDENT); 1112 self.visibility(&impl_item.vis); 1113 if impl_item.defaultness.is_some() { 1114 self.word("default "); 1115 } 1116 self.signature(&impl_item.sig); 1117 self.where_clause_for_body(&impl_item.sig.generics.where_clause); 1118 self.word("{"); 1119 self.hardbreak_if_nonempty(); 1120 self.inner_attrs(&impl_item.attrs); 1121 for stmt in &impl_item.block.stmts { 1122 self.stmt(stmt); 1123 } 1124 self.offset(-INDENT); 1125 self.end(); 1126 self.word("}"); 1127 self.hardbreak(); 1128 } 1129 impl_item_type(&mut self, impl_item: &ImplItemType)1130 fn impl_item_type(&mut self, impl_item: &ImplItemType) { 1131 self.outer_attrs(&impl_item.attrs); 1132 self.cbox(INDENT); 1133 self.visibility(&impl_item.vis); 1134 if impl_item.defaultness.is_some() { 1135 self.word("default "); 1136 } 1137 self.word("type "); 1138 self.ident(&impl_item.ident); 1139 self.generics(&impl_item.generics); 1140 self.word(" = "); 1141 self.neverbreak(); 1142 self.ibox(-INDENT); 1143 self.ty(&impl_item.ty); 1144 self.end(); 1145 self.where_clause_oneline_semi(&impl_item.generics.where_clause); 1146 self.end(); 1147 self.hardbreak(); 1148 } 1149 impl_item_macro(&mut self, impl_item: &ImplItemMacro)1150 fn impl_item_macro(&mut self, impl_item: &ImplItemMacro) { 1151 self.outer_attrs(&impl_item.attrs); 1152 let semicolon = true; 1153 self.mac(&impl_item.mac, None, semicolon); 1154 self.hardbreak(); 1155 } 1156 1157 #[cfg(not(feature = "verbatim"))] impl_item_verbatim(&mut self, impl_item: &TokenStream)1158 fn impl_item_verbatim(&mut self, impl_item: &TokenStream) { 1159 if !impl_item.is_empty() { 1160 unimplemented!("ImplItem::Verbatim `{}`", impl_item); 1161 } 1162 self.hardbreak(); 1163 } 1164 1165 #[cfg(feature = "verbatim")] impl_item_verbatim(&mut self, tokens: &TokenStream)1166 fn impl_item_verbatim(&mut self, tokens: &TokenStream) { 1167 use syn::parse::{Parse, ParseStream, Result}; 1168 use syn::{Attribute, Ident, Token, Visibility}; 1169 use verbatim::{FlexibleItemConst, FlexibleItemFn, FlexibleItemType, WhereClauseLocation}; 1170 1171 enum ImplItemVerbatim { 1172 Empty, 1173 ConstFlexible(FlexibleItemConst), 1174 FnFlexible(FlexibleItemFn), 1175 TypeFlexible(FlexibleItemType), 1176 } 1177 1178 impl Parse for ImplItemVerbatim { 1179 fn parse(input: ParseStream) -> Result<Self> { 1180 if input.is_empty() { 1181 return Ok(ImplItemVerbatim::Empty); 1182 } 1183 1184 let attrs = input.call(Attribute::parse_outer)?; 1185 let vis: Visibility = input.parse()?; 1186 let defaultness = input.parse::<Option<Token![default]>>()?.is_some(); 1187 1188 let lookahead = input.lookahead1(); 1189 if lookahead.peek(Token![const]) && (input.peek2(Ident) || input.peek2(Token![_])) { 1190 let flexible_item = FlexibleItemConst::parse(attrs, vis, defaultness, input)?; 1191 Ok(ImplItemVerbatim::ConstFlexible(flexible_item)) 1192 } else if input.peek(Token![const]) 1193 || lookahead.peek(Token![async]) 1194 || lookahead.peek(Token![unsafe]) 1195 || lookahead.peek(Token![extern]) 1196 || lookahead.peek(Token![fn]) 1197 { 1198 let flexible_item = FlexibleItemFn::parse(attrs, vis, defaultness, input)?; 1199 Ok(ImplItemVerbatim::FnFlexible(flexible_item)) 1200 } else if lookahead.peek(Token![type]) { 1201 let flexible_item = FlexibleItemType::parse( 1202 attrs, 1203 vis, 1204 defaultness, 1205 input, 1206 WhereClauseLocation::AfterEq, 1207 )?; 1208 Ok(ImplItemVerbatim::TypeFlexible(flexible_item)) 1209 } else { 1210 Err(lookahead.error()) 1211 } 1212 } 1213 } 1214 1215 let impl_item: ImplItemVerbatim = match syn::parse2(tokens.clone()) { 1216 Ok(impl_item) => impl_item, 1217 Err(_) => unimplemented!("ImplItem::Verbatim `{}`", tokens), 1218 }; 1219 1220 match impl_item { 1221 ImplItemVerbatim::Empty => { 1222 self.hardbreak(); 1223 } 1224 ImplItemVerbatim::ConstFlexible(impl_item) => { 1225 self.flexible_item_const(&impl_item); 1226 } 1227 ImplItemVerbatim::FnFlexible(impl_item) => { 1228 self.flexible_item_fn(&impl_item); 1229 } 1230 ImplItemVerbatim::TypeFlexible(impl_item) => { 1231 self.flexible_item_type(&impl_item); 1232 } 1233 } 1234 } 1235 signature(&mut self, signature: &Signature)1236 fn signature(&mut self, signature: &Signature) { 1237 if signature.constness.is_some() { 1238 self.word("const "); 1239 } 1240 if signature.asyncness.is_some() { 1241 self.word("async "); 1242 } 1243 if signature.unsafety.is_some() { 1244 self.word("unsafe "); 1245 } 1246 if let Some(abi) = &signature.abi { 1247 self.abi(abi); 1248 } 1249 self.word("fn "); 1250 self.ident(&signature.ident); 1251 self.generics(&signature.generics); 1252 self.word("("); 1253 self.neverbreak(); 1254 self.cbox(0); 1255 self.zerobreak(); 1256 for input in signature.inputs.iter().delimited() { 1257 self.fn_arg(&input); 1258 let is_last = input.is_last && signature.variadic.is_none(); 1259 self.trailing_comma(is_last); 1260 } 1261 if let Some(variadic) = &signature.variadic { 1262 self.variadic(variadic); 1263 self.zerobreak(); 1264 } 1265 self.offset(-INDENT); 1266 self.end(); 1267 self.word(")"); 1268 self.cbox(-INDENT); 1269 self.return_type(&signature.output); 1270 self.end(); 1271 } 1272 fn_arg(&mut self, fn_arg: &FnArg)1273 fn fn_arg(&mut self, fn_arg: &FnArg) { 1274 match fn_arg { 1275 FnArg::Receiver(receiver) => self.receiver(receiver), 1276 FnArg::Typed(pat_type) => self.pat_type(pat_type), 1277 } 1278 } 1279 receiver(&mut self, receiver: &Receiver)1280 fn receiver(&mut self, receiver: &Receiver) { 1281 self.outer_attrs(&receiver.attrs); 1282 if let Some((_ampersand, lifetime)) = &receiver.reference { 1283 self.word("&"); 1284 if let Some(lifetime) = lifetime { 1285 self.lifetime(lifetime); 1286 self.nbsp(); 1287 } 1288 } 1289 if receiver.mutability.is_some() { 1290 self.word("mut "); 1291 } 1292 self.word("self"); 1293 if receiver.colon_token.is_some() { 1294 self.word(": "); 1295 self.ty(&receiver.ty); 1296 } else { 1297 let consistent = match (&receiver.reference, &receiver.mutability, &*receiver.ty) { 1298 (Some(_), mutability, Type::Reference(ty)) => { 1299 mutability.is_some() == ty.mutability.is_some() 1300 && match &*ty.elem { 1301 Type::Path(ty) => ty.qself.is_none() && ty.path.is_ident("Self"), 1302 _ => false, 1303 } 1304 } 1305 (None, _, Type::Path(ty)) => ty.qself.is_none() && ty.path.is_ident("Self"), 1306 _ => false, 1307 }; 1308 if !consistent { 1309 self.word(": "); 1310 self.ty(&receiver.ty); 1311 } 1312 } 1313 } 1314 variadic(&mut self, variadic: &Variadic)1315 fn variadic(&mut self, variadic: &Variadic) { 1316 self.outer_attrs(&variadic.attrs); 1317 if let Some((pat, _colon)) = &variadic.pat { 1318 self.pat(pat); 1319 self.word(": "); 1320 } 1321 self.word("..."); 1322 } 1323 static_mutability(&mut self, mutability: &StaticMutability)1324 fn static_mutability(&mut self, mutability: &StaticMutability) { 1325 match mutability { 1326 StaticMutability::Mut(_) => self.word("mut "), 1327 StaticMutability::None => {} 1328 #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))] 1329 _ => unimplemented!("unknown StaticMutability"), 1330 } 1331 } 1332 } 1333 1334 #[cfg(feature = "verbatim")] 1335 mod verbatim { 1336 use crate::algorithm::Printer; 1337 use crate::iter::IterDelimited; 1338 use crate::INDENT; 1339 use syn::ext::IdentExt; 1340 use syn::parse::{ParseStream, Result}; 1341 use syn::{ 1342 braced, token, Attribute, Block, Expr, Generics, Ident, Signature, StaticMutability, Stmt, 1343 Token, Type, TypeParamBound, Visibility, WhereClause, 1344 }; 1345 1346 pub struct FlexibleItemConst { 1347 pub attrs: Vec<Attribute>, 1348 pub vis: Visibility, 1349 pub defaultness: bool, 1350 pub ident: Ident, 1351 pub ty: Type, 1352 } 1353 1354 pub struct FlexibleItemFn { 1355 pub attrs: Vec<Attribute>, 1356 pub vis: Visibility, 1357 pub defaultness: bool, 1358 pub sig: Signature, 1359 pub body: Option<Vec<Stmt>>, 1360 } 1361 1362 pub struct FlexibleItemStatic { 1363 pub attrs: Vec<Attribute>, 1364 pub vis: Visibility, 1365 pub mutability: StaticMutability, 1366 pub ident: Ident, 1367 pub ty: Option<Type>, 1368 pub expr: Option<Expr>, 1369 } 1370 1371 pub struct FlexibleItemType { 1372 pub attrs: Vec<Attribute>, 1373 pub vis: Visibility, 1374 pub defaultness: bool, 1375 pub ident: Ident, 1376 pub generics: Generics, 1377 pub bounds: Vec<TypeParamBound>, 1378 pub definition: Option<Type>, 1379 pub where_clause_after_eq: Option<WhereClause>, 1380 } 1381 1382 pub enum WhereClauseLocation { 1383 // type Ty<T> where T: 'static = T; 1384 BeforeEq, 1385 // type Ty<T> = T where T: 'static; 1386 AfterEq, 1387 // TODO: goes away once the migration period on rust-lang/rust#89122 is over 1388 Both, 1389 } 1390 1391 impl FlexibleItemConst { parse( attrs: Vec<Attribute>, vis: Visibility, defaultness: bool, input: ParseStream, ) -> Result<Self>1392 pub fn parse( 1393 attrs: Vec<Attribute>, 1394 vis: Visibility, 1395 defaultness: bool, 1396 input: ParseStream, 1397 ) -> Result<Self> { 1398 input.parse::<Token![const]>()?; 1399 let ident = input.call(Ident::parse_any)?; 1400 input.parse::<Token![:]>()?; 1401 let ty: Type = input.parse()?; 1402 input.parse::<Token![;]>()?; 1403 1404 Ok(FlexibleItemConst { 1405 attrs, 1406 vis, 1407 defaultness, 1408 ident, 1409 ty, 1410 }) 1411 } 1412 } 1413 1414 impl FlexibleItemFn { parse( mut attrs: Vec<Attribute>, vis: Visibility, defaultness: bool, input: ParseStream, ) -> Result<Self>1415 pub fn parse( 1416 mut attrs: Vec<Attribute>, 1417 vis: Visibility, 1418 defaultness: bool, 1419 input: ParseStream, 1420 ) -> Result<Self> { 1421 let sig: Signature = input.parse()?; 1422 1423 let lookahead = input.lookahead1(); 1424 let body = if lookahead.peek(Token![;]) { 1425 input.parse::<Token![;]>()?; 1426 None 1427 } else if lookahead.peek(token::Brace) { 1428 let content; 1429 braced!(content in input); 1430 attrs.extend(content.call(Attribute::parse_inner)?); 1431 Some(content.call(Block::parse_within)?) 1432 } else { 1433 return Err(lookahead.error()); 1434 }; 1435 1436 Ok(FlexibleItemFn { 1437 attrs, 1438 vis, 1439 defaultness, 1440 sig, 1441 body, 1442 }) 1443 } 1444 } 1445 1446 impl FlexibleItemStatic { parse(attrs: Vec<Attribute>, vis: Visibility, input: ParseStream) -> Result<Self>1447 pub fn parse(attrs: Vec<Attribute>, vis: Visibility, input: ParseStream) -> Result<Self> { 1448 input.parse::<Token![static]>()?; 1449 let mutability: StaticMutability = input.parse()?; 1450 let ident = input.parse()?; 1451 1452 let lookahead = input.lookahead1(); 1453 let has_type = lookahead.peek(Token![:]); 1454 let has_expr = lookahead.peek(Token![=]); 1455 if !has_type && !has_expr { 1456 return Err(lookahead.error()); 1457 } 1458 1459 let ty: Option<Type> = if has_type { 1460 input.parse::<Token![:]>()?; 1461 input.parse().map(Some)? 1462 } else { 1463 None 1464 }; 1465 1466 let expr: Option<Expr> = if input.parse::<Option<Token![=]>>()?.is_some() { 1467 input.parse().map(Some)? 1468 } else { 1469 None 1470 }; 1471 1472 input.parse::<Token![;]>()?; 1473 1474 Ok(FlexibleItemStatic { 1475 attrs, 1476 vis, 1477 mutability, 1478 ident, 1479 ty, 1480 expr, 1481 }) 1482 } 1483 } 1484 1485 impl FlexibleItemType { parse( attrs: Vec<Attribute>, vis: Visibility, defaultness: bool, input: ParseStream, where_clause_location: WhereClauseLocation, ) -> Result<Self>1486 pub fn parse( 1487 attrs: Vec<Attribute>, 1488 vis: Visibility, 1489 defaultness: bool, 1490 input: ParseStream, 1491 where_clause_location: WhereClauseLocation, 1492 ) -> Result<Self> { 1493 input.parse::<Token![type]>()?; 1494 let ident: Ident = input.parse()?; 1495 let mut generics: Generics = input.parse()?; 1496 1497 let mut bounds = Vec::new(); 1498 if input.parse::<Option<Token![:]>>()?.is_some() { 1499 loop { 1500 if input.peek(Token![where]) || input.peek(Token![=]) || input.peek(Token![;]) { 1501 break; 1502 } 1503 bounds.push(input.parse::<TypeParamBound>()?); 1504 if input.peek(Token![where]) || input.peek(Token![=]) || input.peek(Token![;]) { 1505 break; 1506 } 1507 input.parse::<Token![+]>()?; 1508 } 1509 } 1510 1511 match where_clause_location { 1512 WhereClauseLocation::BeforeEq | WhereClauseLocation::Both => { 1513 generics.where_clause = input.parse()?; 1514 } 1515 WhereClauseLocation::AfterEq => {} 1516 } 1517 1518 let definition = if input.parse::<Option<Token![=]>>()?.is_some() { 1519 Some(input.parse()?) 1520 } else { 1521 None 1522 }; 1523 1524 let where_clause_after_eq = match where_clause_location { 1525 WhereClauseLocation::AfterEq | WhereClauseLocation::Both 1526 if generics.where_clause.is_none() => 1527 { 1528 input.parse()? 1529 } 1530 _ => None, 1531 }; 1532 1533 input.parse::<Token![;]>()?; 1534 1535 Ok(FlexibleItemType { 1536 attrs, 1537 vis, 1538 defaultness, 1539 ident, 1540 generics, 1541 bounds, 1542 definition, 1543 where_clause_after_eq, 1544 }) 1545 } 1546 } 1547 1548 impl Printer { flexible_item_const(&mut self, item: &FlexibleItemConst)1549 pub fn flexible_item_const(&mut self, item: &FlexibleItemConst) { 1550 self.outer_attrs(&item.attrs); 1551 self.cbox(0); 1552 self.visibility(&item.vis); 1553 if item.defaultness { 1554 self.word("default "); 1555 } 1556 self.word("const "); 1557 self.ident(&item.ident); 1558 self.word(": "); 1559 self.ty(&item.ty); 1560 self.word(";"); 1561 self.end(); 1562 self.hardbreak(); 1563 } 1564 flexible_item_fn(&mut self, item: &FlexibleItemFn)1565 pub fn flexible_item_fn(&mut self, item: &FlexibleItemFn) { 1566 self.outer_attrs(&item.attrs); 1567 self.cbox(INDENT); 1568 self.visibility(&item.vis); 1569 if item.defaultness { 1570 self.word("default "); 1571 } 1572 self.signature(&item.sig); 1573 if let Some(body) = &item.body { 1574 self.where_clause_for_body(&item.sig.generics.where_clause); 1575 self.word("{"); 1576 self.hardbreak_if_nonempty(); 1577 self.inner_attrs(&item.attrs); 1578 for stmt in body { 1579 self.stmt(stmt); 1580 } 1581 self.offset(-INDENT); 1582 self.end(); 1583 self.word("}"); 1584 } else { 1585 self.where_clause_semi(&item.sig.generics.where_clause); 1586 self.end(); 1587 } 1588 self.hardbreak(); 1589 } 1590 flexible_item_static(&mut self, item: &FlexibleItemStatic)1591 pub fn flexible_item_static(&mut self, item: &FlexibleItemStatic) { 1592 self.outer_attrs(&item.attrs); 1593 self.cbox(0); 1594 self.visibility(&item.vis); 1595 self.word("static "); 1596 self.static_mutability(&item.mutability); 1597 self.ident(&item.ident); 1598 if let Some(ty) = &item.ty { 1599 self.word(": "); 1600 self.ty(ty); 1601 } 1602 if let Some(expr) = &item.expr { 1603 self.word(" = "); 1604 self.neverbreak(); 1605 self.expr(expr); 1606 } 1607 self.word(";"); 1608 self.end(); 1609 self.hardbreak(); 1610 } 1611 flexible_item_type(&mut self, item: &FlexibleItemType)1612 pub fn flexible_item_type(&mut self, item: &FlexibleItemType) { 1613 self.outer_attrs(&item.attrs); 1614 self.cbox(INDENT); 1615 self.visibility(&item.vis); 1616 if item.defaultness { 1617 self.word("default "); 1618 } 1619 self.word("type "); 1620 self.ident(&item.ident); 1621 self.generics(&item.generics); 1622 for bound in item.bounds.iter().delimited() { 1623 if bound.is_first { 1624 self.word(": "); 1625 } else { 1626 self.space(); 1627 self.word("+ "); 1628 } 1629 self.type_param_bound(&bound); 1630 } 1631 if let Some(definition) = &item.definition { 1632 self.where_clause_oneline(&item.generics.where_clause); 1633 self.word("= "); 1634 self.neverbreak(); 1635 self.ibox(-INDENT); 1636 self.ty(definition); 1637 self.end(); 1638 self.where_clause_oneline_semi(&item.where_clause_after_eq); 1639 } else { 1640 self.where_clause_oneline_semi(&item.generics.where_clause); 1641 } 1642 self.end(); 1643 self.hardbreak(); 1644 } 1645 } 1646 } 1647