spire_enum_macros 0.7.2

Procedural macros distributed by the crate `spire_enum`.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use super::*;

#[derive(Parse, ToTokens)]
pub enum InputImplItem {
    Const(Box<InputImplItemConst>),
    Fn(Box<InputImplItemFn>),
    Type(Box<InputImplItemAssocType>),
    Macro(Box<syn::ImplItemMacro>),
}

#[derive(Parse, ToTokens)]
pub struct InputImplItemFn {
    pub attrs: Any<Attribute<SynMeta>>,
    pub vis:   Visibility,
    pub sig:   InputFnSignature,
    pub body:  InputImplItemFnBody,
}

#[derive(Parse, ToTokens)]
pub enum InputImplItemFnBody {
    Block(Block),
    SemiColon(Token![;]),
}

#[derive(Parse, ToTokens)]
pub struct InputImplItemConst {
    pub attrs: Any<Attribute<SynMeta>>,
    pub vis: Visibility,
    pub const_token: Token![const],
    pub ident: Ident,
    pub generics: Optional<InputGenerics>,
    pub colon_token: Token![:],
    pub ty: Type,
    pub body: InputImplItemConstBody,
    pub semi_token: Token![;],
}

#[derive(Parse, ToTokens)]
pub enum InputImplItemConstBody {
    Some(Token![=], Box<Expr>),
    None,
}

#[derive(Parse, ToTokens)]
pub struct InputImplItemAssocType {
    pub attrs: Any<Attribute<SynMeta>>,
    pub type_token: Token![type],
    pub ident: Ident,
    pub generics: Optional<InputGenerics>,
    pub body: InputImplItemAssocTypeBody,
    pub semi_token: Token![;],
}

#[derive(Parse, ToTokens)]
pub enum InputImplItemAssocTypeBody {
    Some(Token![=], Box<Type>),
    None,
}

#[derive(Parse, ToTokens)]
pub struct InputFnSignature {
    pub constness: Optional<Token![const]>,
    pub asyncness: Optional<Token![async]>,
    pub unsafety: Optional<Token![unsafe]>,
    pub abi: Optional<syn::Abi>,
    pub fn_token: Token![fn],
    pub ident: Ident,
    pub generics: Optional<InputGenerics>,
    pub inputs: Paren<InputPunctuated<FnArg, Token![,]>>,
    pub output: syn::ReturnType,
    pub where_clause: Optional<WhereClause>,
}

pub fn find_enum_ident(ty: &Type) -> Option<&Ident> {
    match ty {
        | Type::Group(TypeGroup { elem, .. })
        | Type::Paren(TypeParen { elem, .. })
        | Type::Reference(TypeReference { elem, .. })
        | Type::Ptr(TypePtr { elem, .. }) => find_enum_ident(elem),

        Type::Tuple(TypeTuple { elems, .. }) => elems.first().and_then(find_enum_ident),
        Type::Path(TypePath { path, .. }) => path.segments.last().map(|seg| &seg.ident),
        _ => None,
    }
}