macroific_attr_parse 3.0.1

Attribute parsing utilities for the macroific crate
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

use proc_macro2::{Ident, TokenStream};
use syn::parse::{Parse, ParseStream};
use syn::spanned::Spanned;
use syn::{Meta, Token};

use crate::__attr_parse_prelude::*;
use crate::{DelimitedIter, ParseWrapper, ValueSyntax};

/// Get the ident from a path or [`Err`] trying
pub fn get_attr_ident(path: &syn::Path) -> syn::Result<&Ident> {
    if let Some(ident) = path.get_ident() {
        Ok(ident)
    } else {
        Err(syn::Error::new_spanned(path, "expected ident"))
    }
}

pub enum MetaValue {
    Expr(syn::Expr),
    Stream(TokenStream),
}

pub type MetaValueTuple = (Ident, Option<MetaValue>);

/// Iterate over metadata for the `ParseOption` derive macro
pub fn iterate_option_meta(
    parse: ParseStream<'_>,
) -> syn::Result<impl Iterator<Item = syn::Result<MetaValueTuple>> + '_> {
    fn map_meta(meta: Meta) -> syn::Result<MetaValueTuple> {
        Ok(match meta {
            Meta::Path(path) => (get_attr_ident(&path)?.clone(), None),
            Meta::NameValue(meta) => (
                get_attr_ident(&meta.path)?.clone(),
                Some(MetaValue::Expr(meta.value)),
            ),
            Meta::List(meta) => (
                get_attr_ident(&meta.path)?.clone(),
                Some(MetaValue::Stream(meta.tokens)),
            ),
        })
    }

    let parse_from: DelimitedIter<Meta, Token![,]> =
        if let Some(syntax) = ValueSyntax::from_stream(parse) {
            if let Some(buffer) = syntax.parse_token(parse)? {
                buffer.into()
            } else {
                parse.into()
            }
        } else {
            parse.into()
        };

    Ok(parse_from.map(move |meta| meta.and_then(map_meta)))
}

macro_rules! check_option {
    ($option: ident, $source: ident) => {
        if $option.is_some() {
            return Err(syn::Error::new($source.span(), "duplicate attribute"));
        }
    };
}

/// Decode a field while iterating attributes
pub fn decode_parse_option_field<O: ParseOption + FromExpr>(
    option: &mut Option<O>,
    ident: Ident,
    value_source: Option<MetaValue>,
) -> syn::Result<()> {
    check_option!(option, ident);

    let new_value = if let Some(meta_value) = value_source {
        match meta_value {
            MetaValue::Expr(expr) => O::from_expr(expr)?,
            MetaValue::Stream(stream) => ParseWrapper::<O>::parse_stream_self(stream)?,
        }
    } else if let Some(v) = O::boolean() {
        v
    } else {
        return Err(syn::Error::new_spanned(ident, "expected a value"));
    };

    *option = Some(new_value);

    Ok(())
}

/// Decode a field while iterating attributes
pub fn decode_attr_options_field<O>(
    option: &mut Option<O>,
    source: &impl Spanned,
    stream: ParseStream,
) -> syn::Result<()>
where
    O: ParseOption,
{
    check_option!(option, source);

    *option = Some(O::from_stream(stream)?);
    Ok(())
}

/// Decode a [`ParseOption`] with the `from_parse` option set
pub fn decode_parse_option_from_parse<O: Parse>(stream: ParseStream) -> syn::Result<O> {
    ValueSyntax::from_stream(stream).and_parse(stream)
}