95 lines
3.3 KiB
Rust
95 lines
3.3 KiB
Rust
//! Derive support for static Kaptan runtime-log messages.
|
|
|
|
use proc_macro::TokenStream;
|
|
use quote::quote;
|
|
use syn::{Data, DeriveInput, Error, Fields, parse_macro_input, parse_quote};
|
|
|
|
/// Implements [`kaptan_log::ErrorReport`], [`core::fmt::Display`], and
|
|
/// [`core::error::Error`] for enums.
|
|
///
|
|
/// Each enum variant receives one static message in the form
|
|
/// `module::Type::Variant`. The derive deliberately accepts no attributes:
|
|
/// text logging has no user-provided numeric catalog allocation.
|
|
#[proc_macro_derive(KaptanError)]
|
|
pub fn derive_kaptan_error(input: TokenStream) -> TokenStream {
|
|
let input = parse_macro_input!(input as DeriveInput);
|
|
match expand(input) {
|
|
Ok(tokens) => tokens.into(),
|
|
Err(error) => error.into_compile_error().into(),
|
|
}
|
|
}
|
|
|
|
fn expand(input: DeriveInput) -> Result<proc_macro2::TokenStream, Error> {
|
|
let DeriveInput {
|
|
ident,
|
|
generics,
|
|
data,
|
|
..
|
|
} = input;
|
|
let Data::Enum(data) = data else {
|
|
let kind = match data {
|
|
Data::Struct(_) => "structs",
|
|
Data::Union(_) => "unions",
|
|
Data::Enum(_) => unreachable!("enum handled above"),
|
|
};
|
|
return Err(Error::new_spanned(
|
|
ident,
|
|
format!("KaptanError can only be derived for enums, not {kind}"),
|
|
));
|
|
};
|
|
|
|
let arms = data.variants.iter().map(|variant| {
|
|
let variant_ident = &variant.ident;
|
|
let pattern = match &variant.fields {
|
|
Fields::Unit => quote!(Self::#variant_ident),
|
|
Fields::Unnamed(_) => quote!(Self::#variant_ident(..)),
|
|
Fields::Named(_) => quote!(Self::#variant_ident { .. }),
|
|
};
|
|
quote! {
|
|
#pattern => {
|
|
static ERROR: ::kaptan_log::StaticError =
|
|
::kaptan_log::StaticError::new(concat!(
|
|
module_path!(),
|
|
"::",
|
|
stringify!(#ident),
|
|
"::",
|
|
stringify!(#variant_ident),
|
|
));
|
|
&ERROR
|
|
}
|
|
}
|
|
});
|
|
let (impl_generics, type_generics, where_clause) = generics.split_for_impl();
|
|
let mut error_generics = generics.clone();
|
|
error_generics
|
|
.make_where_clause()
|
|
.predicates
|
|
.push(parse_quote!(#ident #type_generics: ::core::fmt::Debug));
|
|
let (error_impl_generics, error_type_generics, error_where_clause) =
|
|
error_generics.split_for_impl();
|
|
|
|
Ok(quote! {
|
|
impl #impl_generics ::kaptan_log::ErrorReport for #ident #type_generics #where_clause {
|
|
fn static_error(&self) -> &'static ::kaptan_log::StaticError {
|
|
match self {
|
|
#(#arms),*
|
|
}
|
|
}
|
|
}
|
|
|
|
impl #impl_generics ::core::fmt::Display for #ident #type_generics #where_clause {
|
|
fn fmt(
|
|
&self,
|
|
formatter: &mut ::core::fmt::Formatter<'_>,
|
|
) -> ::core::fmt::Result {
|
|
formatter.write_str(
|
|
<Self as ::kaptan_log::ErrorReport>::static_error(self).path(),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl #error_impl_generics ::core::error::Error
|
|
for #ident #error_type_generics #error_where_clause {}
|
|
})
|
|
}
|