syn/
restriction.rs

1use crate::path::Path;
2use crate::token;
3
4ast_enum! {
5    /// The visibility level of an item: inherited or `pub` or
6    /// `pub(restricted)`.
7    ///
8    /// # Syntax tree enum
9    ///
10    /// This type is a [syntax tree enum].
11    ///
12    /// [syntax tree enum]: crate::expr::Expr#syntax-tree-enums
13    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
14    pub enum Visibility {
15        /// A public visibility level: `pub`.
16        Public(Token![pub]),
17
18        /// A visibility level restricted to some path: `pub(self)` or
19        /// `pub(super)` or `pub(crate)` or `pub(in some::module)`.
20        Restricted(VisRestricted),
21
22        /// An inherited visibility, which usually means private.
23        Inherited,
24    }
25}
26
27ast_struct! {
28    /// A visibility level restricted to some path: `pub(self)` or
29    /// `pub(super)` or `pub(crate)` or `pub(in some::module)`.
30    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
31    pub struct VisRestricted {
32        pub pub_token: Token![pub],
33        pub paren_token: token::Paren,
34        pub in_token: Option<Token![in]>,
35        pub path: Box<Path>,
36    }
37}
38
39ast_enum! {
40    /// Unused, but reserved for RFC 3323 restrictions.
41    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
42    #[non_exhaustive]
43    pub enum FieldMutability {
44        None,
45
46        // TODO: https://rust-lang.github.io/rfcs/3323-restrictions.html
47        //
48        // FieldMutability::Restricted(MutRestricted)
49        //
50        // pub struct MutRestricted {
51        //     pub mut_token: Token![mut],
52        //     pub paren_token: token::Paren,
53        //     pub in_token: Option<Token![in]>,
54        //     pub path: Box<Path>,
55        // }
56    }
57}
58
59#[cfg(feature = "parsing")]
60pub(crate) mod parsing {
61    use crate::error::Result;
62    use crate::ext::IdentExt as _;
63    use crate::ident::Ident;
64    use crate::parse::discouraged::Speculative as _;
65    use crate::parse::{Parse, ParseStream};
66    use crate::path::Path;
67    use crate::restriction::{VisRestricted, Visibility};
68    use crate::token;
69
70    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
71    impl Parse for Visibility {
72        fn parse(input: ParseStream) -> Result<Self> {
73            // Recognize an empty None-delimited group, as produced by a $:vis
74            // matcher that matched no tokens.
75            if input.peek(token::Group) {
76                let ahead = input.fork();
77                let group = crate::group::parse_group(&ahead)?;
78                if group.content.is_empty() {
79                    input.advance_to(&ahead);
80                    return Ok(Visibility::Inherited);
81                }
82            }
83
84            if input.peek(Token![pub]) {
85                Self::parse_pub(input)
86            } else {
87                Ok(Visibility::Inherited)
88            }
89        }
90    }
91
92    impl Visibility {
93        fn parse_pub(input: ParseStream) -> Result<Self> {
94            let pub_token = input.parse::<Token![pub]>()?;
95
96            if input.peek(token::Paren) {
97                let ahead = input.fork();
98
99                let content;
100                let paren_token = parenthesized!(content in ahead);
101                if content.peek(Token![crate])
102                    || content.peek(Token![self])
103                    || content.peek(Token![super])
104                {
105                    let path = content.call(Ident::parse_any)?;
106
107                    // Ensure there are no additional tokens within `content`.
108                    // Without explicitly checking, we may misinterpret a tuple
109                    // field as a restricted visibility, causing a parse error.
110                    // e.g. `pub (crate::A, crate::B)` (Issue #720).
111                    if content.is_empty() {
112                        input.advance_to(&ahead);
113                        return Ok(Visibility::Restricted(VisRestricted {
114                            pub_token,
115                            paren_token,
116                            in_token: None,
117                            path: Box::new(Path::from(path)),
118                        }));
119                    }
120                } else if content.peek(Token![in]) {
121                    let in_token: Token![in] = content.parse()?;
122                    let path = content.call(Path::parse_mod_style)?;
123
124                    input.advance_to(&ahead);
125                    return Ok(Visibility::Restricted(VisRestricted {
126                        pub_token,
127                        paren_token,
128                        in_token: Some(in_token),
129                        path: Box::new(path),
130                    }));
131                }
132            }
133
134            Ok(Visibility::Public(pub_token))
135        }
136
137        #[cfg(feature = "full")]
138        pub(crate) fn is_some(&self) -> bool {
139            match self {
140                Visibility::Inherited => false,
141                _ => true,
142            }
143        }
144    }
145}
146
147#[cfg(feature = "printing")]
148mod printing {
149    use crate::path;
150    use crate::path::printing::PathStyle;
151    use crate::restriction::{VisRestricted, Visibility};
152    use proc_macro2::TokenStream;
153    use quote::ToTokens;
154
155    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
156    impl ToTokens for Visibility {
157        fn to_tokens(&self, tokens: &mut TokenStream) {
158            match self {
159                Visibility::Public(pub_token) => pub_token.to_tokens(tokens),
160                Visibility::Restricted(vis_restricted) => vis_restricted.to_tokens(tokens),
161                Visibility::Inherited => {}
162            }
163        }
164    }
165
166    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
167    impl ToTokens for VisRestricted {
168        fn to_tokens(&self, tokens: &mut TokenStream) {
169            self.pub_token.to_tokens(tokens);
170            self.paren_token.surround(tokens, |tokens| {
171                // TODO: If we have a path which is not "self" or "super" or
172                // "crate", automatically add the "in" token.
173                self.in_token.to_tokens(tokens);
174                path::printing::print_path(tokens, &self.path, PathStyle::Mod);
175            });
176        }
177    }
178}
syn/restriction.rs

syn/
restriction.rs
