nnn-macros 1.0.1

Generate your newtypes from a single macro.
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

/* Built-in imports */
extern crate alloc;
use alloc::format;
use core::iter;
/* Crate imports */
use crate::{codegen, utils::syn_ext::SynParseBufferExt as _};
/* Dependencies */
use quote::format_ident;
use syn::{
    parse::{Parse, ParseStream},
    parse_quote,
};

pub(crate) struct AssociatedConst {
    visibility: syn::Visibility,
    name: syn::Ident,
    value: syn::Expr,
}

impl Parse for AssociatedConst {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let visibility = input.parse::<syn::Visibility>()?;
        let (name, value) = input.parse_assign::<syn::Expr>()?;
        Ok(Self {
            visibility,
            name,
            value,
        })
    }
}

impl codegen::Gen for AssociatedConst {
    fn gen_impl(
        &self,
        _: &crate::Context,
    ) -> impl Iterator<Item = codegen::Implementation> {
        let visibility = &self.visibility;
        let const_name = &self.name;
        let value = &self.value;

        iter::once(codegen::Implementation::ImplItem(codegen::ImplItem::Const(
            parse_quote! {
                #visibility const #const_name: Self = Self(#value);
            },
        )))
    }

    fn gen_tests(
        &self,
        ctx: &crate::Context,
    ) -> impl Iterator<Item = codegen::TestFn> {
        let const_name = &self.name;
        let type_name = ctx.type_name();

        let err_msg = format!(
            "Type `{type_name}` has invalid value for associated const `{const_name}`.",
        );
        let test_name =
            format_ident!("const_{const_name}_should_have_valid_value");

        iter::once(parse_quote! {
            #[test]
            fn #test_name() {
                use nnn::NNNewType as _;

                let inner_value = <#type_name>::#const_name.into_inner();
                <#type_name>::try_new(inner_value).expect(#err_msg);
            }
        })
    }
}