proper 0.1.1

Derives for converting primitives to and from simple enums and newtype structs
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

use syn::spanned::Spanned;

use crate::IntTy;

#[derive(Debug)]
pub struct PrimAttrs {
    pub min_ty: Option<IntTy>,
    pub err_ctor: Option<syn::Path>,
}

impl PrimAttrs {
    pub fn new(attrs: &[syn::Attribute]) -> Option<Self> {
        let mut has_errs = false;

        let mut min_ty = None;
        let mut err_ctor = None;

        for attr in attrs.iter() {
            if !attr.path.is_ident("prim") {
                continue;
            }
            let nested_metas = match attr.parse_meta() {
                Ok(syn::Meta::List(syn::MetaList { nested, .. })) => nested,
                Ok(_) => {
                    err!(attr: "Unrecognized meta item");
                    has_errs = true;
                    continue;
                }
                Err(e) => {
                    err!(attr: "Could not parse attribute meta: {}", e);
                    has_errs = true;
                    continue;
                }
            };

            for nested_meta in nested_metas {
                let meta = match nested_meta {
                    syn::NestedMeta::Meta(syn::Meta::NameValue(meta)) => meta,
                    meta_item => {
                        err!(meta_item: "Unrecognized meta item: `{}`",
                             meta_item.span().unwrap().source_text().unwrap());
                        has_errs = true;
                        continue;
                    }
                };

                let lit = match &meta.lit {
                    syn::Lit::Str(lit_str) => lit_str,
                    lit => {
                        err!(lit: "The value of `{}` must be a string literal.", meta.ident);
                        has_errs = true;
                        continue;
                    }
                };

                if meta.ident == "ty" {
                    if min_ty.is_some() {
                        err!(meta: "Multiple `ty` attributes provided.");
                        has_errs = true;
                        continue;
                    }
                    min_ty = match lit.parse::<syn::Ident>().ok().and_then(IntTy::new) {
                        Some(ty) => Some(ty),
                        None => {
                            err!(lit: "The value of `{}` must be an integer type", meta.ident);
                            has_errs = true;
                            continue;
                        }
                    };
                } else if meta.ident == "error" {
                    if err_ctor.is_some() {
                        err!(meta: "Multiple `error` attributes provided.");
                        has_errs = true;
                        continue;
                    }
                    err_ctor = match lit.parse::<syn::Path>() {
                        Ok(ctor) => Some(ctor),
                        Err(_) => {
                            err!(lit: "The value of `{}` must be a path to a constructor",
                                 meta.ident);
                            has_errs = true;
                            continue;
                        }
                    };
                } else {
                    err!(meta.ident: "Unrecognized attribute `{}`", meta.ident);
                    has_errs = true;
                    continue;
                }
            }
        }

        if has_errs {
            None
        } else {
            Some(Self { min_ty, err_ctor })
        }
    }
}