use proc_macro_error::*;
      
    
    use proc_macro::TokenStream;
      
    
    use syn::{spanned::Spanned, DeriveInput, ItemStruct, Fields, Attribute , parse_macro_input};
      
    
    use quote::quote;
      
  
    fn process_attrs(attrs: &[Attribute]) -> Vec {
      
    
        attrs
      
    
            .iter()
      
    
            .filter_map(|attr| match process_attr(attr) {
      
    
                Ok(res) => Some(res),
      
    
                Err(msg) => {
      
    
                    emit_error!(attr, "Invalid attribute: {}", msg);
      
    
                    None
      
    
                }
      
    
            })
      
    
            .collect()
      
    
    }
      
 
    
    fn process_fields(_attrs: &Fields) -> Vec {
      
    
        // processing fields in pretty much the same way as attributes
      
    
        unimplemented!()
      
    
    }
      
   
    
    #[proc_macro]
      
    
    #[proc_macro_error]
      
    
    pub fn make_answer(input: TokenStream) -> TokenStream {
      
    
        let input = parse_macro_input!(input as ItemStruct);
      
    
        let attrs = process_attrs(&input.attrs);
      
    
    

      
    
        // abort right now if some errors were encountered
      
    
        // at the attributes processing stage
      
    
        abort_if_dirty();
      
    
        let fields = process_fields(&input.fields);
      
    
        // no need to think about emitted errors
      
    
        // #[proc_macro_error] will handle them for you
      
    
        //
      
    
        // just return a TokenStream as you normally would
      
    
        quote!(/* stuff */).into()
      
    
    }