fecund_font_flounder_macros/

lib.rs

#![allow(unused_imports)]

use proc_macro2::TokenStream;
use quote::{quote, quote_spanned};
use syn::spanned::Spanned;
use syn::{
    parse_macro_input, parse_quote, Data, DeriveInput, Fields, GenericParam, Generics, Index, Type,
};
use utils::{add_gen, div_gen, sub_gen};


mod utils;


///Naively implements the Add and AddAssign traits, adding every field to each other. 
#[proc_macro_attribute]
pub fn naive_add(_att: proc_macro::TokenStream, item: proc_macro::TokenStream) -> proc_macro::TokenStream {
    
    let mut ory_item = item.clone();

    let input = parse_macro_input!(item as DeriveInput);
    let name = input.ident;
    
    let adding = add_gen(&input.data);
        
    let expanded = quote!{

        impl std::ops::AddAssign for #name{
           fn add_assign(&mut self, rhs: Self) {
               #adding
           } 
        }

        impl std::ops::Add for #name {
            type Output = #name;
            fn add(self, rhs: Self) -> Self::Output {
                let mut mself = self;
                mself += rhs;
                mself
            }
        }

    };
    
        
    let t = proc_macro::TokenStream::from(expanded);

    ory_item.extend(t);
    ory_item

}





///Naively implements the Sub and SubAssign traits, adding every field to each other. 
#[proc_macro_attribute]
pub fn naive_sub(_att: proc_macro::TokenStream, item: proc_macro::TokenStream) -> proc_macro::TokenStream {
    
    let mut ory_item = item.clone();

    let input = parse_macro_input!(item as DeriveInput);
    let name = input.ident;
    
    let subing = sub_gen(&input.data);
        
    let expanded = quote!{

        impl std::ops::SubAssign for #name {
           fn sub_assign(&mut self, rhs: Self) {
               #subing
           } 
        }

        impl std::ops::Sub for #name {
            type Output = #name;
            fn sub(self, rhs: Self) -> Self::Output {
                let mut mself = self;
                mself -= rhs;
                mself
            }
        }

    };
    
        
    let t = proc_macro::TokenStream::from(expanded);

    ory_item.extend(t);
    ory_item

}



/// Naively implements the Div and DivAssign traits. Allows division by the given type in the
/// attribute.
#[proc_macro_attribute]
pub fn naive_div(att: proc_macro::TokenStream, item: proc_macro::TokenStream) -> proc_macro::TokenStream {
    
    let mut ory_item = item.clone();

    let input = parse_macro_input!(item as DeriveInput);
    let att = parse_macro_input!(att as Type);

    let name = input.ident;
    
    let dividing = div_gen(&input.data);
        
    let expanded = quote!{

        impl std::ops::DivAssign< #att > for #name {
            fn div_assign(&mut self, rhs: #att ) {
                #dividing
            }
        }
        impl std::ops::Div< #att > for #name {
            type Output = #name;
            fn div(self, rhs: #att) -> Self::Output {
                let mut mself = self;
                mself /= rhs;
                mself
            }
        }
        
    };


    let t = proc_macro::TokenStream::from(expanded);

    ory_item.extend(t);
    ory_item

}




















//// Add a bound `T: HeapSize` to every type parameter T.
//fn add_trait_bounds(mut generics: Generics) -> Generics {
    //for param in &mut generics.params {
        //if let GenericParam::Type(ref mut type_param) = *param {
            //type_param.bounds.push(parse_quote!(heapsize::HeapSize));
        //}
    //}
    //generics
//}

//// Generate an expression to sum up the heap size of each field.
//fn heap_size_sum(data: &Data) -> TokenStream {
    //match *data {
        //Data::Struct(ref data) => {
            //match data.fields {
                //Fields::Named(ref fields) => {
                    //// Expands to an expression like
                    ////
                    ////     0 + self.x.heap_size() + self.y.heap_size() + self.z.heap_size()
                    ////
                    //// but using fully qualified function call syntax.
                    ////
                    //// We take some care to use the span of each `syn::Field` as
                    //// the span of the corresponding `heap_size_of_children`
                    //// call. This way if one of the field types does not
                    //// implement `HeapSize` then the compiler's error message
                    //// underlines which field it is. An example is shown in the
                    //// readme of the parent directory.
                    //let recurse = fields.named.iter().map(|f| {
                        //let name = &f.ident;
                        //quote_spanned! {f.span()=>
                            //heapsize::HeapSize::heap_size_of_children(&self.#name)
                        //}
                    //});
                    //quote! {
                        //0 #(+ #recurse)*
                    //}
                //}
                //Fields::Unnamed(ref fields) => {
                    //// Expands to an expression like
                    ////
                    ////     0 + self.0.heap_size() + self.1.heap_size() + self.2.heap_size()
                    //let recurse = fields.unnamed.iter().enumerate().map(|(i, f)| {
                        //let index = Index::from(i);
                        //quote_spanned! {f.span()=>
                            //heapsize::HeapSize::heap_size_of_children(&self.#index)
                        //}
                    //});
                    //quote! {
                        //0 #(+ #recurse)*
                    //}
                //}
                //Fields::Unit => {
                    //// Unit structs cannot own more than 0 bytes of heap memory.
                    //quote!(0)
                //}
            //}
        //}
        //Data::Enum(_) | Data::Union(_) => unimplemented!(),
    //}
//}