bytecheck_derive 0.8.2

Derive macro for bytecheck
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
108
109
110
111
112
113
114
115
116
117

use quote::ToTokens;
use syn::{
    meta::ParseNestedMeta, parenthesized, parse::Parse, parse_quote,
    punctuated::Punctuated, AttrStyle, DeriveInput, Error, Field, Path, Token,
    WherePredicate,
};

fn try_set_attribute<T: ToTokens>(
    attribute: &mut Option<T>,
    value: T,
    name: &'static str,
) -> Result<(), Error> {
    if attribute.is_none() {
        *attribute = Some(value);
        Ok(())
    } else {
        Err(Error::new_spanned(
            value,
            format!("{name} already specified"),
        ))
    }
}

#[derive(Default)]
pub struct Attributes {
    pub bounds: Option<Punctuated<WherePredicate, Token![,]>>,
    crate_path: Option<Path>,
    pub verify: Option<Path>,
}

impl Attributes {
    fn parse_check_bytes_attributes(
        &mut self,
        meta: ParseNestedMeta<'_>,
    ) -> Result<(), Error> {
        if meta.path.is_ident("bounds") {
            let bounds;
            parenthesized!(bounds in meta.input);
            let bounds =
                bounds.parse_terminated(WherePredicate::parse, Token![,])?;
            try_set_attribute(&mut self.bounds, bounds, "bounds")
        } else if meta.path.is_ident("crate") {
            if meta.input.parse::<Token![=]>().is_ok() {
                let path = meta.input.parse::<Path>()?;
                try_set_attribute(&mut self.crate_path, path, "crate")
            } else if meta.input.is_empty() || meta.input.peek(Token![,]) {
                try_set_attribute(
                    &mut self.crate_path,
                    parse_quote! { crate },
                    "crate",
                )
            } else {
                Err(meta.error("expected `crate` or `crate = ...`"))
            }
        } else if meta.path.is_ident("verify") {
            if !meta.input.is_empty() && !meta.input.peek(Token![,]) {
                return Err(meta.error("verify argument must be a path"));
            }

            try_set_attribute(&mut self.verify, meta.path, "verify")
        } else {
            Err(meta.error("unrecognized bytecheck argument"))
        }
    }

    pub fn parse(input: &DeriveInput) -> Result<Self, Error> {
        let mut result = Self::default();

        for attr in input.attrs.iter() {
            if !matches!(attr.style, AttrStyle::Outer) {
                continue;
            }

            if attr.path().is_ident("bytecheck") {
                attr.parse_nested_meta(|nested| {
                    result.parse_check_bytes_attributes(nested)
                })?;
            }
        }

        Ok(result)
    }

    pub fn crate_path(&self) -> Path {
        self.crate_path
            .clone()
            .unwrap_or_else(|| parse_quote! { ::bytecheck })
    }
}

#[derive(Default)]
pub struct FieldAttributes {
    pub omit_bounds: Option<Path>,
}

impl FieldAttributes {
    fn parse_meta(&mut self, meta: ParseNestedMeta<'_>) -> Result<(), Error> {
        if meta.path.is_ident("omit_bounds") {
            self.omit_bounds = Some(meta.path);
            Ok(())
        } else {
            Err(meta.error("unrecognized bytecheck arguments"))
        }
    }

    pub fn parse(input: &Field) -> Result<Self, Error> {
        let mut result = Self::default();

        for attr in input.attrs.iter() {
            if attr.path().is_ident("bytecheck") {
                attr.parse_nested_meta(|meta| result.parse_meta(meta))?;
            }
        }

        Ok(result)
    }
}