| use super::*; |
| use crate::punctuated::Punctuated; |
| |
| ast_struct! { |
| /// An enum variant. |
| /// |
| /// *This type is available only if Syn is built with the `"derive"` or `"full"` |
| /// feature.* |
| #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))] |
| pub struct Variant { |
| /// Attributes tagged on the variant. |
| pub attrs: Vec<Attribute>, |
| |
| /// Name of the variant. |
| pub ident: Ident, |
| |
| /// Content stored in the variant. |
| pub fields: Fields, |
| |
| /// Explicit discriminant: `Variant = 1` |
| pub discriminant: Option<(Token![=], Expr)>, |
| } |
| } |
| |
| ast_enum_of_structs! { |
| /// Data stored within an enum variant or struct. |
| /// |
| /// *This type is available only if Syn is built with the `"derive"` or `"full"` |
| /// feature.* |
| /// |
| /// # Syntax tree enum |
| /// |
| /// This type is a [syntax tree enum]. |
| /// |
| /// [syntax tree enum]: Expr#syntax-tree-enums |
| #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))] |
| pub enum Fields { |
| /// Named fields of a struct or struct variant such as `Point { x: f64, |
| /// y: f64 }`. |
| Named(FieldsNamed), |
| |
| /// Unnamed fields of a tuple struct or tuple variant such as `Some(T)`. |
| Unnamed(FieldsUnnamed), |
| |
| /// Unit struct or unit variant such as `None`. |
| Unit, |
| } |
| } |
| |
| ast_struct! { |
| /// Named fields of a struct or struct variant such as `Point { x: f64, |
| /// y: f64 }`. |
| /// |
| /// *This type is available only if Syn is built with the `"derive"` or |
| /// `"full"` feature.* |
| #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))] |
| pub struct FieldsNamed { |
| pub brace_token: token::Brace, |
| pub named: Punctuated<Field, Token![,]>, |
| } |
| } |
| |
| ast_struct! { |
| /// Unnamed fields of a tuple struct or tuple variant such as `Some(T)`. |
| /// |
| /// *This type is available only if Syn is built with the `"derive"` or |
| /// `"full"` feature.* |
| #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))] |
| pub struct FieldsUnnamed { |
| pub paren_token: token::Paren, |
| pub unnamed: Punctuated<Field, Token![,]>, |
| } |
| } |
| |
| impl Fields { |
| /// Get an iterator over the borrowed [`Field`] items in this object. This |
| /// iterator can be used to iterate over a named or unnamed struct or |
| /// variant's fields uniformly. |
| pub fn iter(&self) -> punctuated::Iter<Field> { |
| match self { |
| Fields::Unit => crate::punctuated::empty_punctuated_iter(), |
| Fields::Named(f) => f.named.iter(), |
| Fields::Unnamed(f) => f.unnamed.iter(), |
| } |
| } |
| |
| /// Get an iterator over the mutably borrowed [`Field`] items in this |
| /// object. This iterator can be used to iterate over a named or unnamed |
| /// struct or variant's fields uniformly. |
| pub fn iter_mut(&mut self) -> punctuated::IterMut<Field> { |
| match self { |
| Fields::Unit => crate::punctuated::empty_punctuated_iter_mut(), |
| Fields::Named(f) => f.named.iter_mut(), |
| Fields::Unnamed(f) => f.unnamed.iter_mut(), |
| } |
| } |
| |
| /// Returns the number of fields. |
| pub fn len(&self) -> usize { |
| match self { |
| Fields::Unit => 0, |
| Fields::Named(f) => f.named.len(), |
| Fields::Unnamed(f) => f.unnamed.len(), |
| } |
| } |
| |
| /// Returns `true` if there are zero fields. |
| pub fn is_empty(&self) -> bool { |
| match self { |
| Fields::Unit => true, |
| Fields::Named(f) => f.named.is_empty(), |
| Fields::Unnamed(f) => f.unnamed.is_empty(), |
| } |
| } |
| } |
| |
| impl IntoIterator for Fields { |
| type Item = Field; |
| type IntoIter = punctuated::IntoIter<Field>; |
| |
| fn into_iter(self) -> Self::IntoIter { |
| match self { |
| Fields::Unit => Punctuated::<Field, ()>::new().into_iter(), |
| Fields::Named(f) => f.named.into_iter(), |
| Fields::Unnamed(f) => f.unnamed.into_iter(), |
| } |
| } |
| } |
| |
| impl<'a> IntoIterator for &'a Fields { |
| type Item = &'a Field; |
| type IntoIter = punctuated::Iter<'a, Field>; |
| |
| fn into_iter(self) -> Self::IntoIter { |
| self.iter() |
| } |
| } |
| |
| impl<'a> IntoIterator for &'a mut Fields { |
| type Item = &'a mut Field; |
| type IntoIter = punctuated::IterMut<'a, Field>; |
| |
| fn into_iter(self) -> Self::IntoIter { |
| self.iter_mut() |
| } |
| } |
| |
| ast_struct! { |
| /// A field of a struct or enum variant. |
| /// |
| /// *This type is available only if Syn is built with the `"derive"` or `"full"` |
| /// feature.* |
| #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))] |
| pub struct Field { |
| /// Attributes tagged on the field. |
| pub attrs: Vec<Attribute>, |
| |
| /// Visibility of the field. |
| pub vis: Visibility, |
| |
| /// Name of the field, if any. |
| /// |
| /// Fields of tuple structs have no names. |
| pub ident: Option<Ident>, |
| |
| pub colon_token: Option<Token![:]>, |
| |
| /// Type of the field. |
| pub ty: Type, |
| } |
| } |
| |
| ast_enum_of_structs! { |
| /// The visibility level of an item: inherited or `pub` or |
| /// `pub(restricted)`. |
| /// |
| /// *This type is available only if Syn is built with the `"derive"` or `"full"` |
| /// feature.* |
| /// |
| /// # Syntax tree enum |
| /// |
| /// This type is a [syntax tree enum]. |
| /// |
| /// [syntax tree enum]: Expr#syntax-tree-enums |
| #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))] |
| pub enum Visibility { |
| /// A public visibility level: `pub`. |
| Public(VisPublic), |
| |
| /// A crate-level visibility: `crate`. |
| Crate(VisCrate), |
| |
| /// A visibility level restricted to some path: `pub(self)` or |
| /// `pub(super)` or `pub(crate)` or `pub(in some::module)`. |
| Restricted(VisRestricted), |
| |
| /// An inherited visibility, which usually means private. |
| Inherited, |
| } |
| } |
| |
| ast_struct! { |
| /// A public visibility level: `pub`. |
| /// |
| /// *This type is available only if Syn is built with the `"derive"` or |
| /// `"full"` feature.* |
| #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))] |
| pub struct VisPublic { |
| pub pub_token: Token![pub], |
| } |
| } |
| |
| ast_struct! { |
| /// A crate-level visibility: `crate`. |
| /// |
| /// *This type is available only if Syn is built with the `"derive"` or |
| /// `"full"` feature.* |
| #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))] |
| pub struct VisCrate { |
| pub crate_token: Token![crate], |
| } |
| } |
| |
| ast_struct! { |
| /// A visibility level restricted to some path: `pub(self)` or |
| /// `pub(super)` or `pub(crate)` or `pub(in some::module)`. |
| /// |
| /// *This type is available only if Syn is built with the `"derive"` or |
| /// `"full"` feature.* |
| #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))] |
| pub struct VisRestricted { |
| pub pub_token: Token![pub], |
| pub paren_token: token::Paren, |
| pub in_token: Option<Token![in]>, |
| pub path: Box<Path>, |
| } |
| } |
| |
| #[cfg(feature = "parsing")] |
| pub mod parsing { |
| use super::*; |
| use crate::ext::IdentExt; |
| use crate::parse::discouraged::Speculative; |
| use crate::parse::{Parse, ParseStream, Result}; |
| |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))] |
| impl Parse for Variant { |
| fn parse(input: ParseStream) -> Result<Self> { |
| let attrs = input.call(Attribute::parse_outer)?; |
| let _visibility: Visibility = input.parse()?; |
| let ident: Ident = input.parse()?; |
| let fields = if input.peek(token::Brace) { |
| Fields::Named(input.parse()?) |
| } else if input.peek(token::Paren) { |
| Fields::Unnamed(input.parse()?) |
| } else { |
| Fields::Unit |
| }; |
| let discriminant = if input.peek(Token![=]) { |
| let eq_token: Token![=] = input.parse()?; |
| let discriminant: Expr = input.parse()?; |
| Some((eq_token, discriminant)) |
| } else { |
| None |
| }; |
| Ok(Variant { |
| attrs, |
| ident, |
| fields, |
| discriminant, |
| }) |
| } |
| } |
| |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))] |
| impl Parse for FieldsNamed { |
| fn parse(input: ParseStream) -> Result<Self> { |
| let content; |
| Ok(FieldsNamed { |
| brace_token: braced!(content in input), |
| named: content.parse_terminated(Field::parse_named)?, |
| }) |
| } |
| } |
| |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))] |
| impl Parse for FieldsUnnamed { |
| fn parse(input: ParseStream) -> Result<Self> { |
| let content; |
| Ok(FieldsUnnamed { |
| paren_token: parenthesized!(content in input), |
| unnamed: content.parse_terminated(Field::parse_unnamed)?, |
| }) |
| } |
| } |
| |
| impl Field { |
| /// Parses a named (braced struct) field. |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))] |
| pub fn parse_named(input: ParseStream) -> Result<Self> { |
| Ok(Field { |
| attrs: input.call(Attribute::parse_outer)?, |
| vis: input.parse()?, |
| ident: Some(if input.peek(Token![_]) { |
| input.call(Ident::parse_any) |
| } else { |
| input.parse() |
| }?), |
| colon_token: Some(input.parse()?), |
| ty: input.parse()?, |
| }) |
| } |
| |
| /// Parses an unnamed (tuple struct) field. |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))] |
| pub fn parse_unnamed(input: ParseStream) -> Result<Self> { |
| Ok(Field { |
| attrs: input.call(Attribute::parse_outer)?, |
| vis: input.parse()?, |
| ident: None, |
| colon_token: None, |
| ty: input.parse()?, |
| }) |
| } |
| } |
| |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))] |
| impl Parse for Visibility { |
| fn parse(input: ParseStream) -> Result<Self> { |
| // Recognize an empty None-delimited group, as produced by a $:vis |
| // matcher that matched no tokens. |
| if input.peek(token::Group) { |
| let ahead = input.fork(); |
| let group = crate::group::parse_group(&ahead)?; |
| if group.content.is_empty() { |
| input.advance_to(&ahead); |
| return Ok(Visibility::Inherited); |
| } |
| } |
| |
| if input.peek(Token![pub]) { |
| Self::parse_pub(input) |
| } else if input.peek(Token![crate]) { |
| Self::parse_crate(input) |
| } else { |
| Ok(Visibility::Inherited) |
| } |
| } |
| } |
| |
| impl Visibility { |
| fn parse_pub(input: ParseStream) -> Result<Self> { |
| let pub_token = input.parse::<Token![pub]>()?; |
| |
| if input.peek(token::Paren) { |
| let ahead = input.fork(); |
| |
| let content; |
| let paren_token = parenthesized!(content in ahead); |
| if content.peek(Token![crate]) |
| || content.peek(Token![self]) |
| || content.peek(Token![super]) |
| { |
| let path = content.call(Ident::parse_any)?; |
| |
| // Ensure there are no additional tokens within `content`. |
| // Without explicitly checking, we may misinterpret a tuple |
| // field as a restricted visibility, causing a parse error. |
| // e.g. `pub (crate::A, crate::B)` (Issue #720). |
| if content.is_empty() { |
| input.advance_to(&ahead); |
| return Ok(Visibility::Restricted(VisRestricted { |
| pub_token, |
| paren_token, |
| in_token: None, |
| path: Box::new(Path::from(path)), |
| })); |
| } |
| } else if content.peek(Token![in]) { |
| let in_token: Token![in] = content.parse()?; |
| let path = content.call(Path::parse_mod_style)?; |
| |
| input.advance_to(&ahead); |
| return Ok(Visibility::Restricted(VisRestricted { |
| pub_token, |
| paren_token, |
| in_token: Some(in_token), |
| path: Box::new(path), |
| })); |
| } |
| } |
| |
| Ok(Visibility::Public(VisPublic { pub_token })) |
| } |
| |
| fn parse_crate(input: ParseStream) -> Result<Self> { |
| if input.peek2(Token![::]) { |
| Ok(Visibility::Inherited) |
| } else { |
| Ok(Visibility::Crate(VisCrate { |
| crate_token: input.parse()?, |
| })) |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| pub(crate) fn is_some(&self) -> bool { |
| match self { |
| Visibility::Inherited => false, |
| _ => true, |
| } |
| } |
| } |
| } |
| |
| #[cfg(feature = "printing")] |
| mod printing { |
| use super::*; |
| use crate::print::TokensOrDefault; |
| use proc_macro2::TokenStream; |
| use quote::{ToTokens, TokenStreamExt}; |
| |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))] |
| impl ToTokens for Variant { |
| fn to_tokens(&self, tokens: &mut TokenStream) { |
| tokens.append_all(&self.attrs); |
| self.ident.to_tokens(tokens); |
| self.fields.to_tokens(tokens); |
| if let Some((eq_token, disc)) = &self.discriminant { |
| eq_token.to_tokens(tokens); |
| disc.to_tokens(tokens); |
| } |
| } |
| } |
| |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))] |
| impl ToTokens for FieldsNamed { |
| fn to_tokens(&self, tokens: &mut TokenStream) { |
| self.brace_token.surround(tokens, |tokens| { |
| self.named.to_tokens(tokens); |
| }); |
| } |
| } |
| |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))] |
| impl ToTokens for FieldsUnnamed { |
| fn to_tokens(&self, tokens: &mut TokenStream) { |
| self.paren_token.surround(tokens, |tokens| { |
| self.unnamed.to_tokens(tokens); |
| }); |
| } |
| } |
| |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))] |
| impl ToTokens for Field { |
| fn to_tokens(&self, tokens: &mut TokenStream) { |
| tokens.append_all(&self.attrs); |
| self.vis.to_tokens(tokens); |
| if let Some(ident) = &self.ident { |
| ident.to_tokens(tokens); |
| TokensOrDefault(&self.colon_token).to_tokens(tokens); |
| } |
| self.ty.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))] |
| impl ToTokens for VisPublic { |
| fn to_tokens(&self, tokens: &mut TokenStream) { |
| self.pub_token.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))] |
| impl ToTokens for VisCrate { |
| fn to_tokens(&self, tokens: &mut TokenStream) { |
| self.crate_token.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))] |
| impl ToTokens for VisRestricted { |
| fn to_tokens(&self, tokens: &mut TokenStream) { |
| self.pub_token.to_tokens(tokens); |
| self.paren_token.surround(tokens, |tokens| { |
| // TODO: If we have a path which is not "self" or "super" or |
| // "crate", automatically add the "in" token. |
| self.in_token.to_tokens(tokens); |
| self.path.to_tokens(tokens); |
| }); |
| } |
| } |
| } |
