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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use syn::{
    parse::{Parse, ParseStream},
    spanned::Spanned,
    Expr, Ident, Lit, LitBool, LitStr, Meta, MetaNameValue,
};

use super::path::path_to_string;

#[derive(Debug)]
pub(crate) enum IdentOrBool {
    Ident(Ident),
    Bool(bool),
}

impl Parse for IdentOrBool {
    #[inline]
    fn parse(input: ParseStream) -> syn::Result<Self> {
        if let Ok(lit) = input.parse::<Lit>() {
            match lit {
                Lit::Bool(lit) => return Ok(Self::Bool(lit.value)),
                Lit::Str(lit) => {
                    return match lit.parse::<Ident>() {
                        Ok(ident) => Ok(Self::Ident(ident)),
                        Err(_) if lit.value().is_empty() => Ok(Self::Bool(false)),
                        Err(error) => Err(error),
                    }
                },
                _ => (),
            }
        }

        Ok(Self::Ident(input.parse::<Ident>()?))
    }
}

#[inline]
pub(crate) fn meta_name_value_2_ident(name_value: &MetaNameValue) -> syn::Result<Ident> {
    match &name_value.value {
        Expr::Lit(lit) => {
            if let Lit::Str(lit) = &lit.lit {
                return lit.parse();
            }
        },
        Expr::Path(path) => {
            if let Some(ident) = path.path.get_ident() {
                return Ok(ident.clone());
            }
        },
        _ => (),
    }

    Err(syn::Error::new(
        name_value.value.span(),
        format!("expected `{path} = Ident`", path = path_to_string(&name_value.path)),
    ))
}

#[inline]
pub(crate) fn meta_2_ident(meta: &Meta) -> syn::Result<Ident> {
    match &meta {
        Meta::NameValue(name_value) => meta_name_value_2_ident(name_value),
        Meta::List(list) => {
            if let Ok(lit) = list.parse_args::<LitStr>() {
                lit.parse()
            } else {
                list.parse_args()
            }
        },
        Meta::Path(path) => Err(syn::Error::new(
            path.span(),
            format!("expected `{path} = Ident` or `{path}(Ident)`", path = path_to_string(path)),
        )),
    }
}

#[inline]
pub(crate) fn meta_name_value_2_bool(name_value: &MetaNameValue) -> syn::Result<bool> {
    if let Expr::Lit(lit) = &name_value.value {
        if let Lit::Bool(b) = &lit.lit {
            return Ok(b.value);
        }
    }

    Err(syn::Error::new(
        name_value.value.span(),
        format!("expected `{path} = false`", path = path_to_string(&name_value.path)),
    ))
}

#[inline]
pub(crate) fn meta_2_bool(meta: &Meta) -> syn::Result<bool> {
    match &meta {
        Meta::NameValue(name_value) => meta_name_value_2_bool(name_value),
        Meta::List(list) => Ok(list.parse_args::<LitBool>()?.value),
        Meta::Path(path) => Err(syn::Error::new(
            path.span(),
            format!("expected `{path} = false` or `{path}(false)`", path = path_to_string(path)),
        )),
    }
}

#[inline]
pub(crate) fn meta_2_bool_allow_path(meta: &Meta) -> syn::Result<bool> {
    match &meta {
        Meta::Path(_) => Ok(true),
        Meta::NameValue(name_value) => meta_name_value_2_bool(name_value),
        Meta::List(list) => Ok(list.parse_args::<LitBool>()?.value),
    }
}

#[inline]
pub(crate) fn meta_name_value_2_ident_and_bool(
    name_value: &MetaNameValue,
) -> syn::Result<IdentOrBool> {
    match &name_value.value {
        Expr::Lit(lit) => match &lit.lit {
            Lit::Str(lit) => match lit.parse::<Ident>() {
                Ok(ident) => return Ok(IdentOrBool::Ident(ident)),
                Err(_) if lit.value().is_empty() => {
                    return Ok(IdentOrBool::Bool(false));
                },
                Err(error) => {
                    return Err(error);
                },
            },
            Lit::Bool(lit) => {
                return Ok(IdentOrBool::Bool(lit.value));
            },
            _ => (),
        },
        Expr::Path(path) => {
            if let Some(ident) = path.path.get_ident() {
                return Ok(IdentOrBool::Ident(ident.clone()));
            }
        },
        _ => (),
    }

    Err(syn::Error::new(
        name_value.value.span(),
        format!(
            "expected `{path} = Ident` or `{path} = false`",
            path = path_to_string(&name_value.path)
        ),
    ))
}

#[inline]
pub(crate) fn meta_2_ident_and_bool(meta: &Meta) -> syn::Result<IdentOrBool> {
    match &meta {
        Meta::NameValue(name_value) => meta_name_value_2_ident_and_bool(name_value),
        Meta::List(list) => list.parse_args::<IdentOrBool>(),
        Meta::Path(path) => Err(syn::Error::new(
            path.span(),
            format!(
                "expected `{path} = Ident`, `{path}(Ident)`, `{path} = false`, or `{path}(false)`",
                path = path_to_string(path)
            ),
        )),
    }
}