1 use syn::{
2     parse::{Parse, ParseStream},
3     Expr, Result,
4 };
5 
6 mod kw {
7     syn::custom_keyword!(default);
8     syn::custom_keyword!(catch_all);
9     syn::custom_keyword!(alternatives);
10 }
11 
12 pub(crate) struct NumEnumVariantAttributes {
13     pub(crate) items: syn::punctuated::Punctuated<NumEnumVariantAttributeItem, syn::Token![,]>,
14 }
15 
16 impl Parse for NumEnumVariantAttributes {
parse(input: ParseStream<'_>) -> Result<Self>17     fn parse(input: ParseStream<'_>) -> Result<Self> {
18         Ok(Self {
19             items: input.parse_terminated(NumEnumVariantAttributeItem::parse, syn::Token![,])?,
20         })
21     }
22 }
23 
24 pub(crate) enum NumEnumVariantAttributeItem {
25     Default(VariantDefaultAttribute),
26     CatchAll(VariantCatchAllAttribute),
27     Alternatives(VariantAlternativesAttribute),
28 }
29 
30 impl Parse for NumEnumVariantAttributeItem {
parse(input: ParseStream<'_>) -> Result<Self>31     fn parse(input: ParseStream<'_>) -> Result<Self> {
32         let lookahead = input.lookahead1();
33         if lookahead.peek(kw::default) {
34             input.parse().map(Self::Default)
35         } else if lookahead.peek(kw::catch_all) {
36             input.parse().map(Self::CatchAll)
37         } else if lookahead.peek(kw::alternatives) {
38             input.parse().map(Self::Alternatives)
39         } else {
40             Err(lookahead.error())
41         }
42     }
43 }
44 
45 pub(crate) struct VariantDefaultAttribute {
46     pub(crate) keyword: kw::default,
47 }
48 
49 impl Parse for VariantDefaultAttribute {
parse(input: ParseStream) -> Result<Self>50     fn parse(input: ParseStream) -> Result<Self> {
51         Ok(Self {
52             keyword: input.parse()?,
53         })
54     }
55 }
56 
57 pub(crate) struct VariantCatchAllAttribute {
58     pub(crate) keyword: kw::catch_all,
59 }
60 
61 impl Parse for VariantCatchAllAttribute {
parse(input: ParseStream) -> Result<Self>62     fn parse(input: ParseStream) -> Result<Self> {
63         Ok(Self {
64             keyword: input.parse()?,
65         })
66     }
67 }
68 
69 pub(crate) struct VariantAlternativesAttribute {
70     _keyword: kw::alternatives,
71     _eq_token: syn::Token![=],
72     _bracket_token: syn::token::Bracket,
73     pub(crate) expressions: syn::punctuated::Punctuated<Expr, syn::Token![,]>,
74 }
75 
76 impl Parse for VariantAlternativesAttribute {
parse(input: ParseStream) -> Result<Self>77     fn parse(input: ParseStream) -> Result<Self> {
78         let content;
79         let keyword = input.parse()?;
80         let _eq_token = input.parse()?;
81         let _bracket_token = syn::bracketed!(content in input);
82         let expressions = content.parse_terminated(Expr::parse, syn::Token![,])?;
83         Ok(Self {
84             _keyword: keyword,
85             _eq_token,
86             _bracket_token,
87             expressions,
88         })
89     }
90 }
91