abi_stable_derive/sabi_trait/
impl_delegations.rs

1use proc_macro2::TokenStream as TokenStream2;
2
3use quote::{quote_spanned, ToTokens};
4
5use as_derive_utils::gen_params_in::InWhat;
6
7use crate::sabi_trait::{TokenizerParams, WhichSelf, WithAssocTys};
8
9/// Generates the code that delegates the implementation of the traits
10/// to the wrapped DynTrait or RObject.
11pub(super) fn delegated_impls(
12    TokenizerParams {
13        arenas: _,
14        ctokens,
15        totrait_def,
16        trait_to,
17        trait_backend,
18        trait_interface,
19        lt_tokens,
20        ..
21    }: TokenizerParams<'_>,
22    mod_: &mut TokenStream2,
23) {
24    let where_preds = &totrait_def.where_preds;
25
26    let impls = totrait_def.trait_flags;
27    let spans = &totrait_def.trait_spans;
28
29    // let gen_params_deser_header=
30    //     totrait_def.generics_tokenizer(
31    //         InWhat::ImplHeader,
32    //         WithAssocTys::Yes(WhichSelf::NoSelf),
33    //         &lt_tokens.lt_de_erasedptr,
34    //     );
35
36    let gen_params_header = totrait_def.generics_tokenizer(
37        InWhat::ImplHeader,
38        WithAssocTys::Yes(WhichSelf::NoSelf),
39        &lt_tokens.lt_erasedptr,
40    );
41    let gen_params_use_to = totrait_def.generics_tokenizer(
42        InWhat::ItemUse,
43        WithAssocTys::Yes(WhichSelf::NoSelf),
44        &lt_tokens.lt_erasedptr,
45    );
46
47    let gen_params_use_to_static = totrait_def.generics_tokenizer(
48        InWhat::ItemUse,
49        WithAssocTys::Yes(WhichSelf::NoSelf),
50        &lt_tokens.staticlt_erasedptr,
51    );
52
53    let trait_interface_header = totrait_def.generics_tokenizer(
54        InWhat::ImplHeader,
55        WithAssocTys::Yes(WhichSelf::NoSelf),
56        &lt_tokens.lt,
57    );
58
59    let trait_interface_use = totrait_def.generics_tokenizer(
60        InWhat::ItemUse,
61        WithAssocTys::Yes(WhichSelf::NoSelf),
62        &ctokens.ts_empty,
63    );
64
65    if impls.debug {
66        let where_preds = where_preds.into_iter();
67
68        quote_spanned!(spans.debug=>
69            impl<#gen_params_header> std::fmt::Debug
70            for #trait_to<#gen_params_use_to>
71            where
72                _ErasedPtr:__sabi_re::AsPtr<PtrTarget=()>,
73                #(#where_preds,)*
74            {
75                #[inline]
76                fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
77                    std::fmt::Debug::fmt(&self.obj,f)
78                }
79            }
80        )
81        .to_tokens(mod_);
82    }
83    if impls.display {
84        let where_preds = where_preds.into_iter();
85
86        quote_spanned!(spans.display=>
87            impl<#gen_params_header> std::fmt::Display
88            for #trait_to<#gen_params_use_to>
89            where
90                _ErasedPtr:__sabi_re::AsPtr<PtrTarget=()>,
91                #(#where_preds,)*
92            {
93                #[inline]
94                fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
95                    std::fmt::Display::fmt(&self.obj,f)
96                }
97            }
98        )
99        .to_tokens(mod_);
100    }
101    if impls.error {
102        let where_preds = where_preds.into_iter();
103
104        quote_spanned!(spans.error=>
105            impl<#gen_params_header> std::error::Error
106            for #trait_to<#gen_params_use_to>
107            where
108                _ErasedPtr:__sabi_re::AsPtr<PtrTarget=()>,
109                #(#where_preds,)*
110            {}
111        )
112        .to_tokens(mod_);
113    }
114    if impls.clone {
115        let where_preds = where_preds.into_iter();
116
117        quote_spanned!(spans.clone=>
118            impl<#gen_params_header> std::clone::Clone
119            for #trait_to<#gen_params_use_to>
120            where
121                #trait_backend<#gen_params_use_to>:Clone,
122                _ErasedPtr:__sabi_re::AsPtr<PtrTarget=()>,
123                #(#where_preds,)*
124            {
125                #[inline]
126                fn clone(&self)->Self{
127                    Self{
128                        obj:std::clone::Clone::clone(&self.obj),
129                        _marker:__sabi_re::UnsafeIgnoredType::DEFAULT,
130                    }
131                }
132            }
133        )
134        .to_tokens(mod_);
135    }
136    if impls.hash {
137        let where_preds = where_preds.into_iter();
138
139        quote_spanned!(spans.hash=>
140            impl<#gen_params_header> std::hash::Hash
141            for #trait_to<#gen_params_use_to>
142            where
143                _ErasedPtr:__sabi_re::AsPtr<PtrTarget=()>,
144                #(#where_preds,)*
145            {
146                #[inline]
147                fn hash<H>(&self, state: &mut H)
148                where
149                    H: std::hash::Hasher
150                {
151                    std::hash::Hash::hash(&self.obj,state)
152                }
153            }
154        )
155        .to_tokens(mod_);
156    }
157    if impls.send {
158        let where_preds = where_preds.into_iter();
159
160        quote_spanned!(spans.send=>
161            unsafe impl<#gen_params_header> std::marker::Send
162            for #trait_to<#gen_params_use_to>
163            where
164                _ErasedPtr:__GetPointerKind,
165                #(#where_preds,)*
166            {}
167        )
168        .to_tokens(mod_);
169    }
170    if impls.sync {
171        let where_preds = where_preds.into_iter();
172
173        quote_spanned!(spans.sync=>
174            unsafe impl<#gen_params_header> std::marker::Sync
175            for #trait_to<#gen_params_use_to>
176            where
177                _ErasedPtr:__GetPointerKind,
178                #(#where_preds,)*
179            {}
180        )
181        .to_tokens(mod_);
182    }
183    if impls.fmt_write {
184        let where_preds = where_preds.into_iter();
185
186        quote_spanned!(spans.fmt_write=>
187            impl<#gen_params_header> std::fmt::Write
188            for #trait_to<#gen_params_use_to>
189            where
190                _ErasedPtr:__sabi_re::AsMutPtr<PtrTarget=()>,
191                #(#where_preds,)*
192            {
193                #[inline]
194                fn write_str(&mut self, s: &str) -> Result<(), std::fmt::Error>{
195                    std::fmt::Write::write_str(&mut self.obj,s)
196                }
197            }
198        )
199        .to_tokens(mod_);
200    }
201    if impls.io_write {
202        let where_preds = where_preds.into_iter();
203
204        quote_spanned!(spans.io_write=>
205            impl<#gen_params_header> std::io::Write
206            for #trait_to<#gen_params_use_to>
207            where
208                _ErasedPtr:__sabi_re::AsMutPtr<PtrTarget=()>,
209                #(#where_preds,)*
210            {
211                fn write(&mut self, buf: &[u8]) -> std::io::Result<usize>{
212                    std::io::Write::write(&mut self.obj,buf)
213                }
214                fn flush(&mut self) -> std::io::Result<()>{
215                    std::io::Write::flush(&mut self.obj)
216                }
217                fn write_all(&mut self, buf: &[u8]) -> std::io::Result<()> {
218                    std::io::Write::write_all(&mut self.obj,buf)
219                }
220            }
221        )
222        .to_tokens(mod_);
223    }
224    if impls.io_read {
225        let where_preds = where_preds.into_iter();
226
227        quote_spanned!(spans.io_read=>
228            impl<#gen_params_header> std::io::Read
229            for #trait_to<#gen_params_use_to>
230            where
231                _ErasedPtr:__sabi_re::AsMutPtr<PtrTarget=()>,
232                #(#where_preds,)*
233            {
234                fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize>{
235                    std::io::Read::read(&mut self.obj,buf)
236                }
237
238                fn read_exact(&mut self, buf: &mut [u8]) -> std::io::Result<()> {
239                    std::io::Read::read_exact(&mut self.obj,buf)
240                }
241            }
242        )
243        .to_tokens(mod_);
244    }
245    if impls.io_buf_read {
246        let where_preds = where_preds.into_iter();
247
248        quote_spanned!(spans.io_buf_read=>
249            impl<#gen_params_header> std::io::BufRead
250            for #trait_to<#gen_params_use_to>
251            where
252                _ErasedPtr:__sabi_re::AsMutPtr<PtrTarget=()>,
253                #(#where_preds,)*
254            {
255                fn fill_buf(&mut self) -> std::io::Result<&[u8]>{
256                    std::io::BufRead::fill_buf(&mut self.obj)
257                }
258
259                fn consume(&mut self, amount:usize ){
260                    std::io::BufRead::consume(&mut self.obj,amount)
261                }
262            }
263        )
264        .to_tokens(mod_);
265    }
266    if impls.io_seek {
267        let where_preds = where_preds.into_iter();
268
269        quote_spanned!(spans.io_seek=>
270            impl<#gen_params_header> std::io::Seek
271            for #trait_to<#gen_params_use_to>
272            where
273                _ErasedPtr:__sabi_re::AsMutPtr<PtrTarget=()>,
274                #(#where_preds,)*
275            {
276                fn seek(&mut self, pos: std::io::SeekFrom) -> std::io::Result<u64>{
277                    std::io::Seek::seek(&mut self.obj,pos)
278                }
279            }
280        )
281        .to_tokens(mod_);
282    }
283
284    let gen_params_header_and2 = totrait_def.generics_tokenizer(
285        InWhat::ImplHeader,
286        WithAssocTys::Yes(WhichSelf::NoSelf),
287        &ctokens.ts_erasedptr_and2,
288    );
289    let gen_params_use_2 = totrait_def.generics_tokenizer(
290        InWhat::ItemUse,
291        WithAssocTys::Yes(WhichSelf::NoSelf),
292        &lt_tokens.staticlt_erasedptr2,
293    );
294
295    if impls.eq {
296        let where_preds = where_preds.into_iter();
297
298        quote_spanned!(spans.eq=>
299            #[allow(clippy::extra_unused_lifetimes)]
300            impl<#gen_params_header> std::cmp::Eq
301            for #trait_to<#gen_params_use_to_static>
302            where
303                _ErasedPtr:__sabi_re::AsPtr<PtrTarget=()>,
304                #(#where_preds,)*
305            {}
306        )
307        .to_tokens(mod_);
308    }
309    if impls.partial_eq {
310        let where_preds = where_preds.into_iter();
311
312        quote_spanned!(spans.partial_eq=>
313            #[allow(clippy::extra_unused_lifetimes)]
314            impl<#gen_params_header_and2> std::cmp::PartialEq<#trait_to<#gen_params_use_2>>
315            for #trait_to<#gen_params_use_to_static>
316            where
317                _ErasedPtr:__sabi_re::AsPtr<PtrTarget=()>,
318                _ErasedPtr2:__sabi_re::AsPtr<PtrTarget=()>,
319                #(#where_preds,)*
320            {
321                fn eq(&self,other:&#trait_to<#gen_params_use_2>)->bool{
322                    std::cmp::PartialEq::eq(
323                        &self.obj,
324                        &other.obj
325                    )
326                }
327            }
328        )
329        .to_tokens(mod_);
330    }
331    if impls.ord {
332        let where_preds = where_preds.into_iter();
333
334        quote_spanned!(spans.ord=>
335            #[allow(clippy::extra_unused_lifetimes)]
336            impl<#gen_params_header> std::cmp::Ord
337            for #trait_to<#gen_params_use_to_static>
338            where
339                _ErasedPtr:__sabi_re::AsPtr<PtrTarget=()>,
340                #(#where_preds,)*
341            {
342                fn cmp(&self,other:&Self)->std::cmp::Ordering{
343                    std::cmp::Ord::cmp(
344                        &self.obj,
345                        &other.obj
346                    )
347                }
348            }
349        )
350        .to_tokens(mod_);
351    }
352    if impls.partial_ord {
353        let where_preds = where_preds.into_iter();
354
355        quote_spanned!(spans.partial_ord=>
356            #[allow(clippy::extra_unused_lifetimes)]
357            impl<#gen_params_header_and2> std::cmp::PartialOrd<#trait_to<#gen_params_use_2>>
358            for #trait_to<#gen_params_use_to_static>
359            where
360                _ErasedPtr:__sabi_re::AsPtr<PtrTarget=()>,
361                _ErasedPtr2:__sabi_re::AsPtr<PtrTarget=()>,
362                #(#where_preds,)*
363            {
364                fn partial_cmp(
365                    &self,
366                    other:&#trait_to<#gen_params_use_2>
367                )->Option<std::cmp::Ordering> {
368                    std::cmp::PartialOrd::partial_cmp(
369                        &self.obj,
370                        &other.obj
371                    )
372                }
373            }
374        )
375        .to_tokens(mod_);
376    }
377
378    // if let Some(deserialize_bound)=&totrait_def.deserialize_bound {
379    //     let deserialize_path=&deserialize_bound.bound.path;
380
381    //     let lifetimes=deserialize_bound.bound.lifetimes.as_ref()
382    //         .map(|x|ToTokenFnMut::new(move|ts|{
383    //             for lt in &x.lifetimes {
384    //                 lt.to_tokens(ts);
385    //                 Comma::default().to_tokens(ts);
386    //             }
387    //         }));
388
389    //     let suffix=&lt_tokens.lt_erasedptr;
390
391    //     let header_generics=arenas.alloc(quote!( #lifetimes #suffix ));
392
393    //     let gen_params_header=
394    //         totrait_def.generics_tokenizer(
395    //             InWhat::ImplHeader,
396    //             WithAssocTys::Yes(WhichSelf::NoSelf),
397    //             header_generics,
398    //         );
399
400    //     let lifetime_param=deserialize_bound.lifetime;
401
402    //     quote!(
403    //         impl<#gen_params_header> #deserialize_path for #trait_to<#gen_params_use_to>
404    //         where
405    //             #trait_backend<#gen_params_use_to>: #deserialize_path,
406    //             _ErasedPtr:__sabi_re::AsPtr<PtrTarget=()>,
407    //             #(#where_preds,)*
408    //         {
409    //             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
410    //             where
411    //                 D: ::serde::Deserializer<#lifetime_param>,
412    //             {
413    //                 #trait_backend::<#gen_params_use_to>::deserialize(deserializer)
414    //                     .map(Self::from_sabi)
415    //             }
416    //         }
417    //     ).to_tokens(mod_);
418    // }
419
420    // if impls.serialize{
421
422    //     quote!(
423    //         impl<#gen_params_header> ::serde::Serialize for #trait_to<#gen_params_use_to>
424    //         where
425    //             #trait_backend<#gen_params_use_to>: ::serde::Serialize,
426    //             _ErasedPtr:__sabi_re::AsPtr<PtrTarget=()>,
427    //             #(#where_preds,)*
428    //         {
429    //             fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
430    //             where
431    //                 S: ::serde::Serializer,
432    //             {
433    //                 self.obj.serialize(serializer)
434    //             }
435    //         }
436    //     ).to_tokens(mod_);
437    // }
438
439    if let Some(iter_item) = &totrait_def.iterator_item {
440        let one_lt = &lt_tokens.one_lt;
441        quote_spanned!(spans.iterator=>
442            impl<#trait_interface_header>
443                abi_stable::erased_types::IteratorItem<#one_lt>
444            for #trait_interface<#trait_interface_use>
445            where
446                #iter_item:#one_lt
447            {
448                type Item=#iter_item;
449            }
450        )
451        .to_tokens(mod_);
452    }
453    if impls.iterator {
454        quote_spanned!(spans.iterator=>
455            impl<#gen_params_header> std::iter::Iterator for #trait_to<#gen_params_use_to>
456            where
457                _ErasedPtr:__GetPointerKind,
458                #trait_backend<#gen_params_use_to>:std::iter::Iterator,
459            {
460                type Item=<#trait_backend<#gen_params_use_to>as std::iter::Iterator>::Item;
461
462                fn next(&mut self)->Option<Self::Item>{
463                    self.obj.next()
464                }
465
466                fn nth(&mut self,nth:usize)->Option<Self::Item>{
467                    self.obj.nth(nth)
468                }
469
470                fn size_hint(&self)->(usize,Option<usize>){
471                    self.obj.size_hint()
472                }
473
474                fn count(self)->usize{
475                    self.obj.count()
476                }
477
478                fn last(self)->Option<Self::Item>{
479                    self.obj.last()
480                }
481            }
482        )
483        .to_tokens(mod_);
484    }
485    if impls.double_ended_iterator {
486        quote_spanned!(spans.double_ended_iterator=>
487            impl<#gen_params_header> std::iter::DoubleEndedIterator
488            for #trait_to<#gen_params_use_to>
489            where
490                _ErasedPtr:__GetPointerKind,
491                #trait_backend<#gen_params_use_to>:std::iter::DoubleEndedIterator,
492            {
493                fn next_back(&mut self)->Option<Self::Item>{
494                    self.obj.next_back()
495                }
496            }
497        )
498        .to_tokens(mod_);
499    }
500}