eraserhead-derive 1.0.0

Derive for Erase trait in eraserhead crate
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use std::iter;

use proc_macro2::Span;
use quote::quote;

#[proc_macro_derive(Erase)]
pub fn derive_erase(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let mut ast: syn::DeriveInput = syn::parse(input).unwrap();

    inject_erase_bound(&mut ast.generics);
    let (impl_generics, type_generics, where_clause) = ast.generics.split_for_impl();
    let generics_filtered: Vec<_> = filter_generics(&ast.generics).collect();
    let generics_filtered = &generics_filtered;
    let erased_generics: Vec<_> = erase_generics(&ast.generics).collect();

    let where_clause = inject_sized_bound(where_clause, &erased_generics[..]);

    let ty = &ast.ident;
    let vis = &ast.vis;
    let erased_ty = syn::Ident::new(&format!("Erased{}", &ty), Span::call_site());

    quote!(
        #vis struct #erased_ty<#(#generics_filtered)*> {
            _marker: ::std::marker::PhantomData<(#(#generics_filtered)*)>,
        }

        unsafe impl #impl_generics eraserhead::Erase for #ty #type_generics #where_clause {
            type Erased = #erased_ty<#(#erased_generics),*>;

            fn erase(&self) -> std::ptr::NonNull<Self::Erased> {
                unsafe { std::mem::transmute(self) }
            }

            unsafe fn unerase<'__unerase>(erased: std::ptr::NonNull<Self::Erased>)
                -> &'__unerase Self
            {
                std::mem::transmute(erased)
            }
        }
    ).into()
}

fn erase_generics(generics: &syn::Generics) -> impl Iterator<Item = syn::Type> + '_ {
    generics.params.iter().filter_map(|param| match param {
        syn::GenericParam::Lifetime(_)  => None,
        syn::GenericParam::Const(_)     => todo!("const generics not supported"),
        syn::GenericParam::Type(param)  => {
            let seg1 = segment(param.ident.clone());
            let seg2 = segment(syn::Ident::new("Erased", Span::call_site()));
            Some(syn::Type::Path(syn::TypePath {
                qself: None,
                path: syn::Path {
                    leading_colon:  None,
                    segments: iter::once(seg1).chain(iter::once(seg2)).collect(),
                },
            }))
        }
    })
}

fn filter_generics(generics: &syn::Generics) -> impl Iterator<Item = syn::TypeParam> + '_ {
    generics.params.iter().cloned().filter_map(|param| match param {
        syn::GenericParam::Type(mut param)  => {
            param.colon_token = None;
            param.bounds = iter::empty::<syn::TypeParamBound>().collect();
            param.eq_token = None;
            param.default = None;
            Some(param)
        }
        _                                   => None,
    })
}

fn inject_erase_bound(generics: &mut syn::Generics) {
    for param in generics.params.iter_mut() {
        if let syn::GenericParam::Type(param) = param {
            let eraserhead = segment(syn::Ident::new("eraserhead", Span::call_site()));
            let erase = segment(syn::Ident::new("Erase", Span::call_site()));
            param.bounds.push(bound(iter::once(eraserhead).chain(iter::once(erase))));
        }
    }
}

fn inject_sized_bound(where_clause: Option<&syn::WhereClause>, types: &[syn::Type])
    -> syn::WhereClause
{
    let mut where_clause = where_clause.cloned().unwrap_or_else(|| syn::WhereClause {
        where_token: syn::token::Where::default(),
        predicates: iter::empty::<syn::WherePredicate>().collect(),
    });

    for ty in types {
        let sized = bound(iter::once(segment(syn::Ident::new("Sized", Span::call_site()))));
        where_clause.predicates.push(syn::WherePredicate::Type(syn::PredicateType {
            lifetimes: None,
            bounded_ty: ty.clone(),
            colon_token: syn::token::Colon::default(),
            bounds: iter::once(sized).collect(),
        }));
    }

    where_clause
}

fn segment(ident: syn::Ident) -> syn::PathSegment {
    syn::PathSegment {
        ident,
        arguments: syn::PathArguments::None,
    }
}

fn bound(segments: impl Iterator<Item = syn::PathSegment>) -> syn::TypeParamBound {
    let segments = segments.collect();
    syn::TypeParamBound::Trait(syn::TraitBound {
        paren_token: None,
        modifier: syn::TraitBoundModifier::None,
        lifetimes: None,
        path: syn::Path {
            leading_colon: None,
            segments,
        }
    })
}