mkutils-macros 0.1.198

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
82
83
84
85
86
87
88
89
90
91
92
93
94

use crate::error::Error;
use proc_macro::TokenStream;
use proc_macro2::TokenStream as TokenStream2;
use syn::{
    Error as SynError, Ident, ItemImpl, Path, Type, Visibility,
    ext::IdentExt,
    parse::{Parse, ParseStream},
};

enum EmptyType {
    Enum,
    UnitStruct,
    CStruct,
}

impl EmptyType {
    fn get_declaration(&self, ident: &Ident) -> TokenStream2 {
        match self {
            Self::Enum => quote::quote!(enum #ident {}),
            Self::UnitStruct => quote::quote!(struct #ident;),
            Self::CStruct => quote::quote!(struct #ident {}),
        }
    }
}

pub struct Empty {
    visibility: Visibility,
    empty_type: EmptyType,
}

impl Parse for Empty {
    fn parse(parse_stream: ParseStream) -> Result<Self, SynError> {
        let visibility = parse_stream.parse()?;
        let empty_type = if parse_stream.is_empty() {
            EmptyType::Enum
        } else {
            let ident = Ident::parse_any(parse_stream)?;

            match ident.to_string().as_str() {
                "enum" => EmptyType::Enum,
                "unit_struct" => EmptyType::UnitStruct,
                "c_struct" => EmptyType::CStruct,
                _ => {
                    return Err(Error::unexpected_value_multi(
                        &ident,
                        &["enum", "unit_struct", "c_struct"],
                    ));
                }
            }
        };
        let empty = Self { visibility, empty_type };

        Ok(empty)
    }
}

impl Empty {
    fn get_ident(item_impl: &ItemImpl) -> Result<&Ident, SynError> {
        let Type::Path(type_path) = item_impl.self_ty.as_ref() else {
            return Err(Error::unexpected_value(
                item_impl.self_ty.as_ref(),
                std::any::type_name::<Path>(),
            ));
        };
        let Some(segment) = type_path.path.segments.last() else {
            return Err(Error::empty_path(&type_path.path));
        };

        Ok(&segment.ident)
    }

    fn derive_impl(&self, item_impl: &ItemImpl) -> Result<TokenStream2, SynError> {
        let Self { visibility, empty_type } = self;
        let ident = Self::get_ident(item_impl)?;
        let declaration = empty_type.get_declaration(ident);
        let declaration_and_impl_token_stream = quote::quote! {
            #visibility #declaration

            #item_impl
        };

        Ok(declaration_and_impl_token_stream)
    }

    pub fn derive(attr_args_token_stream: TokenStream, input_token_stream: TokenStream) -> TokenStream {
        let empty = syn::parse_macro_input!(attr_args_token_stream as Self);
        let item_impl = syn::parse_macro_input!(input_token_stream);

        empty
            .derive_impl(&item_impl)
            .unwrap_or_else(SynError::into_compile_error)
            .into()
    }
}