typekin 0.6.0

new-type pattern with concept of Friends borrowed from c++, no-std and fully const
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

use crate::integral::cfg::IntegralCfg;
use crate::integral::maker::Maker;
use crate::runner;
use crate::runner::MkErr;
use crate::value_type::N;
use quote::quote;
use syn::Fields;
use syn::Type;

pub(crate) fn integral(
    attr: proc_macro::TokenStream,
    item: proc_macro::TokenStream,
) -> proc_macro::TokenStream {
    let cfg = Box::new(syn::parse_macro_input!(attr as IntegralCfg));
    let item = syn::parse_macro_input!(item as syn::ItemStruct);

    return runner::ekran_catching(move || {
        let ty = item.ident.clone();

        let el = if let Fields::Unnamed(fields) = &item.fields
            && fields.unnamed.len() == 1
            && let Type::Path(field) = &fields.unnamed[0].ty
            && let Some(id) = field.path.get_ident()
            && N::rust_names().contains(&id.to_string().as_str())
        {
            id.clone()
        }
        else {
            return item.fail(
                "expected a tuple struct with exactly one field of primitive integral type",
            );
        };

        if !runner::find_repr_transparent(&item.attrs)? {
            return item.fail("expecting #[repr(transparent, ...)]");
        }

        let it = Maker::new(ty, el, cfg)?.ekran()?;

        let stream = quote::quote! {
            #[allow(dead_code)]
            #[allow(unused_qualifications)]
            const _: () = {
                #it
            };
        };

        return Ok(quote! { #item #stream });
    });
}