prettyplease/
data.rs

1use crate::algorithm::Printer;
2use crate::fixup::FixupContext;
3use crate::iter::IterDelimited;
4use crate::path::PathKind;
5use crate::INDENT;
6use syn::{Field, Fields, FieldsUnnamed, Variant, VisRestricted, Visibility};
7
8impl Printer {
9    pub fn variant(&mut self, variant: &Variant) {
10        self.outer_attrs(&variant.attrs);
11        self.ident(&variant.ident);
12        match &variant.fields {
13            Fields::Named(fields) => {
14                self.nbsp();
15                self.word("{");
16                self.cbox(INDENT);
17                self.space();
18                for field in fields.named.iter().delimited() {
19                    self.field(&field);
20                    self.trailing_comma_or_space(field.is_last);
21                }
22                self.offset(-INDENT);
23                self.end();
24                self.word("}");
25            }
26            Fields::Unnamed(fields) => {
27                self.cbox(INDENT);
28                self.fields_unnamed(fields);
29                self.end();
30            }
31            Fields::Unit => {}
32        }
33        if let Some((_eq_token, discriminant)) = &variant.discriminant {
34            self.word(" = ");
35            self.expr(discriminant, FixupContext::NONE);
36        }
37    }
38
39    pub fn fields_unnamed(&mut self, fields: &FieldsUnnamed) {
40        self.word("(");
41        self.zerobreak();
42        for field in fields.unnamed.iter().delimited() {
43            self.field(&field);
44            self.trailing_comma(field.is_last);
45        }
46        self.offset(-INDENT);
47        self.word(")");
48    }
49
50    pub fn field(&mut self, field: &Field) {
51        self.outer_attrs(&field.attrs);
52        self.visibility(&field.vis);
53        if let Some(ident) = &field.ident {
54            self.ident(ident);
55            self.word(": ");
56        }
57        self.ty(&field.ty);
58    }
59
60    pub fn visibility(&mut self, vis: &Visibility) {
61        match vis {
62            Visibility::Public(_) => self.word("pub "),
63            Visibility::Restricted(vis) => self.vis_restricted(vis),
64            Visibility::Inherited => {}
65        }
66    }
67
68    fn vis_restricted(&mut self, vis: &VisRestricted) {
69        self.word("pub(");
70        let omit_in = vis.path.get_ident().map_or(false, |ident| {
71            matches!(ident.to_string().as_str(), "self" | "super" | "crate")
72        });
73        if !omit_in {
74            self.word("in ");
75        }
76        self.path(&vis.path, PathKind::Simple);
77        self.word(") ");
78    }
79}