rustc_ast_pretty/pprust/state/
item.rs

1use ast::StaticItem;
2use itertools::{Itertools, Position};
3use rustc_ast as ast;
4use rustc_ast::ModKind;
5use rustc_span::Ident;
6
7use crate::pp::BoxMarker;
8use crate::pp::Breaks::Inconsistent;
9use crate::pprust::state::fixup::FixupContext;
10use crate::pprust::state::{AnnNode, INDENT_UNIT, PrintState, State};
11
12enum DelegationKind<'a> {
13    Single,
14    List(&'a [(Ident, Option<Ident>)]),
15    Glob,
16}
17
18fn visibility_qualified(vis: &ast::Visibility, s: &str) -> String {
19    format!("{}{}", State::to_string(|s| s.print_visibility(vis)), s)
20}
21
22impl<'a> State<'a> {
23    fn print_foreign_mod(&mut self, nmod: &ast::ForeignMod, attrs: &[ast::Attribute]) {
24        self.print_inner_attributes(attrs);
25        for item in &nmod.items {
26            self.print_foreign_item(item);
27        }
28    }
29
30    pub(crate) fn print_foreign_item(&mut self, item: &ast::ForeignItem) {
31        let ast::Item { id, span, ref attrs, ref kind, ref vis, tokens: _ } = *item;
32        self.ann.pre(self, AnnNode::SubItem(id));
33        self.hardbreak_if_not_bol();
34        self.maybe_print_comment(span.lo());
35        self.print_outer_attributes(attrs);
36        match kind {
37            ast::ForeignItemKind::Fn(func) => {
38                self.print_fn_full(vis, attrs, &*func);
39            }
40            ast::ForeignItemKind::Static(box ast::StaticItem {
41                ident,
42                ty,
43                mutability,
44                expr,
45                safety,
46                define_opaque,
47            }) => self.print_item_const(
48                *ident,
49                Some(*mutability),
50                &ast::Generics::default(),
51                ty,
52                expr.as_deref(),
53                vis,
54                *safety,
55                ast::Defaultness::Final,
56                define_opaque.as_deref(),
57            ),
58            ast::ForeignItemKind::TyAlias(box ast::TyAlias {
59                defaultness,
60                ident,
61                generics,
62                where_clauses,
63                bounds,
64                ty,
65            }) => {
66                self.print_associated_type(
67                    *ident,
68                    generics,
69                    *where_clauses,
70                    bounds,
71                    ty.as_deref(),
72                    vis,
73                    *defaultness,
74                );
75            }
76            ast::ForeignItemKind::MacCall(m) => {
77                self.print_mac(m);
78                if m.args.need_semicolon() {
79                    self.word(";");
80                }
81            }
82        }
83        self.ann.post(self, AnnNode::SubItem(id))
84    }
85
86    fn print_item_const(
87        &mut self,
88        ident: Ident,
89        mutbl: Option<ast::Mutability>,
90        generics: &ast::Generics,
91        ty: &ast::Ty,
92        body: Option<&ast::Expr>,
93        vis: &ast::Visibility,
94        safety: ast::Safety,
95        defaultness: ast::Defaultness,
96        define_opaque: Option<&[(ast::NodeId, ast::Path)]>,
97    ) {
98        self.print_define_opaques(define_opaque);
99        let (cb, ib) = self.head("");
100        self.print_visibility(vis);
101        self.print_safety(safety);
102        self.print_defaultness(defaultness);
103        let leading = match mutbl {
104            None => "const",
105            Some(ast::Mutability::Not) => "static",
106            Some(ast::Mutability::Mut) => "static mut",
107        };
108        self.word_space(leading);
109        self.print_ident(ident);
110        self.print_generic_params(&generics.params);
111        self.word_space(":");
112        self.print_type(ty);
113        if body.is_some() {
114            self.space();
115        }
116        self.end(ib);
117        if let Some(body) = body {
118            self.word_space("=");
119            self.print_expr(body, FixupContext::default());
120        }
121        self.print_where_clause(&generics.where_clause);
122        self.word(";");
123        self.end(cb);
124    }
125
126    fn print_associated_type(
127        &mut self,
128        ident: Ident,
129        generics: &ast::Generics,
130        where_clauses: ast::TyAliasWhereClauses,
131        bounds: &ast::GenericBounds,
132        ty: Option<&ast::Ty>,
133        vis: &ast::Visibility,
134        defaultness: ast::Defaultness,
135    ) {
136        let (before_predicates, after_predicates) =
137            generics.where_clause.predicates.split_at(where_clauses.split);
138        let (cb, ib) = self.head("");
139        self.print_visibility(vis);
140        self.print_defaultness(defaultness);
141        self.word_space("type");
142        self.print_ident(ident);
143        self.print_generic_params(&generics.params);
144        if !bounds.is_empty() {
145            self.word_nbsp(":");
146            self.print_type_bounds(bounds);
147        }
148        self.print_where_clause_parts(where_clauses.before.has_where_token, before_predicates);
149        if let Some(ty) = ty {
150            self.space();
151            self.word_space("=");
152            self.print_type(ty);
153        }
154        self.print_where_clause_parts(where_clauses.after.has_where_token, after_predicates);
155        self.word(";");
156        self.end(ib);
157        self.end(cb);
158    }
159
160    /// Pretty-prints an item.
161    pub(crate) fn print_item(&mut self, item: &ast::Item) {
162        if self.is_sdylib_interface && item.span.is_dummy() {
163            // Do not print prelude for interface files.
164            return;
165        }
166        self.hardbreak_if_not_bol();
167        self.maybe_print_comment(item.span.lo());
168        self.print_outer_attributes(&item.attrs);
169        self.ann.pre(self, AnnNode::Item(item));
170        match &item.kind {
171            ast::ItemKind::ExternCrate(orig_name, ident) => {
172                let (cb, ib) = self.head(visibility_qualified(&item.vis, "extern crate"));
173                if let &Some(orig_name) = orig_name {
174                    self.print_name(orig_name);
175                    self.space();
176                    self.word("as");
177                    self.space();
178                }
179                self.print_ident(*ident);
180                self.word(";");
181                self.end(ib);
182                self.end(cb);
183            }
184            ast::ItemKind::Use(tree) => {
185                self.print_visibility(&item.vis);
186                self.word_nbsp("use");
187                self.print_use_tree(tree);
188                self.word(";");
189            }
190            ast::ItemKind::Static(box StaticItem {
191                ident,
192                ty,
193                safety,
194                mutability: mutbl,
195                expr: body,
196                define_opaque,
197            }) => {
198                self.print_safety(*safety);
199                self.print_item_const(
200                    *ident,
201                    Some(*mutbl),
202                    &ast::Generics::default(),
203                    ty,
204                    body.as_deref(),
205                    &item.vis,
206                    ast::Safety::Default,
207                    ast::Defaultness::Final,
208                    define_opaque.as_deref(),
209                );
210            }
211            ast::ItemKind::Const(box ast::ConstItem {
212                defaultness,
213                ident,
214                generics,
215                ty,
216                expr,
217                define_opaque,
218            }) => {
219                self.print_item_const(
220                    *ident,
221                    None,
222                    generics,
223                    ty,
224                    expr.as_deref(),
225                    &item.vis,
226                    ast::Safety::Default,
227                    *defaultness,
228                    define_opaque.as_deref(),
229                );
230            }
231            ast::ItemKind::Fn(func) => {
232                self.print_fn_full(&item.vis, &item.attrs, &*func);
233            }
234            ast::ItemKind::Mod(safety, ident, mod_kind) => {
235                let (cb, ib) = self.head(Self::to_string(|s| {
236                    s.print_visibility(&item.vis);
237                    s.print_safety(*safety);
238                    s.word("mod");
239                }));
240                self.print_ident(*ident);
241
242                match mod_kind {
243                    ModKind::Loaded(items, ..) => {
244                        self.nbsp();
245                        self.bopen(ib);
246                        self.print_inner_attributes(&item.attrs);
247                        for item in items {
248                            self.print_item(item);
249                        }
250                        let empty = item.attrs.is_empty() && items.is_empty();
251                        self.bclose(item.span, empty, cb);
252                    }
253                    ModKind::Unloaded => {
254                        self.word(";");
255                        self.end(ib);
256                        self.end(cb);
257                    }
258                }
259            }
260            ast::ItemKind::ForeignMod(nmod) => {
261                let (cb, ib) = self.head(Self::to_string(|s| {
262                    s.print_safety(nmod.safety);
263                    s.word("extern");
264                }));
265                if let Some(abi) = nmod.abi {
266                    self.print_token_literal(abi.as_token_lit(), abi.span);
267                    self.nbsp();
268                }
269                self.bopen(ib);
270                self.print_foreign_mod(nmod, &item.attrs);
271                let empty = item.attrs.is_empty() && nmod.items.is_empty();
272                self.bclose(item.span, empty, cb);
273            }
274            ast::ItemKind::GlobalAsm(asm) => {
275                // FIXME: Print `builtin # global_asm` once macro `global_asm` uses `builtin_syntax`.
276                let (cb, ib) = self.head(visibility_qualified(&item.vis, "global_asm!"));
277                self.print_inline_asm(asm);
278                self.word(";");
279                self.end(ib);
280                self.end(cb);
281            }
282            ast::ItemKind::TyAlias(box ast::TyAlias {
283                defaultness,
284                ident,
285                generics,
286                where_clauses,
287                bounds,
288                ty,
289            }) => {
290                self.print_associated_type(
291                    *ident,
292                    generics,
293                    *where_clauses,
294                    bounds,
295                    ty.as_deref(),
296                    &item.vis,
297                    *defaultness,
298                );
299            }
300            ast::ItemKind::Enum(ident, generics, enum_definition) => {
301                self.print_enum_def(enum_definition, generics, *ident, item.span, &item.vis);
302            }
303            ast::ItemKind::Struct(ident, generics, struct_def) => {
304                let (cb, ib) = self.head(visibility_qualified(&item.vis, "struct"));
305                self.print_struct(struct_def, generics, *ident, item.span, true, cb, ib);
306            }
307            ast::ItemKind::Union(ident, generics, struct_def) => {
308                let (cb, ib) = self.head(visibility_qualified(&item.vis, "union"));
309                self.print_struct(struct_def, generics, *ident, item.span, true, cb, ib);
310            }
311            ast::ItemKind::Impl(ast::Impl { generics, of_trait, self_ty, items }) => {
312                let (cb, ib) = self.head("");
313                self.print_visibility(&item.vis);
314
315                let impl_generics = |this: &mut Self| {
316                    this.word("impl");
317
318                    if generics.params.is_empty() {
319                        this.nbsp();
320                    } else {
321                        this.print_generic_params(&generics.params);
322                        this.space();
323                    }
324                };
325
326                if let Some(box of_trait) = of_trait {
327                    let ast::TraitImplHeader {
328                        defaultness,
329                        safety,
330                        constness,
331                        polarity,
332                        ref trait_ref,
333                    } = *of_trait;
334                    self.print_defaultness(defaultness);
335                    self.print_safety(safety);
336                    impl_generics(self);
337                    self.print_constness(constness);
338                    if let ast::ImplPolarity::Negative(_) = polarity {
339                        self.word("!");
340                    }
341                    self.print_trait_ref(trait_ref);
342                    self.space();
343                    self.word_space("for");
344                } else {
345                    impl_generics(self);
346                }
347
348                self.print_type(self_ty);
349                self.print_where_clause(&generics.where_clause);
350
351                self.space();
352                self.bopen(ib);
353                self.print_inner_attributes(&item.attrs);
354                for impl_item in items {
355                    self.print_assoc_item(impl_item);
356                }
357                let empty = item.attrs.is_empty() && items.is_empty();
358                self.bclose(item.span, empty, cb);
359            }
360            ast::ItemKind::Trait(box ast::Trait {
361                constness,
362                safety,
363                is_auto,
364                ident,
365                generics,
366                bounds,
367                items,
368            }) => {
369                let (cb, ib) = self.head("");
370                self.print_visibility(&item.vis);
371                self.print_constness(*constness);
372                self.print_safety(*safety);
373                self.print_is_auto(*is_auto);
374                self.word_nbsp("trait");
375                self.print_ident(*ident);
376                self.print_generic_params(&generics.params);
377                if !bounds.is_empty() {
378                    self.word_nbsp(":");
379                    self.print_type_bounds(bounds);
380                }
381                self.print_where_clause(&generics.where_clause);
382                self.word(" ");
383                self.bopen(ib);
384                self.print_inner_attributes(&item.attrs);
385                for trait_item in items {
386                    self.print_assoc_item(trait_item);
387                }
388                let empty = item.attrs.is_empty() && items.is_empty();
389                self.bclose(item.span, empty, cb);
390            }
391            ast::ItemKind::TraitAlias(ident, generics, bounds) => {
392                let (cb, ib) = self.head(visibility_qualified(&item.vis, "trait"));
393                self.print_ident(*ident);
394                self.print_generic_params(&generics.params);
395                self.nbsp();
396                if !bounds.is_empty() {
397                    self.word_nbsp("=");
398                    self.print_type_bounds(bounds);
399                }
400                self.print_where_clause(&generics.where_clause);
401                self.word(";");
402                self.end(ib);
403                self.end(cb);
404            }
405            ast::ItemKind::MacCall(mac) => {
406                self.print_mac(mac);
407                if mac.args.need_semicolon() {
408                    self.word(";");
409                }
410            }
411            ast::ItemKind::MacroDef(ident, macro_def) => {
412                self.print_mac_def(macro_def, &ident, item.span, |state| {
413                    state.print_visibility(&item.vis)
414                });
415            }
416            ast::ItemKind::Delegation(deleg) => self.print_delegation(
417                &item.attrs,
418                &item.vis,
419                &deleg.qself,
420                &deleg.path,
421                DelegationKind::Single,
422                &deleg.body,
423            ),
424            ast::ItemKind::DelegationMac(deleg) => self.print_delegation(
425                &item.attrs,
426                &item.vis,
427                &deleg.qself,
428                &deleg.prefix,
429                deleg.suffixes.as_ref().map_or(DelegationKind::Glob, |s| DelegationKind::List(s)),
430                &deleg.body,
431            ),
432        }
433        self.ann.post(self, AnnNode::Item(item))
434    }
435
436    fn print_enum_def(
437        &mut self,
438        enum_definition: &ast::EnumDef,
439        generics: &ast::Generics,
440        ident: Ident,
441        span: rustc_span::Span,
442        visibility: &ast::Visibility,
443    ) {
444        let (cb, ib) = self.head(visibility_qualified(visibility, "enum"));
445        self.print_ident(ident);
446        self.print_generic_params(&generics.params);
447        self.print_where_clause(&generics.where_clause);
448        self.space();
449        self.bopen(ib);
450        for v in enum_definition.variants.iter() {
451            self.space_if_not_bol();
452            self.maybe_print_comment(v.span.lo());
453            self.print_outer_attributes(&v.attrs);
454            let ib = self.ibox(0);
455            self.print_variant(v);
456            self.word(",");
457            self.end(ib);
458            self.maybe_print_trailing_comment(v.span, None);
459        }
460        let empty = enum_definition.variants.is_empty();
461        self.bclose(span, empty, cb)
462    }
463
464    pub(crate) fn print_visibility(&mut self, vis: &ast::Visibility) {
465        match &vis.kind {
466            ast::VisibilityKind::Public => self.word_nbsp("pub"),
467            ast::VisibilityKind::Restricted { path, shorthand, .. } => {
468                let path = Self::to_string(|s| s.print_path(path, false, 0));
469                if *shorthand && (path == "crate" || path == "self" || path == "super") {
470                    self.word_nbsp(format!("pub({path})"))
471                } else {
472                    self.word_nbsp(format!("pub(in {path})"))
473                }
474            }
475            ast::VisibilityKind::Inherited => {}
476        }
477    }
478
479    fn print_defaultness(&mut self, defaultness: ast::Defaultness) {
480        if let ast::Defaultness::Default(_) = defaultness {
481            self.word_nbsp("default");
482        }
483    }
484
485    fn print_struct(
486        &mut self,
487        struct_def: &ast::VariantData,
488        generics: &ast::Generics,
489        ident: Ident,
490        span: rustc_span::Span,
491        print_finalizer: bool,
492        cb: BoxMarker,
493        ib: BoxMarker,
494    ) {
495        self.print_ident(ident);
496        self.print_generic_params(&generics.params);
497        match &struct_def {
498            ast::VariantData::Tuple(..) | ast::VariantData::Unit(..) => {
499                if let ast::VariantData::Tuple(..) = struct_def {
500                    self.popen();
501                    self.commasep(Inconsistent, struct_def.fields(), |s, field| {
502                        s.maybe_print_comment(field.span.lo());
503                        s.print_outer_attributes(&field.attrs);
504                        s.print_visibility(&field.vis);
505                        s.print_type(&field.ty)
506                    });
507                    self.pclose();
508                }
509                self.print_where_clause(&generics.where_clause);
510                if print_finalizer {
511                    self.word(";");
512                }
513                self.end(ib);
514                self.end(cb);
515            }
516            ast::VariantData::Struct { fields, .. } => {
517                self.print_where_clause(&generics.where_clause);
518                self.nbsp();
519                self.bopen(ib);
520
521                let empty = fields.is_empty();
522                if !empty {
523                    self.hardbreak_if_not_bol();
524
525                    for field in fields {
526                        self.hardbreak_if_not_bol();
527                        self.maybe_print_comment(field.span.lo());
528                        self.print_outer_attributes(&field.attrs);
529                        self.print_visibility(&field.vis);
530                        self.print_ident(field.ident.unwrap());
531                        self.word_nbsp(":");
532                        self.print_type(&field.ty);
533                        self.word(",");
534                    }
535                }
536
537                self.bclose(span, empty, cb);
538            }
539        }
540    }
541
542    pub(crate) fn print_variant(&mut self, v: &ast::Variant) {
543        let (cb, ib) = self.head("");
544        self.print_visibility(&v.vis);
545        let generics = ast::Generics::default();
546        self.print_struct(&v.data, &generics, v.ident, v.span, false, cb, ib);
547        if let Some(d) = &v.disr_expr {
548            self.space();
549            self.word_space("=");
550            self.print_expr(&d.value, FixupContext::default())
551        }
552    }
553
554    pub(crate) fn print_assoc_item(&mut self, item: &ast::AssocItem) {
555        let ast::Item { id, span, ref attrs, ref kind, ref vis, tokens: _ } = *item;
556        self.ann.pre(self, AnnNode::SubItem(id));
557        self.hardbreak_if_not_bol();
558        self.maybe_print_comment(span.lo());
559        self.print_outer_attributes(attrs);
560        match kind {
561            ast::AssocItemKind::Fn(func) => {
562                self.print_fn_full(vis, attrs, &*func);
563            }
564            ast::AssocItemKind::Const(box ast::ConstItem {
565                defaultness,
566                ident,
567                generics,
568                ty,
569                expr,
570                define_opaque,
571            }) => {
572                self.print_item_const(
573                    *ident,
574                    None,
575                    generics,
576                    ty,
577                    expr.as_deref(),
578                    vis,
579                    ast::Safety::Default,
580                    *defaultness,
581                    define_opaque.as_deref(),
582                );
583            }
584            ast::AssocItemKind::Type(box ast::TyAlias {
585                defaultness,
586                ident,
587                generics,
588                where_clauses,
589                bounds,
590                ty,
591            }) => {
592                self.print_associated_type(
593                    *ident,
594                    generics,
595                    *where_clauses,
596                    bounds,
597                    ty.as_deref(),
598                    vis,
599                    *defaultness,
600                );
601            }
602            ast::AssocItemKind::MacCall(m) => {
603                self.print_mac(m);
604                if m.args.need_semicolon() {
605                    self.word(";");
606                }
607            }
608            ast::AssocItemKind::Delegation(deleg) => self.print_delegation(
609                &item.attrs,
610                vis,
611                &deleg.qself,
612                &deleg.path,
613                DelegationKind::Single,
614                &deleg.body,
615            ),
616            ast::AssocItemKind::DelegationMac(deleg) => self.print_delegation(
617                &item.attrs,
618                vis,
619                &deleg.qself,
620                &deleg.prefix,
621                deleg.suffixes.as_ref().map_or(DelegationKind::Glob, |s| DelegationKind::List(s)),
622                &deleg.body,
623            ),
624        }
625        self.ann.post(self, AnnNode::SubItem(id))
626    }
627
628    fn print_delegation(
629        &mut self,
630        attrs: &[ast::Attribute],
631        vis: &ast::Visibility,
632        qself: &Option<Box<ast::QSelf>>,
633        path: &ast::Path,
634        kind: DelegationKind<'_>,
635        body: &Option<Box<ast::Block>>,
636    ) {
637        let body_cb_ib = body.as_ref().map(|body| (body, self.head("")));
638        self.print_visibility(vis);
639        self.word_nbsp("reuse");
640
641        if let Some(qself) = qself {
642            self.print_qpath(path, qself, false);
643        } else {
644            self.print_path(path, false, 0);
645        }
646        match kind {
647            DelegationKind::Single => {}
648            DelegationKind::List(suffixes) => {
649                self.word("::");
650                self.word("{");
651                for (i, (ident, rename)) in suffixes.iter().enumerate() {
652                    self.print_ident(*ident);
653                    if let Some(rename) = rename {
654                        self.nbsp();
655                        self.word_nbsp("as");
656                        self.print_ident(*rename);
657                    }
658                    if i != suffixes.len() - 1 {
659                        self.word_space(",");
660                    }
661                }
662                self.word("}");
663            }
664            DelegationKind::Glob => {
665                self.word("::");
666                self.word("*");
667            }
668        }
669        if let Some((body, (cb, ib))) = body_cb_ib {
670            self.nbsp();
671            self.print_block_with_attrs(body, attrs, cb, ib);
672        } else {
673            self.word(";");
674        }
675    }
676
677    fn print_fn_full(&mut self, vis: &ast::Visibility, attrs: &[ast::Attribute], func: &ast::Fn) {
678        let ast::Fn { defaultness, ident, generics, sig, contract, body, define_opaque } = func;
679
680        self.print_define_opaques(define_opaque.as_deref());
681
682        let body_cb_ib = body.as_ref().map(|body| (body, self.head("")));
683
684        self.print_visibility(vis);
685        self.print_defaultness(*defaultness);
686        self.print_fn(&sig.decl, sig.header, Some(*ident), generics);
687        if let Some(contract) = &contract {
688            self.nbsp();
689            self.print_contract(contract);
690        }
691        if let Some((body, (cb, ib))) = body_cb_ib {
692            if self.is_sdylib_interface {
693                self.word(";");
694                self.end(ib); // end inner head-block
695                self.end(cb); // end outer head-block
696                return;
697            }
698
699            self.nbsp();
700            self.print_block_with_attrs(body, attrs, cb, ib);
701        } else {
702            self.word(";");
703        }
704    }
705
706    fn print_define_opaques(&mut self, define_opaque: Option<&[(ast::NodeId, ast::Path)]>) {
707        if let Some(define_opaque) = define_opaque {
708            self.word("#[define_opaque(");
709            for (i, (_, path)) in define_opaque.iter().enumerate() {
710                if i != 0 {
711                    self.word_space(",");
712                }
713
714                self.print_path(path, false, 0);
715            }
716            self.word(")]");
717        }
718        self.hardbreak_if_not_bol();
719    }
720
721    fn print_contract(&mut self, contract: &ast::FnContract) {
722        if let Some(pred) = &contract.requires {
723            self.word("rustc_requires");
724            self.popen();
725            self.print_expr(pred, FixupContext::default());
726            self.pclose();
727        }
728        if let Some(pred) = &contract.ensures {
729            self.word("rustc_ensures");
730            self.popen();
731            self.print_expr(pred, FixupContext::default());
732            self.pclose();
733        }
734    }
735
736    pub(crate) fn print_fn(
737        &mut self,
738        decl: &ast::FnDecl,
739        header: ast::FnHeader,
740        ident: Option<Ident>,
741        generics: &ast::Generics,
742    ) {
743        self.print_fn_header_info(header);
744        if let Some(ident) = ident {
745            self.nbsp();
746            self.print_ident(ident);
747        }
748        self.print_generic_params(&generics.params);
749        self.print_fn_params_and_ret(decl, false);
750        self.print_where_clause(&generics.where_clause);
751    }
752
753    pub(crate) fn print_fn_params_and_ret(&mut self, decl: &ast::FnDecl, is_closure: bool) {
754        let (open, close) = if is_closure { ("|", "|") } else { ("(", ")") };
755        self.word(open);
756        self.commasep(Inconsistent, &decl.inputs, |s, param| s.print_param(param, is_closure));
757        self.word(close);
758        self.print_fn_ret_ty(&decl.output)
759    }
760
761    fn print_where_clause(&mut self, where_clause: &ast::WhereClause) {
762        self.print_where_clause_parts(where_clause.has_where_token, &where_clause.predicates);
763    }
764
765    fn print_where_clause_parts(
766        &mut self,
767        has_where_token: bool,
768        predicates: &[ast::WherePredicate],
769    ) {
770        if predicates.is_empty() && !has_where_token {
771            return;
772        }
773
774        self.space();
775        self.word_space("where");
776
777        for (i, predicate) in predicates.iter().enumerate() {
778            if i != 0 {
779                self.word_space(",");
780            }
781
782            self.print_where_predicate(predicate);
783        }
784    }
785
786    pub fn print_where_predicate(&mut self, predicate: &ast::WherePredicate) {
787        let ast::WherePredicate { attrs, kind, id: _, span: _, is_placeholder: _ } = predicate;
788        self.print_outer_attributes(attrs);
789        match kind {
790            ast::WherePredicateKind::BoundPredicate(where_bound_predicate) => {
791                self.print_where_bound_predicate(where_bound_predicate);
792            }
793            ast::WherePredicateKind::RegionPredicate(ast::WhereRegionPredicate {
794                lifetime,
795                bounds,
796                ..
797            }) => {
798                self.print_lifetime(*lifetime);
799                self.word(":");
800                if !bounds.is_empty() {
801                    self.nbsp();
802                    self.print_lifetime_bounds(bounds);
803                }
804            }
805            ast::WherePredicateKind::EqPredicate(ast::WhereEqPredicate {
806                lhs_ty, rhs_ty, ..
807            }) => {
808                self.print_type(lhs_ty);
809                self.space();
810                self.word_space("=");
811                self.print_type(rhs_ty);
812            }
813        }
814    }
815
816    pub(crate) fn print_where_bound_predicate(
817        &mut self,
818        where_bound_predicate: &ast::WhereBoundPredicate,
819    ) {
820        self.print_formal_generic_params(&where_bound_predicate.bound_generic_params);
821        self.print_type(&where_bound_predicate.bounded_ty);
822        self.word(":");
823        if !where_bound_predicate.bounds.is_empty() {
824            self.nbsp();
825            self.print_type_bounds(&where_bound_predicate.bounds);
826        }
827    }
828
829    fn print_use_tree(&mut self, tree: &ast::UseTree) {
830        match &tree.kind {
831            ast::UseTreeKind::Simple(rename) => {
832                self.print_path(&tree.prefix, false, 0);
833                if let &Some(rename) = rename {
834                    self.nbsp();
835                    self.word_nbsp("as");
836                    self.print_ident(rename);
837                }
838            }
839            ast::UseTreeKind::Glob => {
840                if !tree.prefix.segments.is_empty() {
841                    self.print_path(&tree.prefix, false, 0);
842                    self.word("::");
843                }
844                self.word("*");
845            }
846            ast::UseTreeKind::Nested { items, .. } => {
847                if !tree.prefix.segments.is_empty() {
848                    self.print_path(&tree.prefix, false, 0);
849                    self.word("::");
850                }
851                if items.is_empty() {
852                    self.word("{}");
853                } else if let [(item, _)] = items.as_slice() {
854                    self.print_use_tree(item);
855                } else {
856                    let cb = self.cbox(INDENT_UNIT);
857                    self.word("{");
858                    self.zerobreak();
859                    let ib = self.ibox(0);
860                    for (pos, use_tree) in items.iter().with_position() {
861                        let is_last = matches!(pos, Position::Last | Position::Only);
862                        self.print_use_tree(&use_tree.0);
863                        if !is_last {
864                            self.word(",");
865                            if let ast::UseTreeKind::Nested { .. } = use_tree.0.kind {
866                                self.hardbreak();
867                            } else {
868                                self.space();
869                            }
870                        }
871                    }
872                    self.end(ib);
873                    self.trailing_comma();
874                    self.offset(-INDENT_UNIT);
875                    self.word("}");
876                    self.end(cb);
877                }
878            }
879        }
880    }
881}
rustc_ast_pretty/pprust/state/item.rs

rustc_ast_pretty/pprust/state/
item.rs
