third_party/rust/serde_repr/src/parse.rs

   1 use proc_macro2::{Span, TokenTree};
   2 use syn::parse::{Error, Parse, ParseStream, Result};
   3 use syn::{token, Attribute, Data, DeriveInput, Expr, Fields, Ident, Meta, Token};
   4
   5 pub struct Input {
   6     pub ident: Ident,
   7     pub repr: Ident,
   8     pub variants: Vec<Variant>,
   9     pub default_variant: Option<Variant>,
  10 }
  11
  12 #[derive(Clone)]
  13 pub struct Variant {
  14     pub ident: Ident,
  15     pub attrs: VariantAttrs,
  16 }
  17
  18 #[derive(Clone)]
  19 pub struct VariantAttrs {
  20     pub is_default: bool,
  21 }
  22
  23 fn parse_serde_attr(attrs: &mut VariantAttrs, attr: &Attribute) {
  24     if let Meta::List(_) = attr.meta {
  25         let _ = attr.parse_nested_meta(|meta| {
  26             if meta.input.peek(Token![=]) {
  27                 let _value: Expr = meta.value()?.parse()?;
  28             } else if meta.input.peek(token::Paren) {
  29                 let _group: TokenTree = meta.input.parse()?;
  30             } else if meta.path.is_ident("other") {
  31                 attrs.is_default = true;
  32             }
  33             Ok(())
  34         });
  35     }
  36 }
  37
  38 fn parse_attrs(variant: &syn::Variant) -> VariantAttrs {
  39     let mut attrs = VariantAttrs { is_default: false };
  40     for attr in &variant.attrs {
  41         if attr.path().is_ident("serde") {
  42             parse_serde_attr(&mut attrs, attr);
  43         }
  44     }
  45     attrs
  46 }
  47
  48 impl Parse for Input {
  49     fn parse(input: ParseStream) -> Result<Self> {
  50         let call_site = Span::call_site();
  51         let derive_input = DeriveInput::parse(input)?;
  52
  53         let data = match derive_input.data {
  54             Data::Enum(data) => data,
  55             _ => {
  56                 return Err(Error::new(call_site, "input must be an enum"));
  57             }
  58         };
  59
  60         let variants = data
  61             .variants
  62             .into_iter()
  63             .map(|variant| match variant.fields {
  64                 Fields::Unit => {
  65                     let attrs = parse_attrs(&variant);
  66                     Ok(Variant {
  67                         ident: variant.ident,
  68                         attrs,
  69                     })
  70                 }
  71                 Fields::Named(_) | Fields::Unnamed(_) => {
  72                     Err(Error::new(variant.ident.span(), "must be a unit variant"))
  73                 }
  74             })
  75             .collect::<Result<Vec<Variant>>>()?;
  76
  77         if variants.is_empty() {
  78             return Err(Error::new(call_site, "there must be at least one variant"));
  79         }
  80
  81         let generics = derive_input.generics;
  82         if !generics.params.is_empty() || generics.where_clause.is_some() {
  83             return Err(Error::new(call_site, "generic enum is not supported"));
  84         }
  85
  86         let mut repr = None;
  87         for attr in derive_input.attrs {
  88             if attr.path().is_ident("repr") {
  89                 if let Meta::List(_) = &attr.meta {
  90                     let ty: Ident = attr.parse_args()?;
  91                     repr = Some(ty);
  92                     break;
  93                 }
  94             }
  95         }
  96         let repr = repr.ok_or_else(|| Error::new(call_site, "missing #[repr(...)] attribute"))?;
  97
  98         let mut default_variants = variants.iter().filter(|x| x.attrs.is_default);
  99         let default_variant = default_variants.next().cloned();
 100         if default_variants.next().is_some() {
 101             return Err(Error::new(
 102                 call_site,
 103                 "only one variant can be #[serde(other)]",
 104             ));
 105         }
 106
 107         Ok(Input {
 108             ident: derive_input.ident,
 109             repr,
 110             variants,
 111             default_variant,
 112         })
 113     }
 114 }