macroific_core 3.0.0

Shared functionality for macroific & macroific_macro
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

//! `impl SomeTrait for SomeType`.

use crate::core_ext::*;
use proc_macro2::{Ident, TokenStream};
use quote::{ToTokens, TokenStreamExt};
use syn::{Generics, ImplGenerics, TypeGenerics, WhereClause};
use unspecified::Unspecified;

/// `impl<T> SomeTrait for SomeType<T>` or `impl<T> SomeType<T>`.
///
/// ```
/// # use macroific_core::{elements::*, core_ext::*};
/// # use proc_macro2::*;
/// # use syn::*;
/// # use quote::*;
///
/// // Make <T: Clone> where T: Copy generic bounds for our example
/// let mut generics = Generics::default();
/// generics.params.push(parse_quote!(T: Clone));
/// generics.make_where_clause().predicates.push(parse_quote!(T: Copy));
///
/// let our_trait_name: Path = parse_quote!{ ::foo::Trait };
/// let implemented_for = Ident::create("SomeStruct");
///
/// let g_impl = GenericImpl::new(&generics)
///   .with_trait(our_trait_name) // Can be anything implementing ToTokens
///   .with_target(&implemented_for) // Same
///   .into_token_stream()
///   .to_string();
/// assert_eq!(g_impl, "impl < T : Clone > :: foo :: Trait for SomeStruct < T > where T : Copy");
///
/// let g_impl = GenericImpl::new(generics) // You can give an owned generics argument
///   .with_target(implemented_for) // You can also omit `with_trait`
///   .into_token_stream()
///   .to_string();
///
/// assert_eq!(g_impl, "impl < T : Clone > SomeStruct < T > where T : Copy");
/// ```
#[cfg(feature = "generic-impl")]
pub struct GenericImpl<G, Tgt = Unspecified, Tr = Unspecified> {
    generics: G,
    implemented_for: Tgt,
    implemented_trait: Tr,
}

impl<G> GenericImpl<G> {
    /// Implement using the given [`Generics`] or [`&Generics`](Generics)…
    #[inline]
    pub fn new(generics: G) -> Self
    where
        G: GenericsLike,
    {
        Self {
            generics,
            implemented_trait: Unspecified,
            implemented_for: Unspecified,
        }
    }
}

impl<G, Tgt, Tr> GenericImpl<G, Tgt, Tr> {
    /// Implement the given trait
    #[inline]
    pub fn with_trait<Tr2>(self, trait_name: Tr2) -> GenericImpl<G, Tgt, Tr2> {
        GenericImpl {
            generics: self.generics,
            implemented_trait: trait_name,
            implemented_for: self.implemented_for,
        }
    }

    /// Implement for the given type.
    pub fn with_target<Tgt2>(self, target: Tgt2) -> GenericImpl<G, Tgt2, Tr> {
        GenericImpl {
            generics: self.generics,
            implemented_trait: self.implemented_trait,
            implemented_for: target,
        }
    }
}

impl<G, Tgt> ToTokens for GenericImpl<G, Tgt>
where
    G: GenericsLike,
    Tgt: ToTokens,
{
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let Self {
            generics,
            implemented_for,
            implemented_trait: _,
        } = self;

        let (g1, g2, g3) = generics.split_for_impl();
        tokens.append(Ident::create("impl"));
        g1.to_tokens(tokens);
        implemented_for.to_tokens(tokens);
        g2.to_tokens(tokens);
        g3.to_tokens(tokens);
    }
}

impl<G, Tgt, Tr> ToTokens for GenericImpl<G, Tgt, Tr>
where
    G: GenericsLike,
    Tgt: ToTokens,
    Tr: ToTokens,
{
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let Self {
            generics,
            implemented_for,
            implemented_trait,
        } = self;

        let (g1, g2, g3) = generics.split_for_impl();
        tokens.append(Ident::create("impl"));
        g1.to_tokens(tokens);
        implemented_trait.to_tokens(tokens);
        tokens.append(Ident::create("for"));
        implemented_for.to_tokens(tokens);
        g2.to_tokens(tokens);
        g3.to_tokens(tokens);
    }
}

/// [`Generics`] or something that acts like them.
pub trait GenericsLike {
    /// Mirror of [`Generics::split_for_impl`].
    fn split_for_impl(&self) -> (ImplGenerics<'_>, TypeGenerics<'_>, Option<&WhereClause>);
}

impl<T: GenericsLike> GenericsLike for &T {
    #[inline]
    fn split_for_impl(&self) -> (ImplGenerics<'_>, TypeGenerics<'_>, Option<&WhereClause>) {
        T::split_for_impl(*self)
    }
}

impl GenericsLike for Generics {
    fn split_for_impl(&self) -> (ImplGenerics<'_>, TypeGenerics<'_>, Option<&WhereClause>) {
        Generics::split_for_impl(self)
    }
}

mod unspecified {
    /// Equivalent to `()`, but guaranteed to not get `ToTokens` implemented.
    pub struct Unspecified;
}