datastruct_derive 0.1.1

The derive macro of `datastruct` 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

use crate::utils::synerr::{ResultExt, SynErrorExt};
use proc_macro2::Span;
use std::collections::{HashMap, HashSet};
use std::hash::Hash;
use syn::spanned::Spanned;
use syn::{Ident, Lit, Meta, MetaList, MetaNameValue, NestedMeta};

pub fn collect_meta_set<T: Hash + Eq>(
    meta_list: &MetaList,
    mut func: impl FnMut(&str, Span) -> syn::Result<T>,
) -> syn::Result<HashSet<T>> {
    let mut set = HashSet::new();
    let mut err: Option<syn::Error> = None;

    for meta in &meta_list.nested {
        match meta {
            NestedMeta::Meta(Meta::Path(pth)) => {
                if let Some(path) = pth.get_ident() {
                    match func(&path.to_string(), meta.span()) {
                        Ok(val) => {
                            set.insert(val);
                        }
                        Err(e) => err.update_or_combine(e),
                    }
                } else {
                    err.update_or_combine(syn::Error::new(
                        meta.span(),
                        "invalid meta argument, expect ident or string literal"
                    ))
                }
            }
            NestedMeta::Lit(Lit::Str(lit)) => match func(&lit.value(), meta.span()) {
                Ok(val) => {
                    set.insert(val);
                }
                Err(e) => err.update_or_combine(e),
            },
            _ => err.update_or_combine(syn::Error::new(
                meta.span(),
                "invalid meta argument, expect ident or string literal",
            )),
        }
    }

    err.ok_or(()).swap()?;

    Ok(set)
}

pub fn collect_meta_map<K: Hash + Eq, V>(
    meta_list: &MetaList,
    mut func: impl FnMut(usize, &Ident, Option<&Lit>) -> syn::Result<(K, V)>,
) -> syn::Result<HashMap<K, V>> {
    let mut map = HashMap::new();
    let mut err: Option<syn::Error> = None;

    for (idx, meta) in meta_list.nested.iter().enumerate() {
        if let NestedMeta::Meta(meta) = meta {
            match meta {
                Meta::Path(pth) => {
                    if let Some(ident) = pth.get_ident() {
                        let res = func(idx, ident, None);
                        match res {
                            Err(e) => err.update_or_combine(e),
                            Ok(res) => {
                                map.insert(res.0, res.1);
                            }
                        }
                    }
                }
                Meta::NameValue(MetaNameValue { path: pth, lit, .. }) => {
                    if let Some(ident) = pth.get_ident() {
                        let res = func(idx, ident, Some(lit));
                        match res {
                            Err(e) => err.update_or_combine(e),
                            Ok(res) => {
                                map.insert(res.0, res.1);
                            }
                        }
                    }
                }
                _ => {}
            }
        }
    }

    err.ok_or(()).swap()?;

    Ok(map)
}