alioth-macros/src/errors.rs - 93f4782

errors.rs90.00%

// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
use proc_macro::TokenStream;
use quote::quote;
use syn::parse::{Parse, Parser};
use syn::{DeriveInput, GenericArgument, PathArguments, Type, parse_macro_input, parse_quote};
 
fn extract_type_from_box(ty: &Type) -> Option<&Type> {506x
    let Type::Path(type_path) = ty else {506x
        return None;
    };
    if type_path.path.segments.first()?.ident != "Box" {506x
        return None;322x
    }184x
    let arguments = &type_path.path.segments.first()?.arguments;184x
    let PathArguments::AngleBracketed(angle_bracketed) = arguments else {184x
        return None;
    };
    let generic_arg = angle_bracketed.args.first()?;184x
    let GenericArgument::Type(ty) = generic_arg else {184x
        return None;
    };
    if matches!(ty, Type::TraitObject(_)) {184x
        None24x
    } else {
        Some(ty)160x
    }
}506x
 
pub fn trace_error(_attr: TokenStream, item: TokenStream) -> TokenStream {91x
    let mut input = parse_macro_input!(item as DeriveInput);91x
    let syn::Data::Enum(enum_data) = &mut input.data else {91x
        panic!("not an enum")
    };
    for variant in enum_data.variants.iter_mut() {916x
        if matches!(variant.fields, syn::Fields::Unit) {916x
            variant.fields =136x
                syn::Fields::Named(syn::FieldsNamed::parse.parse2(quote! {{}}).unwrap());136x
        }780x
        let syn::Fields::Named(field) = &mut variant.fields else {916x
            panic!("not a named field ")
        };
        field.named.push(916x
            syn::Field::parse_named
                .parse2(quote! {#[snafu(implicit)] _location: ::snafu::Location})916x
                .unwrap(),916x
        );
        if let Some(source) = field.named.iter_mut().find(|f| {1412x
            let name = f.ident.as_ref().unwrap();1412x
            name == "source" || name == "error"1412x
        }) {1412x
            if let Some(inner_type) = extract_type_from_box(&source.ty) {506x
                source160x
                    .attrs160x
                    .push(parse_quote! {#[snafu(source(from(#inner_type, Box::new)))]})160x
            } else {
                source.attrs.push(parse_quote! {#[snafu(source)]})346x
            }
        }410x
    }
 
    quote! { #input }.into()91x
}91x
 
pub fn derive_debug_trace(input: TokenStream) -> TokenStream {91x
    let mut input = parse_macro_input!(input as DeriveInput);91x
    let name = &input.ident;91x
    let syn::Data::Enum(enum_data) = &mut input.data else {91x
        panic!("not an enum")
    };
    let mut debug_trace_arms = vec![];91x
    for variant in enum_data.variants.iter_mut() {883x
        let syn::Fields::Named(field) = &mut variant.fields else {883x
            panic!("not a named field ")
        };
        let mut cfg_attrs = vec![];883x
        for attr in &variant.attrs {921x
            if attr.path().is_ident("cfg") {921x
                cfg_attrs.push(attr);38x
            }883x
        }
        let is_source = |f: &syn::Field| f.ident.as_ref().unwrap() == "source";1646x
        let has_source = field.named.iter().any(is_source);883x
        let is_error = |f: &syn::Field| f.ident.as_ref().unwrap() == "error";1565x
        let has_error = field.named.iter().any(is_error);883x
 
        let variant_name = &variant.ident;883x
        let debug_trace_arm = if has_source {883x
            quote! {204x
                #(#cfg_attrs)*
                #name::#variant_name {_location, source, ..} => {
                    let level = source.debug_trace(f)?;
                    writeln!(f, "{level}: {self}, at {_location}")?;
                    Ok(level + 1)
                }
            }
        } else if has_error {679x
            quote! {285x
                #(#cfg_attrs)*
                #name::#variant_name {_location, error, ..} => {
                    writeln!(f, "0: {error}")?;
                    writeln!(f, "1: {self}, at {_location}")?;
                    Ok(2)
                }
            }
        } else {
            quote! {394x
                #(#cfg_attrs)*
                #name::#variant_name {_location, .. } => {
                    writeln!(f, "0: {self}, at {_location}")?;
                    Ok(1)
                }
            }
        };
        debug_trace_arms.push(debug_trace_arm);883x
    }
 
    quote! {91x
        impl DebugTrace for #name {
            #[inline(never)]
            fn debug_trace(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::result::Result<u32, ::std::fmt::Error> {
                match self {
                    #(#debug_trace_arms)*
                }
            }
        }
 
        impl ::std::fmt::Debug for #name {
            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
                writeln!(f, "{self}")?;
                DebugTrace::debug_trace(self, f)?;
                Ok(())
            }
        }
    }
    .into()91x
}91x
 