intertrait-nostd-macros 0.2.3

Macros for intertrait crate, which allows for direct casting between trait objects
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

use std::collections::HashSet;

use proc_macro2::TokenStream;
use quote::{quote, quote_spanned, ToTokens};
use syn::punctuated::Punctuated;
use syn::spanned::Spanned;
use syn::Token;
use syn::{
    AngleBracketedGenericArguments, Binding, GenericArgument, ImplItem, ItemImpl, Path,
    PathArguments,
};
use PathArguments::AngleBracketed;

use crate::args::Flag;
use crate::gen_caster::generate_caster;

pub fn process(flags: &HashSet<Flag>, input: ItemImpl) -> TokenStream {
    let ItemImpl {
        ref self_ty,
        ref trait_,
        ref items,
        ..
    } = input;

    let generated = match trait_ {
        None => quote_spanned! {
            self_ty.span() => compile_error!("#[cast_to] should only be on an impl of a trait");
        },
        Some(trait_) => match trait_ {
            (Some(bang), _, _) => quote_spanned! {
                bang.span() => compile_error!("#[cast_to] is not for !Trait impl");
            },
            (None, path, _) => {
                let path = fully_bound_trait(path, items);
                generate_caster(self_ty, &path, flags.contains(&Flag::Sync))
            }
        },
    };

    quote! {
        #input
        #generated
    }
}

fn fully_bound_trait(path: &Path, items: &[ImplItem]) -> impl ToTokens {
    let bindings = items
        .iter()
        .filter_map(|item| {
            if let ImplItem::Type(assoc_ty) = item {
                Some(GenericArgument::Binding(Binding {
                    ident: assoc_ty.ident.to_owned(),
                    eq_token: Default::default(),
                    ty: assoc_ty.ty.to_owned(),
                }))
            } else {
                None
            }
        })
        .collect::<Punctuated<_, Token![,]>>();

    let mut path = path.clone();

    if bindings.is_empty() {
        return path;
    }

    if let Some(last) = path.segments.last_mut() {
        match &mut last.arguments {
            PathArguments::None => {
                last.arguments = AngleBracketed(AngleBracketedGenericArguments {
                    colon2_token: None,
                    lt_token: Default::default(),
                    args: bindings,
                    gt_token: Default::default(),
                })
            }
            AngleBracketed(args) => args.args.extend(bindings),
            _ => {}
        }
    }
    path
}