tosserror-derive 0.1.2

Derive implementation of the `tosserror` 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

use proc_macro2::{Ident, TokenStream};
use quote::format_ident;
use syn::{Attribute, Error, Meta, Result};

pub struct Attrs<'a> {
    pub source: Option<&'a Attribute>,
    pub from: Option<&'a Attribute>,
    pub backtrace: Option<&'a Attribute>,
    pub visibility: Option<&'a TokenStream>,
    pub prefix: Option<Ident>,
}

pub fn get(input: &[Attribute]) -> Result<Attrs> {
    let mut attrs = Attrs {
        source: None,
        from: None,
        backtrace: None,
        visibility: None,
        prefix: None,
    };

    for attr in input {
        if attr.path().is_ident("source") {
            attr.meta.require_path_only()?;
            if attrs.source.is_some() {
                return Err(Error::new_spanned(attr, "duplicate #[source] attribute"));
            }
            attrs.source = Some(attr);
        } else if attr.path().is_ident("backtrace") {
            attr.meta.require_path_only()?;
            if attrs.backtrace.is_some() {
                return Err(Error::new_spanned(attr, "duplicate #[backtrace] attribute"));
            }
            attrs.backtrace = Some(attr);
        } else if attr.path().is_ident("visibility") {
            attr.meta.require_list()?;
            if attrs.visibility.is_some() {
                return Err(Error::new_spanned(attr, "duplicate #[backtrace] attribute"));
            }
            if let Meta::List(list) = &attr.meta {
                attrs.visibility = Some(&list.tokens);
            }
        } else if attr.path().is_ident("from") {
            match attr.meta {
                Meta::Path(_) => {}
                Meta::List(_) | Meta::NameValue(_) => {
                    // Assume this is meant for derive_more crate or something.
                    continue;
                }
            }
            if attrs.from.is_some() {
                return Err(Error::new_spanned(attr, "duplicate #[from] attribute"));
            }
            attrs.from = Some(attr);
        } else if attr.path().is_ident("prefix") {
            if attrs.prefix.is_some() {
                return Err(Error::new_spanned(attr, "duplicate #[backtrace] attribute"));
            }
            if let Meta::List(list) = &attr.meta {
                let ident: Ident = syn::parse2(list.tokens.clone())?;
                attrs.prefix = Some(ident);
            } else if let Meta::Path(_) = &attr.meta {
                attrs.prefix = Some(format_ident!("self"));
            }
        }
    }

    Ok(attrs)
}