overloading 0.1.2

A POC crate that utilizes `Fn*` traits to implement partial overloading
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

#![doc = include_str!("../README.md")]

use proc_macro2::{Ident, TokenStream};
use quote::quote;
use syn::{parse_macro_input, spanned::Spanned, Signature};

extern crate proc_macro;
use syn::ItemFn;

#[proc_macro_attribute]
pub fn overloading(
    attrs: proc_macro::TokenStream,
    input: proc_macro::TokenStream,
) -> proc_macro::TokenStream {
    let ItemFn {
        vis, sig, block, ..
    } = parse_macro_input!(input as ItemFn);

    let error = filter_sig(&sig);
    if !error.is_empty() {
        return error.into();
    }
    let Signature {
        mut ident,
        generics,
        inputs,
        output,
        ..
    } = sig;
    let struct_def = if attrs.is_empty() {
        quote! {
            #[allow(non_camel_case_types)]
            #vis struct #ident;
        }
    } else {
        let new_ident = parse_macro_input!(attrs as Ident);
        ident = new_ident;
        quote!()
    };

    let mut tys = vec![];
    let mut pats = vec![];
    for input in inputs {
        match input {
            syn::FnArg::Receiver(kw) => {
                return syn::Error::new(kw.span(), "Method is not implemented")
                    .into_compile_error()
                    .into();
            }
            syn::FnArg::Typed(typed) => {
                tys.push(typed.ty.clone());
                pats.push(typed.pat);
            }
        }
    }
    let output = match output {
        syn::ReturnType::Default => quote!(()),
        syn::ReturnType::Type(_, ty) => quote!(#ty),
    };
    let pat = if pats.is_empty() {
        quote!(_)
    } else {
        quote!( (#(#pats),*,) )
    };
    let arg = if tys.is_empty() {
        quote!(())
    } else {
        quote!( (#(#tys),*,) )
    };

    quote! {
        #struct_def

        impl #generics std::ops::FnOnce<#arg> for #ident {
            type Output = #output;

            extern "rust-call" fn call_once(self, #pat: #arg) -> Self::Output #block
        }

        impl #generics std::ops::FnMut<#arg> for #ident {
            extern "rust-call" fn call_mut(&mut self, #pat: #arg) -> Self::Output #block
        }

        impl #generics std::ops::Fn<#arg> for #ident {
            extern "rust-call" fn call(&self, #pat: #arg) -> Self::Output #block
        }
    }
    .into()
}

fn filter_sig(sig: &Signature) -> TokenStream {
    let Signature {
        constness,
        asyncness,
        unsafety,
        abi,
        variadic,
        ..
    } = sig;

    if let Some(kw) = constness {
        return syn::Error::new(kw.span(), "Const overloading is not implemented")
            .into_compile_error();
    };
    if let Some(kw) = asyncness {
        return syn::Error::new(kw.span(), "Async overloading is not implemented")
            .into_compile_error();
    }
    if let Some(kw) = unsafety {
        return syn::Error::new(kw.span(), "Unsafe Fn* is not supported").to_compile_error();
    }
    if let Some(kw) = abi {
        return syn::Error::new(kw.span(), "Custom ABI is not supported").to_compile_error();
    }
    if let Some(kw) = variadic {
        return syn::Error::new(kw.span(), "Variadic is not supported").to_compile_error();
    }

    TokenStream::new()
}

#[test]
fn test() {}