spire_enum_macros 0.2.0

Procedural macros to facilitate enum usage, such as when delegating implementations, extracting variant types, or creating enum tables.
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<Punctuated<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,
	}
}