76 lines
2.0 KiB
Rust
76 lines
2.0 KiB
Rust
use proc_macro::TokenStream;
|
|
use proc_macro2::TokenStream as TokenStream2;
|
|
use quote::{quote, quote_spanned};
|
|
use syn::spanned::Spanned;
|
|
use syn::{
|
|
parse_macro_input, parse_quote, Data, DeriveInput, Fields, GenericParam, Generics, Index,
|
|
};
|
|
|
|
// Add a bound `T: GcTrace` 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!(gc::trace::GcTrace));
|
|
}
|
|
}
|
|
generics
|
|
}
|
|
|
|
// Generate an expression to call trace on every gc field recursively.
|
|
fn gctrace_fields(data: &Data) -> TokenStream2 {
|
|
match *data {
|
|
Data::Struct(ref data) => match data.fields {
|
|
Fields::Named(ref fields) => {
|
|
let recurse = fields.named.iter().map(|f| {
|
|
let name = &f.ident;
|
|
quote_spanned! {f.span()=>
|
|
gc::trace::GCTrace::trace(&self.#name, tracer)
|
|
}
|
|
});
|
|
quote! {
|
|
#(#recurse;)*
|
|
}
|
|
}
|
|
Fields::Unnamed(ref fields) => {
|
|
let recurse = fields.unnamed.iter().enumerate().map(|(i, f)| {
|
|
let index = Index::from(i);
|
|
quote_spanned! {f.span()=>
|
|
gc::trace::GCTrace::trace(&self.#index, tracer)
|
|
}
|
|
});
|
|
quote! {
|
|
#(#recurse;)*
|
|
}
|
|
}
|
|
Fields::Unit => TokenStream2::default(),
|
|
},
|
|
Data::Enum(_) | Data::Union(_) => unimplemented!(),
|
|
}
|
|
}
|
|
|
|
#[proc_macro_derive(GCTrace)]
|
|
pub fn gctrace_derive(input: TokenStream) -> TokenStream {
|
|
// Parse the input tokens into a syntax tree
|
|
let input = parse_macro_input!(input as DeriveInput);
|
|
|
|
let name = input.ident;
|
|
|
|
let generics = add_trait_bounds(input.generics);
|
|
|
|
let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
|
|
let trace_fields = gctrace_fields(&input.data);
|
|
|
|
// Build the output, possibly using quasi-quotation
|
|
//
|
|
let expanded = quote! {
|
|
unsafe impl #impl_generics gc::trace::GCTrace for #name #ty_generics #where_clause {
|
|
fn trace(&self, tracer: &mut gc::trace::GCTracer) {
|
|
#trace_fields
|
|
}
|
|
}
|
|
};
|
|
|
|
// Hand the output tokens back to the compiler
|
|
TokenStream::from(expanded)
|
|
}
|