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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

use logid_core::log_id::LogLevel;
use proc_macro::TokenStream;
use quote::{quote, quote_spanned};
use syn::{parse_macro_input, DeriveInput};

#[proc_macro_derive(ErrLogId)]
pub fn derive_err_log_id(input: TokenStream) -> TokenStream {
    derive_log_id(input, LogLevel::Error)
}

#[proc_macro_derive(WarnLogId)]
pub fn derive_warn_log_id(input: TokenStream) -> TokenStream {
    derive_log_id(input, LogLevel::Warn)
}

#[proc_macro_derive(InfoLogId)]
pub fn derive_info_log_id(input: TokenStream) -> TokenStream {
    derive_log_id(input, LogLevel::Info)
}

#[proc_macro_derive(DbgLogId)]
pub fn derive_dbg_log_id(input: TokenStream) -> TokenStream {
    derive_log_id(input, LogLevel::Debug)
}

#[proc_macro_derive(TraceLogId)]
pub fn derive_trace_log_id(input: TokenStream) -> TokenStream {
    derive_log_id(input, LogLevel::Trace)
}

fn derive_log_id(input: TokenStream, log_level: LogLevel) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let ident_name = input.ident;

    let log_token = log_level_as_tokenstream(log_level);

    match input.data {
        syn::Data::Enum(enum_data) => {
            let span = ident_name.span();

            let mut field_identifiers = Vec::new();

            for variant in enum_data.variants {
                let field_name = variant.ident;
                let full_field_name = quote_spanned! {span=>
                    #ident_name::#field_name
                };
                let full_field_name_str =
                    syn::LitStr::new(&full_field_name.to_string().replace(' ', ""), span);
                field_identifiers.push(quote_spanned! {span=>
                    #full_field_name => #full_field_name_str,
                });
            }

            let from_enum = quote_spanned! {span=>
                impl From<#ident_name> for logid_core::log_id::LogId {
                    fn from(value: #ident_name) -> Self {
                        let field_name = match value {
                            #(#field_identifiers)*
                        };

                        logid_core::log_id::LogId::new(
                            env!("CARGO_PKG_NAME"),
                            module_path!(),
                            field_name,
                            #log_token,
                        )
                    }
                }
            };

            TokenStream::from(from_enum)
        }
        syn::Data::Struct(struct_data) => {
            let span = struct_data.struct_token.span;
            from_struct_or_union(ident_name, log_token, span)
        }
        syn::Data::Union(union_data) => {
            let span = union_data.union_token.span;
            from_struct_or_union(ident_name, log_token, span)
        }
    }
}

fn from_struct_or_union(
    ident_name: proc_macro2::Ident,
    log_token: proc_macro2::TokenStream,
    span: proc_macro2::Span,
) -> TokenStream {
    let from = quote_spanned! {span=>
        impl From<#ident_name> for logid_core::log_id::LogId {
            fn from(value: #ident_name) -> Self {
                logid_core::log_id::LogId::new(
                    env!("CARGO_PKG_NAME"),
                    module_path!(),
                    #ident_name,
                    #log_token,
                )
            }
        }
    };

    TokenStream::from(from)
}

#[proc_macro_derive(FromLogId)]
pub fn derive_from_log_id(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let enum_name = input.ident;

    match input.data {
        syn::Data::Enum(enum_data) => {
            let span = enum_name.span();

            let mut from_fields = Vec::new();

            for variant in enum_data.variants {
                let field_name = variant.ident;
                let full_field_name = quote_spanned! {span=>
                    #enum_name::#field_name
                };
                let full_field_name_str =
                    syn::LitStr::new(&full_field_name.to_string().replace(' ', ""), span);
                from_fields.push(quote_spanned! {span=>
                    v if v == #full_field_name_str => #full_field_name,
                });
            }

            let from_log_id = quote_spanned! {span=>
                impl From<logid_core::log_id::LogId> for #enum_name {
                    fn from(value: logid_core::log_id::LogId) -> Self {
                        if value.get_crate_name() != env!("CARGO_PKG_NAME")
                            || value.get_module_path() != module_path!() {

                            return Self::default();
                        }

                        match value.get_identifier() {
                            #(#from_fields)*
                            _ => Self::default(),
                        }
                    }
                }

                impl From<logid_core::logging::intermediary_event::IntermediaryLogEvent> for #enum_name {
                    fn from(value: logid_core::logging::intermediary_event::IntermediaryLogEvent) -> Self {
                        value.finalize().into_event_id().into()
                    }
                }
            };

            TokenStream::from(from_log_id)
        }
        _ => panic!("Derive `FromLogId` is only implemented for enumerations where no item has fields (e.g. SomeEnum::Item(Field) is **not** allowed)."),
    }
}

fn log_level_as_tokenstream(level: LogLevel) -> proc_macro2::TokenStream {
    match level {
        LogLevel::Error => quote! { logid_core::log_id::LogLevel::Error },
        LogLevel::Warn => quote! { logid_core::log_id::LogLevel::Warn },
        LogLevel::Info => quote! { logid_core::log_id::LogLevel::Info },
        LogLevel::Debug => quote! { logid_core::log_id::LogLevel::Debug },
        LogLevel::Trace => quote! { logid_core::log_id::LogLevel::Trace },
    }
}