derived 0.4.2

Derive macros for automating the boring stuff
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

use ::proc_macro::TokenStream;
use ::quote::quote;
use ::syn::{spanned::Spanned, Attribute, Data, DataStruct, DeriveInput, Fields, Ident, Type};

pub(crate) const ATTR_PHANTOM: &str = "phantom";

gen_typeset! {
    u8, i8, u16, i16, u32, i32, u64, i64, u128, i128, str, bool, usize, isize, char, f32, f64
}

/// Returns the field names and their corresponding type from the AST (returning an error
/// if it isn't a struct)
pub fn get_struct_field_names(
    ast: &DeriveInput,
) -> Result<Vec<(&Ident, &Type, &Vec<Attribute>)>, TokenStream> {
    let fields = match &ast.data {
        Data::Struct(DataStruct {
            fields: Fields::Named(fields),
            ..
        }) => &fields.named,
        _ => {
            return Err(
                syn::Error::new_spanned(ast, "this macro can only be used on structs")
                    .into_compile_error()
                    .into(),
            );
        }
    };
    if fields.is_empty() {
        Ok(Vec::new())
    } else {
        Ok(fields
            .iter()
            .map(|field| {
                let fname = field.ident.as_ref().unwrap();
                (fname, &field.ty, &field.attrs)
            })
            .collect())
    }
}

pub(crate) fn single_instance_of_attr(
    attrs: &[Attribute],
    target: &str,
) -> Result<bool, TokenStream> {
    let mut span = None;
    let has_attr = attrs
        .iter()
        .filter(|attr| {
            span = Some((*attr).span());
            attr.path.is_ident(target)
        })
        .count();
    match has_attr {
        0 => Ok(false),
        1 => Ok(true),
        _ => Err(syn::Error::new(
            span.unwrap(),
            format!("Found duplicate attributes for `{}`", target),
        )
        .into_compile_error()
        .into()),
    }
}

/// Returns a const-ed (if required) func "header"
pub(crate) fn get_func_header(
    attrs: &[Attribute],
    target: &str,
) -> Result<quote::__private::TokenStream, TokenStream> {
    let r = if self::single_instance_of_attr(attrs, target)? {
        quote! {
            pub const fn
        }
    } else {
        quote! {
            pub fn
        }
    };
    Ok(r)
}