mkutils-macros 0.1.144

Utility methods, traits, and 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

use crate::utils::{Cat6, Colon, Equals};
use proc_macro::TokenStream;
use proc_macro2::TokenStream as TokenStream2;
use syn::{
    DeriveInput, Error as SynError, Expr, Ident, Type, Visibility,
    parse::{Parse, ParseStream},
};

pub struct ConstAssoc {
    visibility: Visibility,
    ident: Ident,
    ty: Type,
    expr: Expr,
}

impl ConstAssoc {
    const ATTRIBUTE_NAME: &str = "const_assoc";

    fn from_derive_input(input: &DeriveInput) -> Result<Vec<Self>, SynError> {
        let mut const_assocs = Vec::new();

        for attribute in &input.attrs {
            if attribute.path().is_ident(Self::ATTRIBUTE_NAME) {
                const_assocs.push(attribute.parse_args::<Self>()?);
            }
        }

        Ok(const_assocs)
    }

    fn associated_item(&self) -> TokenStream2 {
        let Self {
            visibility,
            ident,
            ty,
            expr,
        } = self;

        quote::quote! {
            #visibility const #ident: #ty = #expr;
        }
    }

    fn derive_impl(input: &DeriveInput) -> Result<TokenStream2, SynError> {
        let DeriveInput { ident, generics, .. } = input;
        let const_assocs = Self::from_derive_input(input)?;
        let (impl_generics, input_generics, input_where_clause) = generics.split_for_impl();
        let associated_items = const_assocs.iter().map(Self::associated_item);
        let impl_block_token_stream = quote::quote! {
            impl #impl_generics #ident #input_generics #input_where_clause {
                #(#associated_items)*
            }
        };

        Ok(impl_block_token_stream)
    }

    pub fn derive(input_token_stream: TokenStream) -> TokenStream {
        let input = syn::parse_macro_input!(input_token_stream);

        Self::derive_impl(&input)
            .unwrap_or_else(SynError::into_compile_error)
            .into()
    }
}

impl Parse for ConstAssoc {
    fn parse(parse_stream: ParseStream) -> Result<Self, SynError> {
        let (visibility, ident, _colon, ty, _equals, expr) = parse_stream
            .parse::<Cat6<Visibility, Ident, Colon, Type, Equals, Expr>>()?
            .into_tuple();
        let const_assoc = Self {
            visibility,
            ident,
            ty,
            expr,
        };

        Ok(const_assoc)
    }
}