buf_sized_derive 0.1.0

Derive macros to calculate buffer sizes needed by types
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

//! A library for deriving the `BufSized` trait.
//!
//! # Examples
//! ```
//! use buf_sized_derive::BufSized;
//!
//! #[derive(BufSized)]
//! struct Data {
//!     header: u8,
//!     num: u128,
//!     payload: [u8; 12],
//!     crc: u32,
//! }
//! ```
use proc_macro2::TokenStream;
use quote::quote;
use syn::{
    parse_macro_input, parse_quote, Data, DeriveInput, Field, Fields, GenericParam, Generics, Type,
    TypeParamBound,
};

/// Derive the `BufSized` trait for a struct.
#[proc_macro_derive(BufSized)]
pub fn buf_sized(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = input.ident;
    let generics = add_trait_bounds(input.generics, &parse_quote!(::buf_sized::BufSized));
    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
    let buf_size = sum_buf_size(input.data);
    let expanded = quote! {
        impl #impl_generics ::buf_sized::BufSized for #name #ty_generics #where_clause {
            const BUF_SIZE: usize = #buf_size;
        }
    };

    proc_macro::TokenStream::from(expanded)
}

fn add_trait_bounds(mut generics: Generics, trait_name: &TypeParamBound) -> Generics {
    for param in &mut generics.params {
        if let GenericParam::Type(ref mut type_param) = *param {
            type_param.bounds.push(trait_name.clone());
        }
    }

    generics
}

fn sum_buf_size(data: Data) -> TokenStream {
    let mut result = quote! {0usize};

    match data {
        Data::Struct(structure) => match structure.fields {
            Fields::Named(fields) => {
                result.add_fields(fields.named);
            }
            Fields::Unit => (),
            Fields::Unnamed(fields) => {
                result.add_fields(fields.unnamed);
            }
        },
        Data::Enum(_) | Data::Union(_) => {
            unimplemented!("Enums and unions are not supported");
        }
    }

    result
}

trait TokenStreamExt {
    fn add_fields<T>(&mut self, fields: T)
    where
        T: IntoIterator<Item = Field>;
    fn add_field(&mut self, field: Field);
    fn add_type(&mut self, typ: Type);
}

impl TokenStreamExt for TokenStream {
    fn add_fields<T>(&mut self, fields: T)
    where
        T: IntoIterator<Item = Field>,
    {
        for field in fields {
            self.add_field(field);
        }
    }

    fn add_field(&mut self, field: Field) {
        self.add_type(field.ty);
    }

    fn add_type(&mut self, typ: Type) {
        self.extend(quote! { + <#typ as ::buf_sized::BufSized>::BUF_SIZE });
    }
}