1use crate::algorithm::Printer;
2use crate::iter::IterDelimited;
3use crate::path::PathKind;
4use crate::INDENT;
5use proc_macro2::TokenStream;
6use 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
15impl Printer {
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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"))]
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")]
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
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
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
720 fn use_name(&mut self, use_name: &UseName) {
721 self.ident(&use_name.ident);
722 }
723
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
730 fn use_glob(&mut self, use_glob: &UseGlob) {
731 let _ = use_glob;
732 self.word("*");
733 }
734
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
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
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
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
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
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"))]
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")]
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
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
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
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
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
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"))]
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")]
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
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
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
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
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
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"))]
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")]
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
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
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
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
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
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")]
1335mod 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 BeforeEq,
1385 AfterEq,
1387 Both,
1389 }
1390
1391 impl FlexibleItemConst {
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 {
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 {
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 {
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 {
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
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
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
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}