snafu-derive 0.9.2

An ergonomic error handling library
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

use crate::{
    parse::{
        self,
        attr::{self, ErrorLocation},
        into_crate_root, into_transformation,
        tuple_struct_field_impl::parse_tuple_struct_field,
        AtMostOne, Attribute, CrateRoot, ProvideExpression, SourceFrom, SynErrors,
    },
    TupleStructInfo,
};

struct Attributes {
    crate_root: Option<CrateRoot>,
    provide_expressions: Vec<ProvideExpression>,
    source_from: Option<SourceFrom>,
}

impl Attributes {
    fn from_syn(attrs: &[syn::Attribute]) -> syn::Result<Self> {
        let location = ErrorLocation::OnTupleStruct;
        let mut errors = SynErrors::default();

        let mut crate_roots = AtMostOne::attribute(attr::CrateRoot, location);
        let mut provide_expressions = Vec::new();
        let mut source_froms = AtMostOne::attribute(attr::SourceFrom, location);

        parse::syn_attrs(attrs, &mut errors, |errors, attr| {
            use Attribute::*;

            match attr {
                Backtrace(a) => errors.push_invalid_flag(a, location),
                ContextFlag(a) => errors.push_invalid_flag(a, location),
                ContextName(a) => errors.push_invalid(a, location),
                ContextSuffix(a) => errors.push_invalid(a, location),
                CrateRoot(a) => crate_roots.push(a),
                Display(a) => errors.push_invalid(a, location),
                DocComment(_a) => { /* no-op */ }
                Implicit(a) => errors.push_invalid_flag(a, location),
                Module(a) => errors.push_invalid(a, location),
                ProvideFlag(a) => errors.push_invalid_flag(a, location),
                ProvideExpression(a) => provide_expressions.push(a),
                SourceFlag(a) => errors.push_invalid_flag(a, location),
                SourceFrom(a) => source_froms.push(a),
                Transparent(a) => errors.push_invalid_flag(a, location),
                Visibility(a) => errors.push_invalid(a, location),
                Whatever(a) => errors.push_invalid(a, location),
            }
        });

        let crate_root = crate_roots.finish_default(&mut errors);
        let source_from = source_froms.finish_default(&mut errors);

        errors.finish(Self {
            crate_root,
            provide_expressions,
            source_from,
        })
    }
}

pub(crate) fn parse_tuple_struct(
    fields: &syn::FieldsUnnamed,
    name: &syn::Ident,
    generics: &syn::Generics,
    attrs: &[syn::Attribute],
    span: impl quote::ToTokens,
) -> syn::Result<TupleStructInfo> {
    let attrs = Attributes::from_syn(attrs);
    let field_ty = parse_tuple_struct_field(fields, span);

    let (attrs, field_ty) = join_syn_error!(attrs, field_ty)?;

    let Attributes {
        crate_root,
        provide_expressions,
        source_from,
    } = attrs;

    let crate_root = into_crate_root(crate_root);
    let generics = generics.clone();
    let name = name.clone();
    let provides = provide_expressions
        .into_iter()
        .map(|p| p.into_provide())
        .collect();
    let transformation = into_transformation(source_from, field_ty, true);

    Ok(TupleStructInfo {
        crate_root,
        generics,
        name,
        provides,
        transformation,
    })
}