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
9pub(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_header = totrait_def.generics_tokenizer(
37 InWhat::ImplHeader,
38 WithAssocTys::Yes(WhichSelf::NoSelf),
39 <_tokens.lt_erasedptr,
40 );
41 let gen_params_use_to = totrait_def.generics_tokenizer(
42 InWhat::ItemUse,
43 WithAssocTys::Yes(WhichSelf::NoSelf),
44 <_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 <_tokens.staticlt_erasedptr,
51 );
52
53 let trait_interface_header = totrait_def.generics_tokenizer(
54 InWhat::ImplHeader,
55 WithAssocTys::Yes(WhichSelf::NoSelf),
56 <_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 <_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(iter_item) = &totrait_def.iterator_item {
440 let one_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}