subenum 1.1.3

A proc-macro to create subsets of enums, that can be converted to and from.
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use alloc::{borrow::ToOwned, boxed::Box, vec::Vec};
use syn::{Ident, Lifetime, Type, TypeParamBound};

use crate::{iter::BoxedIter, param::Param};

pub trait Extractor {
    fn extract_lifetimes(&self) -> Vec<Lifetime>;
    fn extract_idents(&self) -> Vec<Ident>;
    fn extract_params(&self) -> Box<dyn Iterator<Item = Param>> {
        self.extract_lifetimes()
            .into_iter()
            .map(Param::Lifetime)
            .chain(self.extract_idents().into_iter().map(Param::Ident))
            .boxed()
    }
}

impl Extractor for Type {
    fn extract_lifetimes(&self) -> Vec<Lifetime> {
        match self {
            Type::Array(a) => a.elem.extract_lifetimes(),
            Type::BareFn(_) => Vec::new(),
            Type::Group(g) => g.elem.extract_lifetimes(),
            Type::ImplTrait(it) => it
                .bounds
                .iter()
                .cloned()
                .filter_map(|b| match b {
                    TypeParamBound::Trait(_) => None,
                    TypeParamBound::Lifetime(lt) => Some(lt),
                    _ => panic!("Unsupported Type Parameter Bound"),
                })
                .collect(),
            Type::Infer(_) => Vec::new(),
            Type::Macro(_) => Vec::new(),
            Type::Never(_) => Vec::new(),
            Type::Paren(p) => p.elem.extract_lifetimes(),
            Type::Path(p) => p
                .path
                .segments
                .iter()
                .flat_map(|x| match x.arguments {
                    syn::PathArguments::AngleBracketed(ref ab) => ab
                        .args
                        .iter()
                        .flat_map(|arg| match arg {
                            syn::GenericArgument::Lifetime(lt) => Vec::from([lt.clone()]),
                            syn::GenericArgument::Type(ty) => ty.extract_lifetimes(),
                            syn::GenericArgument::AssocType(at) => at.ty.extract_lifetimes(),
                            _ => Vec::new(),
                        })
                        .collect(),
                    syn::PathArguments::Parenthesized(ref p) => p
                        .inputs
                        .iter()
                        .flat_map(|x| x.extract_lifetimes())
                        .collect(),
                    syn::PathArguments::None => Vec::new(),
                })
                .collect(),
            Type::Ptr(p) => p.elem.extract_lifetimes(),
            Type::Reference(r) => r
                .lifetime
                .iter()
                .cloned()
                .chain(r.elem.extract_lifetimes())
                .collect(),
            Type::Slice(s) => s.elem.extract_lifetimes(),
            Type::TraitObject(to) => to
                .bounds
                .iter()
                .cloned()
                .filter_map(|b| match b {
                    TypeParamBound::Trait(_) => None,
                    TypeParamBound::Lifetime(lt) => Some(lt),
                    _ => panic!("Unsupported Type Parameter Bound"),
                })
                .collect(),

            Type::Tuple(t) => t.elems.iter().flat_map(Self::extract_lifetimes).collect(),
            Type::Verbatim(_) => Vec::new(),
            #[allow(unknown_lints)]
            #[cfg_attr(test, deny(non_exhaustive_omitted_patterns))]
            _ => Vec::new(),
        }
    }

    fn extract_idents(&self) -> Vec<Ident> {
        match self {
            Type::Array(a) => a.elem.extract_idents(),
            Type::BareFn(_) => Vec::new(),
            Type::Group(g) => g.elem.extract_idents(),
            Type::ImplTrait(it) => it
                .bounds
                .iter()
                .cloned()
                .filter_map(|b| match b {
                    TypeParamBound::Trait(t) => t.path.get_ident().map(ToOwned::to_owned),
                    TypeParamBound::Lifetime(_) => None,
                    _ => panic!("Unsupported Type Parameter Bound"),
                })
                .collect(),
            Type::Infer(_) => Vec::new(),
            Type::Macro(_) => Vec::new(),
            Type::Never(_) => Vec::new(),
            Type::Paren(p) => p.elem.extract_idents(),
            Type::Path(p) => p
                .path
                .get_ident()
                .map(ToOwned::to_owned)
                .into_iter()
                .collect(),
            Type::Ptr(p) => p.elem.extract_idents(),
            Type::Reference(r) => r.elem.extract_idents(),
            Type::Slice(s) => s.elem.extract_idents(),
            Type::TraitObject(_) => Vec::new(),
            Type::Tuple(t) => t.elems.iter().flat_map(Self::extract_idents).collect(),
            Type::Verbatim(_) => Vec::new(),
            #[allow(unknown_lints)]
            #[cfg_attr(test, deny(non_exhaustive_omitted_patterns))]
            _ => Vec::new(),
        }
    }
}