ssh-derive 0.3.0-rc.0

Custom derive support for the `ssh-encoding` 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
91
92
93
94
95
96
97

use proc_macro2::TokenStream;
use quote::quote;

pub(crate) struct ContainerAttributes {
    pub(crate) length_prefixed: bool,
    pub(crate) discriminant_type: Option<TokenStream>,
}

impl TryFrom<&syn::DeriveInput> for ContainerAttributes {
    type Error = syn::Error;

    fn try_from(input: &syn::DeriveInput) -> Result<Self, Self::Error> {
        let mut length_prefixed = false;
        let mut discriminant_type = None;
        for attr in &input.attrs {
            if attr.path().is_ident("ssh") {
                attr.parse_nested_meta(|meta| {
                    // #[ssh(length_prefixed)]
                    if meta.path.is_ident("length_prefixed") {
                        length_prefixed = true;
                    } else {
                        return Err(syn::Error::new_spanned(meta.path, "unknown attribute"));
                    }
                    Ok(())
                })?;
            } else if attr.path().is_ident("repr") {
                attr.parse_nested_meta(|meta| {
                    // #[repr(u8)]  or similar
                    // https://doc.rust-lang.org/reference/type-layout.html#primitive-representations
                    if meta.path.is_ident("u8") {
                        discriminant_type = Some(quote! {u8});
                    } else if meta.path.is_ident("u16") {
                        discriminant_type = Some(quote! {u16});
                    } else if meta.path.is_ident("u32") {
                        discriminant_type = Some(quote! {u32});
                    } else if meta.path.is_ident("u64") {
                        discriminant_type = Some(quote! {u64});
                    } else if meta.path.is_ident("u128") {
                        discriminant_type = Some(quote! {u128});
                    } else if meta.path.is_ident("usize") {
                        discriminant_type = Some(quote! {usize});
                    } else if meta.path.is_ident("i8") {
                        discriminant_type = Some(quote! {i8});
                    } else if meta.path.is_ident("i16") {
                        discriminant_type = Some(quote! {i16});
                    } else if meta.path.is_ident("i32") {
                        discriminant_type = Some(quote! {i32});
                    } else if meta.path.is_ident("i64") {
                        discriminant_type = Some(quote! {i64});
                    } else if meta.path.is_ident("i128") {
                        discriminant_type = Some(quote! {i128});
                    } else if meta.path.is_ident("isize") {
                        discriminant_type = Some(quote! {isize});
                    } else {
                        return Err(syn::Error::new_spanned(
                            meta.path,
                            "unsupported repr for deriving Encode/Decode, must be a primitive integer type",
                        ));
                    }
                    Ok(())
                })?;
            }
        }

        Ok(Self {
            length_prefixed,
            discriminant_type,
        })
    }
}

pub(crate) struct FieldAttributes {
    pub(crate) length_prefixed: bool,
}

impl TryFrom<&syn::Field> for FieldAttributes {
    type Error = syn::Error;

    fn try_from(field: &syn::Field) -> Result<Self, Self::Error> {
        let mut length_prefixed = false;
        for attr in &field.attrs {
            if attr.path().is_ident("ssh") {
                attr.parse_nested_meta(|meta| {
                    // #[ssh(length_prefixed)]
                    if meta.path.is_ident("length_prefixed") {
                        length_prefixed = true;
                    } else {
                        return Err(syn::Error::new_spanned(meta.path, "unknown attribute"));
                    }
                    Ok(())
                })?;
            }
        }

        Ok(Self { length_prefixed })
    }
}