prettyplease/
item.rs

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

prettyplease/
item.rs
