erased_serde/
ser.rs

1use self::ErrorImpl::ShortCircuit;
2use crate::error::Error;
3use crate::sealed;
4use alloc::boxed::Box;
5use alloc::string::{String, ToString};
6use core::fmt::{self, Debug, Display};
7use serde::ser::{
8    SerializeMap as _, SerializeSeq as _, SerializeStruct as _, SerializeStructVariant as _,
9    SerializeTuple as _, SerializeTupleStruct as _, SerializeTupleVariant as _,
10};
11
12// TRAITS //////////////////////////////////////////////////////////////////////
13
14/// An object-safe equivalent of Serde's `Serialize` trait.
15///
16/// Any implementation of Serde's `Serialize` converts seamlessly to a
17/// `&dyn erased_serde::Serialize` or `Box<dyn erased_serde::Serialize>` trait
18/// object.
19///
20/// ```rust
21/// use erased_serde::{Serialize, Serializer};
22/// use std::collections::BTreeMap as Map;
23/// use std::io;
24///
25/// fn main() {
26///     // Construct some serializers.
27///     let json = &mut serde_json::Serializer::new(io::stdout());
28///     let cbor = &mut serde_cbor::Serializer::new(serde_cbor::ser::IoWrite::new(io::stdout()));
29///
30///     // The values in this map are boxed trait objects. Ordinarily this would not
31///     // be possible with serde::Serializer because of object safety, but type
32///     // erasure makes it possible with erased_serde::Serializer.
33///     let mut formats: Map<&str, Box<dyn Serializer>> = Map::new();
34///     formats.insert("json", Box::new(<dyn Serializer>::erase(json)));
35///     formats.insert("cbor", Box::new(<dyn Serializer>::erase(cbor)));
36///
37///     // These are boxed trait objects as well. Same thing here - type erasure
38///     // makes this possible.
39///     let mut values: Map<&str, Box<dyn Serialize>> = Map::new();
40///     values.insert("vec", Box::new(vec!["a", "b"]));
41///     values.insert("int", Box::new(65536));
42///
43///     // Pick a Serializer out of the formats map.
44///     let format = formats.get_mut("json").unwrap();
45///
46///     // Pick a Serialize out of the values map.
47///     let value = values.get("vec").unwrap();
48///
49///     // This line prints `["a","b"]` to stdout.
50///     value.erased_serialize(format).unwrap();
51/// }
52/// ```
53///
54/// This trait is sealed and can only be implemented via a `serde::Serialize`
55/// impl.
56#[cfg_attr(
57    not(no_diagnostic_namespace),
58    diagnostic::on_unimplemented(
59        message = "the trait bound `{Self}: serde::Serialize` is not satisfied",
60        label = "the trait `serde::Serialize` is not implemented for `{Self}`, so it does not implement `erased_serde::Serialize`",
61    )
62)]
63pub trait Serialize: sealed::serialize::Sealed {
64    fn erased_serialize(&self, serializer: &mut dyn Serializer) -> Result<(), Error>;
65
66    #[doc(hidden)]
67    fn do_erased_serialize(&self, serializer: &mut dyn Serializer) -> Result<(), ErrorImpl>;
68}
69
70/// An object-safe equivalent of Serde's `Serializer` trait.
71///
72/// Any implementation of Serde's `Serializer` can be converted to a
73/// `&dyn erased_serde::Serializer` or `Box<dyn erased_serde::Serializer>` trait
74/// object using `erased_serde::Serializer::erase`.
75///
76/// ```rust
77/// use erased_serde::{Serialize, Serializer};
78/// use std::collections::BTreeMap as Map;
79/// use std::io;
80///
81/// fn main() {
82///     // Construct some serializers.
83///     let json = &mut serde_json::Serializer::new(io::stdout());
84///     let cbor = &mut serde_cbor::Serializer::new(serde_cbor::ser::IoWrite::new(io::stdout()));
85///
86///     // The values in this map are boxed trait objects. Ordinarily this would not
87///     // be possible with serde::Serializer because of object safety, but type
88///     // erasure makes it possible with erased_serde::Serializer.
89///     let mut formats: Map<&str, Box<dyn Serializer>> = Map::new();
90///     formats.insert("json", Box::new(<dyn Serializer>::erase(json)));
91///     formats.insert("cbor", Box::new(<dyn Serializer>::erase(cbor)));
92///
93///     // These are boxed trait objects as well. Same thing here - type erasure
94///     // makes this possible.
95///     let mut values: Map<&str, Box<dyn Serialize>> = Map::new();
96///     values.insert("vec", Box::new(vec!["a", "b"]));
97///     values.insert("int", Box::new(65536));
98///
99///     // Pick a Serializer out of the formats map.
100///     let format = formats.get_mut("json").unwrap();
101///
102///     // Pick a Serialize out of the values map.
103///     let value = values.get("vec").unwrap();
104///
105///     // This line prints `["a","b"]` to stdout.
106///     value.erased_serialize(format).unwrap();
107/// }
108/// ```
109///
110/// This trait is sealed and can only be implemented via a `serde::Serializer`
111/// impl.
112pub trait Serializer: sealed::serializer::Sealed {
113    fn erased_serialize_bool(&mut self, v: bool);
114    fn erased_serialize_i8(&mut self, v: i8);
115    fn erased_serialize_i16(&mut self, v: i16);
116    fn erased_serialize_i32(&mut self, v: i32);
117    fn erased_serialize_i64(&mut self, v: i64);
118    fn erased_serialize_i128(&mut self, v: i128);
119    fn erased_serialize_u8(&mut self, v: u8);
120    fn erased_serialize_u16(&mut self, v: u16);
121    fn erased_serialize_u32(&mut self, v: u32);
122    fn erased_serialize_u64(&mut self, v: u64);
123    fn erased_serialize_u128(&mut self, v: u128);
124    fn erased_serialize_f32(&mut self, v: f32);
125    fn erased_serialize_f64(&mut self, v: f64);
126    fn erased_serialize_char(&mut self, v: char);
127    fn erased_serialize_str(&mut self, v: &str);
128    fn erased_serialize_bytes(&mut self, v: &[u8]);
129    fn erased_serialize_none(&mut self);
130    fn erased_serialize_some(&mut self, value: &dyn Serialize);
131    fn erased_serialize_unit(&mut self);
132    fn erased_serialize_unit_struct(&mut self, name: &'static str);
133    fn erased_serialize_unit_variant(
134        &mut self,
135        name: &'static str,
136        variant_index: u32,
137        variant: &'static str,
138    );
139    fn erased_serialize_newtype_struct(&mut self, name: &'static str, value: &dyn Serialize);
140    fn erased_serialize_newtype_variant(
141        &mut self,
142        name: &'static str,
143        variant_index: u32,
144        variant: &'static str,
145        value: &dyn Serialize,
146    );
147    fn erased_serialize_seq(
148        &mut self,
149        len: Option<usize>,
150    ) -> Result<&mut dyn SerializeSeq, ErrorImpl>;
151    fn erased_serialize_tuple(&mut self, len: usize) -> Result<&mut dyn SerializeTuple, ErrorImpl>;
152    fn erased_serialize_tuple_struct(
153        &mut self,
154        name: &'static str,
155        len: usize,
156    ) -> Result<&mut dyn SerializeTupleStruct, ErrorImpl>;
157    fn erased_serialize_tuple_variant(
158        &mut self,
159        name: &'static str,
160        variant_index: u32,
161        variant: &'static str,
162        len: usize,
163    ) -> Result<&mut dyn SerializeTupleVariant, ErrorImpl>;
164    fn erased_serialize_map(
165        &mut self,
166        len: Option<usize>,
167    ) -> Result<&mut dyn SerializeMap, ErrorImpl>;
168    fn erased_serialize_struct(
169        &mut self,
170        name: &'static str,
171        len: usize,
172    ) -> Result<&mut dyn SerializeStruct, ErrorImpl>;
173    fn erased_serialize_struct_variant(
174        &mut self,
175        name: &'static str,
176        variant_index: u32,
177        variant: &'static str,
178        len: usize,
179    ) -> Result<&mut dyn SerializeStructVariant, ErrorImpl>;
180    fn erased_is_human_readable(&self) -> bool;
181    #[doc(hidden)]
182    fn erased_display_error(&self) -> &dyn Display;
183}
184
185impl dyn Serializer {
186    return_impl_trait! {
187        /// Convert any Serde `Serializer` to a trait object.
188        ///
189        /// ```rust
190        /// use erased_serde::{Serialize, Serializer};
191        /// use std::collections::BTreeMap as Map;
192        /// use std::io;
193        ///
194        /// fn main() {
195        ///     // Construct some serializers.
196        ///     let json = &mut serde_json::Serializer::new(io::stdout());
197        ///     let cbor = &mut serde_cbor::Serializer::new(serde_cbor::ser::IoWrite::new(io::stdout()));
198        ///
199        ///     // The values in this map are boxed trait objects. Ordinarily this would not
200        ///     // be possible with serde::Serializer because of object safety, but type
201        ///     // erasure makes it possible with erased_serde::Serializer.
202        ///     let mut formats: Map<&str, Box<dyn Serializer>> = Map::new();
203        ///     formats.insert("json", Box::new(<dyn Serializer>::erase(json)));
204        ///     formats.insert("cbor", Box::new(<dyn Serializer>::erase(cbor)));
205        ///
206        ///     // These are boxed trait objects as well. Same thing here - type erasure
207        ///     // makes this possible.
208        ///     let mut values: Map<&str, Box<dyn Serialize>> = Map::new();
209        ///     values.insert("vec", Box::new(vec!["a", "b"]));
210        ///     values.insert("int", Box::new(65536));
211        ///
212        ///     // Pick a Serializer out of the formats map.
213        ///     let format = formats.get_mut("json").unwrap();
214        ///
215        ///     // Pick a Serialize out of the values map.
216        ///     let value = values.get("vec").unwrap();
217        ///
218        ///     // This line prints `["a","b"]` to stdout.
219        ///     value.erased_serialize(format).unwrap();
220        /// }
221        /// ```
222        pub fn erase<S>(serializer: S) -> impl Serializer [erase::Serializer<S>]
223        where
224            S: serde::Serializer,
225        {
226            erase::Serializer::new(serializer)
227        }
228    }
229}
230
231// IMPL ERASED SERDE FOR SERDE /////////////////////////////////////////////////
232
233impl<T> Serialize for T
234where
235    T: ?Sized + serde::Serialize,
236{
237    fn erased_serialize(&self, serializer: &mut dyn Serializer) -> Result<(), Error> {
238        match self.do_erased_serialize(serializer) {
239            Ok(()) => Ok(()),
240            Err(ShortCircuit) => Err(serde::ser::Error::custom(serializer.erased_display_error())),
241            Err(ErrorImpl::Custom(msg)) => Err(serde::ser::Error::custom(msg)),
242        }
243    }
244
245    fn do_erased_serialize(&self, serializer: &mut dyn Serializer) -> Result<(), ErrorImpl> {
246        self.serialize(MakeSerializer(serializer))
247    }
248}
249
250impl<T> sealed::serialize::Sealed for T where T: ?Sized + serde::Serialize {}
251
252mod erase {
253    use core::mem;
254
255    pub enum Serializer<S>
256    where
257        S: serde::Serializer,
258    {
259        Ready(S),
260        Seq(S::SerializeSeq),
261        Tuple(S::SerializeTuple),
262        TupleStruct(S::SerializeTupleStruct),
263        TupleVariant(S::SerializeTupleVariant),
264        Map(S::SerializeMap),
265        Struct(S::SerializeStruct),
266        StructVariant(S::SerializeStructVariant),
267        Error(S::Error),
268        Complete(S::Ok),
269        Unusable,
270    }
271
272    impl<S> Serializer<S>
273    where
274        S: serde::Serializer,
275    {
276        pub(crate) fn new(serializer: S) -> Self {
277            Serializer::Ready(serializer)
278        }
279
280        pub(crate) fn take(&mut self) -> Self {
281            mem::replace(self, Serializer::Unusable)
282        }
283
284        pub(crate) fn take_serializer(&mut self) -> S {
285            match self.take() {
286                Serializer::Ready(serializer) => serializer,
287                _ => unreachable!(),
288            }
289        }
290    }
291}
292
293impl<T> Serializer for erase::Serializer<T>
294where
295    T: serde::Serializer,
296{
297    fn erased_serialize_bool(&mut self, v: bool) {
298        *self = match self.take_serializer().serialize_bool(v) {
299            Ok(ok) => erase::Serializer::Complete(ok),
300            Err(err) => erase::Serializer::Error(err),
301        };
302    }
303
304    fn erased_serialize_i8(&mut self, v: i8) {
305        *self = match self.take_serializer().serialize_i8(v) {
306            Ok(ok) => erase::Serializer::Complete(ok),
307            Err(err) => erase::Serializer::Error(err),
308        };
309    }
310
311    fn erased_serialize_i16(&mut self, v: i16) {
312        *self = match self.take_serializer().serialize_i16(v) {
313            Ok(ok) => erase::Serializer::Complete(ok),
314            Err(err) => erase::Serializer::Error(err),
315        };
316    }
317
318    fn erased_serialize_i32(&mut self, v: i32) {
319        *self = match self.take_serializer().serialize_i32(v) {
320            Ok(ok) => erase::Serializer::Complete(ok),
321            Err(err) => erase::Serializer::Error(err),
322        };
323    }
324
325    fn erased_serialize_i64(&mut self, v: i64) {
326        *self = match self.take_serializer().serialize_i64(v) {
327            Ok(ok) => erase::Serializer::Complete(ok),
328            Err(err) => erase::Serializer::Error(err),
329        };
330    }
331
332    fn erased_serialize_i128(&mut self, v: i128) {
333        *self = match self.take_serializer().serialize_i128(v) {
334            Ok(ok) => erase::Serializer::Complete(ok),
335            Err(err) => erase::Serializer::Error(err),
336        };
337    }
338
339    fn erased_serialize_u8(&mut self, v: u8) {
340        *self = match self.take_serializer().serialize_u8(v) {
341            Ok(ok) => erase::Serializer::Complete(ok),
342            Err(err) => erase::Serializer::Error(err),
343        };
344    }
345
346    fn erased_serialize_u16(&mut self, v: u16) {
347        *self = match self.take_serializer().serialize_u16(v) {
348            Ok(ok) => erase::Serializer::Complete(ok),
349            Err(err) => erase::Serializer::Error(err),
350        };
351    }
352
353    fn erased_serialize_u32(&mut self, v: u32) {
354        *self = match self.take_serializer().serialize_u32(v) {
355            Ok(ok) => erase::Serializer::Complete(ok),
356            Err(err) => erase::Serializer::Error(err),
357        };
358    }
359
360    fn erased_serialize_u64(&mut self, v: u64) {
361        *self = match self.take_serializer().serialize_u64(v) {
362            Ok(ok) => erase::Serializer::Complete(ok),
363            Err(err) => erase::Serializer::Error(err),
364        };
365    }
366
367    fn erased_serialize_u128(&mut self, v: u128) {
368        *self = match self.take_serializer().serialize_u128(v) {
369            Ok(ok) => erase::Serializer::Complete(ok),
370            Err(err) => erase::Serializer::Error(err),
371        };
372    }
373
374    fn erased_serialize_f32(&mut self, v: f32) {
375        *self = match self.take_serializer().serialize_f32(v) {
376            Ok(ok) => erase::Serializer::Complete(ok),
377            Err(err) => erase::Serializer::Error(err),
378        };
379    }
380
381    fn erased_serialize_f64(&mut self, v: f64) {
382        *self = match self.take_serializer().serialize_f64(v) {
383            Ok(ok) => erase::Serializer::Complete(ok),
384            Err(err) => erase::Serializer::Error(err),
385        };
386    }
387
388    fn erased_serialize_char(&mut self, v: char) {
389        *self = match self.take_serializer().serialize_char(v) {
390            Ok(ok) => erase::Serializer::Complete(ok),
391            Err(err) => erase::Serializer::Error(err),
392        };
393    }
394
395    fn erased_serialize_str(&mut self, v: &str) {
396        *self = match self.take_serializer().serialize_str(v) {
397            Ok(ok) => erase::Serializer::Complete(ok),
398            Err(err) => erase::Serializer::Error(err),
399        };
400    }
401
402    fn erased_serialize_bytes(&mut self, v: &[u8]) {
403        *self = match self.take_serializer().serialize_bytes(v) {
404            Ok(ok) => erase::Serializer::Complete(ok),
405            Err(err) => erase::Serializer::Error(err),
406        };
407    }
408
409    fn erased_serialize_none(&mut self) {
410        *self = match self.take_serializer().serialize_none() {
411            Ok(ok) => erase::Serializer::Complete(ok),
412            Err(err) => erase::Serializer::Error(err),
413        };
414    }
415
416    fn erased_serialize_some(&mut self, value: &dyn Serialize) {
417        *self = match self.take_serializer().serialize_some(value) {
418            Ok(ok) => erase::Serializer::Complete(ok),
419            Err(err) => erase::Serializer::Error(err),
420        };
421    }
422
423    fn erased_serialize_unit(&mut self) {
424        *self = match self.take_serializer().serialize_unit() {
425            Ok(ok) => erase::Serializer::Complete(ok),
426            Err(err) => erase::Serializer::Error(err),
427        };
428    }
429
430    fn erased_serialize_unit_struct(&mut self, name: &'static str) {
431        *self = match self.take_serializer().serialize_unit_struct(name) {
432            Ok(ok) => erase::Serializer::Complete(ok),
433            Err(err) => erase::Serializer::Error(err),
434        };
435    }
436
437    fn erased_serialize_unit_variant(
438        &mut self,
439        name: &'static str,
440        variant_index: u32,
441        variant: &'static str,
442    ) {
443        *self = match self
444            .take_serializer()
445            .serialize_unit_variant(name, variant_index, variant)
446        {
447            Ok(ok) => erase::Serializer::Complete(ok),
448            Err(err) => erase::Serializer::Error(err),
449        };
450    }
451
452    fn erased_serialize_newtype_struct(&mut self, name: &'static str, value: &dyn Serialize) {
453        *self = match self.take_serializer().serialize_newtype_struct(name, value) {
454            Ok(ok) => erase::Serializer::Complete(ok),
455            Err(err) => erase::Serializer::Error(err),
456        };
457    }
458
459    fn erased_serialize_newtype_variant(
460        &mut self,
461        name: &'static str,
462        variant_index: u32,
463        variant: &'static str,
464        value: &dyn Serialize,
465    ) {
466        *self = match self.take_serializer().serialize_newtype_variant(
467            name,
468            variant_index,
469            variant,
470            value,
471        ) {
472            Ok(ok) => erase::Serializer::Complete(ok),
473            Err(err) => erase::Serializer::Error(err),
474        };
475    }
476
477    fn erased_serialize_seq(
478        &mut self,
479        len: Option<usize>,
480    ) -> Result<&mut dyn SerializeSeq, ErrorImpl> {
481        match self.take_serializer().serialize_seq(len) {
482            Ok(ok) => {
483                *self = erase::Serializer::Seq(ok);
484                Ok(self)
485            }
486            Err(err) => {
487                *self = erase::Serializer::Error(err);
488                Err(ShortCircuit)
489            }
490        }
491    }
492
493    fn erased_serialize_tuple(&mut self, len: usize) -> Result<&mut dyn SerializeTuple, ErrorImpl> {
494        match self.take_serializer().serialize_tuple(len) {
495            Ok(ok) => {
496                *self = erase::Serializer::Tuple(ok);
497                Ok(self)
498            }
499            Err(err) => {
500                *self = erase::Serializer::Error(err);
501                Err(ShortCircuit)
502            }
503        }
504    }
505
506    fn erased_serialize_tuple_struct(
507        &mut self,
508        name: &'static str,
509        len: usize,
510    ) -> Result<&mut dyn SerializeTupleStruct, ErrorImpl> {
511        match self.take_serializer().serialize_tuple_struct(name, len) {
512            Ok(ok) => {
513                *self = erase::Serializer::TupleStruct(ok);
514                Ok(self)
515            }
516            Err(err) => {
517                *self = erase::Serializer::Error(err);
518                Err(ShortCircuit)
519            }
520        }
521    }
522
523    fn erased_serialize_tuple_variant(
524        &mut self,
525        name: &'static str,
526        variant_index: u32,
527        variant: &'static str,
528        len: usize,
529    ) -> Result<&mut dyn SerializeTupleVariant, ErrorImpl> {
530        match self
531            .take_serializer()
532            .serialize_tuple_variant(name, variant_index, variant, len)
533        {
534            Ok(ok) => {
535                *self = erase::Serializer::TupleVariant(ok);
536                Ok(self)
537            }
538            Err(err) => {
539                *self = erase::Serializer::Error(err);
540                Err(ShortCircuit)
541            }
542        }
543    }
544
545    fn erased_serialize_map(
546        &mut self,
547        len: Option<usize>,
548    ) -> Result<&mut dyn SerializeMap, ErrorImpl> {
549        match self.take_serializer().serialize_map(len) {
550            Ok(ok) => {
551                *self = erase::Serializer::Map(ok);
552                Ok(self)
553            }
554            Err(err) => {
555                *self = erase::Serializer::Error(err);
556                Err(ShortCircuit)
557            }
558        }
559    }
560
561    fn erased_serialize_struct(
562        &mut self,
563        name: &'static str,
564        len: usize,
565    ) -> Result<&mut dyn SerializeStruct, ErrorImpl> {
566        match self.take_serializer().serialize_struct(name, len) {
567            Ok(ok) => {
568                *self = erase::Serializer::Struct(ok);
569                Ok(self)
570            }
571            Err(err) => {
572                *self = erase::Serializer::Error(err);
573                Err(ShortCircuit)
574            }
575        }
576    }
577
578    fn erased_serialize_struct_variant(
579        &mut self,
580        name: &'static str,
581        variant_index: u32,
582        variant: &'static str,
583        len: usize,
584    ) -> Result<&mut dyn SerializeStructVariant, ErrorImpl> {
585        match self
586            .take_serializer()
587            .serialize_struct_variant(name, variant_index, variant, len)
588        {
589            Ok(ok) => {
590                *self = erase::Serializer::StructVariant(ok);
591                Ok(self)
592            }
593            Err(err) => {
594                *self = erase::Serializer::Error(err);
595                Err(ShortCircuit)
596            }
597        }
598    }
599
600    fn erased_is_human_readable(&self) -> bool {
601        match self {
602            erase::Serializer::Ready(serializer) => serializer.is_human_readable(),
603            _ => unreachable!(),
604        }
605    }
606
607    fn erased_display_error(&self) -> &dyn Display {
608        match self {
609            erase::Serializer::Error(err) => err,
610            _ => unreachable!(),
611        }
612    }
613}
614
615impl<T> sealed::serializer::Sealed for erase::Serializer<T> where T: serde::Serializer {}
616
617pub enum ErrorImpl {
618    ShortCircuit,
619    Custom(Box<String>),
620}
621
622impl Display for ErrorImpl {
623    fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result {
624        unimplemented!()
625    }
626}
627
628impl Debug for ErrorImpl {
629    fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result {
630        unimplemented!()
631    }
632}
633
634impl serde::ser::StdError for ErrorImpl {}
635
636impl serde::ser::Error for ErrorImpl {
637    fn custom<T: Display>(msg: T) -> Self {
638        ErrorImpl::Custom(Box::new(msg.to_string()))
639    }
640}
641
642// IMPL SERDE FOR ERASED SERDE /////////////////////////////////////////////////
643
644/// Serialize the given type-erased serializable value.
645///
646/// This can be used to implement `serde::Serialize` for trait objects that have
647/// `erased_serde::Serialize` as a supertrait.
648///
649/// ```
650/// trait Event: erased_serde::Serialize {
651///     /* ... */
652/// }
653///
654/// impl<'a> serde::Serialize for dyn Event + 'a {
655///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
656///     where
657///         S: serde::Serializer,
658///     {
659///         erased_serde::serialize(self, serializer)
660///     }
661/// }
662/// ```
663///
664/// Since this is reasonably common, the `serialize_trait_object!` macro
665/// generates such a Serialize impl.
666///
667/// ```
668/// use erased_serde::serialize_trait_object;
669/// #
670/// # trait Event: erased_serde::Serialize {}
671///
672/// serialize_trait_object!(Event);
673/// ```
674pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
675where
676    T: ?Sized + Serialize,
677    S: serde::Serializer,
678{
679    let mut erased = erase::Serializer::new(serializer);
680    match value.do_erased_serialize(&mut erased) {
681        Ok(()) | Err(ShortCircuit) => {}
682        Err(ErrorImpl::Custom(msg)) => return Err(serde::ser::Error::custom(msg)),
683    }
684    match erased {
685        erase::Serializer::Complete(ok) => Ok(ok),
686        erase::Serializer::Error(err) => Err(err),
687        _ => unreachable!(),
688    }
689}
690
691serialize_trait_object!(Serialize);
692
693struct MakeSerializer<TraitObject>(TraitObject);
694
695impl<'a> serde::Serializer for MakeSerializer<&'a mut (dyn Serializer + '_)> {
696    type Ok = ();
697    type Error = ErrorImpl;
698    type SerializeSeq = MakeSerializer<&'a mut dyn SerializeSeq>;
699    type SerializeTuple = MakeSerializer<&'a mut dyn SerializeTuple>;
700    type SerializeTupleStruct = MakeSerializer<&'a mut dyn SerializeTupleStruct>;
701    type SerializeTupleVariant = MakeSerializer<&'a mut dyn SerializeTupleVariant>;
702    type SerializeMap = MakeSerializer<&'a mut dyn SerializeMap>;
703    type SerializeStruct = MakeSerializer<&'a mut dyn SerializeStruct>;
704    type SerializeStructVariant = MakeSerializer<&'a mut dyn SerializeStructVariant>;
705
706    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
707        self.0.erased_serialize_bool(v);
708        Ok(())
709    }
710
711    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
712        self.0.erased_serialize_i8(v);
713        Ok(())
714    }
715
716    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
717        self.0.erased_serialize_i16(v);
718        Ok(())
719    }
720
721    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
722        self.0.erased_serialize_i32(v);
723        Ok(())
724    }
725
726    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
727        self.0.erased_serialize_i64(v);
728        Ok(())
729    }
730
731    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
732        self.0.erased_serialize_i128(v);
733        Ok(())
734    }
735
736    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
737        self.0.erased_serialize_u8(v);
738        Ok(())
739    }
740
741    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
742        self.0.erased_serialize_u16(v);
743        Ok(())
744    }
745
746    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
747        self.0.erased_serialize_u32(v);
748        Ok(())
749    }
750
751    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
752        self.0.erased_serialize_u64(v);
753        Ok(())
754    }
755
756    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
757        self.0.erased_serialize_u128(v);
758        Ok(())
759    }
760
761    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
762        self.0.erased_serialize_f32(v);
763        Ok(())
764    }
765
766    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
767        self.0.erased_serialize_f64(v);
768        Ok(())
769    }
770
771    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
772        self.0.erased_serialize_char(v);
773        Ok(())
774    }
775
776    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
777        self.0.erased_serialize_str(v);
778        Ok(())
779    }
780
781    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
782        self.0.erased_serialize_bytes(v);
783        Ok(())
784    }
785
786    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
787        self.0.erased_serialize_none();
788        Ok(())
789    }
790
791    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
792    where
793        T: ?Sized + serde::Serialize,
794    {
795        self.0.erased_serialize_some(&value);
796        Ok(())
797    }
798
799    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
800        self.0.erased_serialize_unit();
801        Ok(())
802    }
803
804    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
805        self.0.erased_serialize_unit_struct(name);
806        Ok(())
807    }
808
809    fn serialize_unit_variant(
810        self,
811        name: &'static str,
812        variant_index: u32,
813        variant: &'static str,
814    ) -> Result<Self::Ok, Self::Error> {
815        self.0
816            .erased_serialize_unit_variant(name, variant_index, variant);
817        Ok(())
818    }
819
820    fn serialize_newtype_struct<T>(
821        self,
822        name: &'static str,
823        value: &T,
824    ) -> Result<Self::Ok, Self::Error>
825    where
826        T: ?Sized + serde::Serialize,
827    {
828        self.0.erased_serialize_newtype_struct(name, &value);
829        Ok(())
830    }
831
832    fn serialize_newtype_variant<T>(
833        self,
834        name: &'static str,
835        variant_index: u32,
836        variant: &'static str,
837        value: &T,
838    ) -> Result<Self::Ok, Self::Error>
839    where
840        T: ?Sized + serde::Serialize,
841    {
842        self.0
843            .erased_serialize_newtype_variant(name, variant_index, variant, &value);
844        Ok(())
845    }
846
847    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
848        self.0.erased_serialize_seq(len).map(MakeSerializer)
849    }
850
851    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
852        self.0.erased_serialize_tuple(len).map(MakeSerializer)
853    }
854
855    fn serialize_tuple_struct(
856        self,
857        name: &'static str,
858        len: usize,
859    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
860        self.0
861            .erased_serialize_tuple_struct(name, len)
862            .map(MakeSerializer)
863    }
864
865    fn serialize_tuple_variant(
866        self,
867        name: &'static str,
868        variant_index: u32,
869        variant: &'static str,
870        len: usize,
871    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
872        self.0
873            .erased_serialize_tuple_variant(name, variant_index, variant, len)
874            .map(MakeSerializer)
875    }
876
877    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
878        self.0.erased_serialize_map(len).map(MakeSerializer)
879    }
880
881    fn serialize_struct(
882        self,
883        name: &'static str,
884        len: usize,
885    ) -> Result<Self::SerializeStruct, Self::Error> {
886        self.0
887            .erased_serialize_struct(name, len)
888            .map(MakeSerializer)
889    }
890
891    fn serialize_struct_variant(
892        self,
893        name: &'static str,
894        variant_index: u32,
895        variant: &'static str,
896        len: usize,
897    ) -> Result<Self::SerializeStructVariant, Self::Error> {
898        self.0
899            .erased_serialize_struct_variant(name, variant_index, variant, len)
900            .map(MakeSerializer)
901    }
902
903    #[cfg(not(feature = "alloc"))]
904    fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
905    where
906        T: ?Sized + Display,
907    {
908        unreachable!()
909    }
910
911    fn is_human_readable(&self) -> bool {
912        self.0.erased_is_human_readable()
913    }
914}
915
916pub trait SerializeSeq {
917    fn erased_serialize_element(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl>;
918    fn erased_end(&mut self);
919}
920
921impl<T> SerializeSeq for erase::Serializer<T>
922where
923    T: serde::Serializer,
924{
925    fn erased_serialize_element(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl> {
926        let erase::Serializer::Seq(serializer) = self else {
927            unreachable!();
928        };
929        serializer.serialize_element(value).map_err(|err| {
930            *self = erase::Serializer::Error(err);
931            ShortCircuit
932        })
933    }
934
935    fn erased_end(&mut self) {
936        let erase::Serializer::Seq(serializer) = self.take() else {
937            unreachable!();
938        };
939        *self = match serializer.end() {
940            Ok(ok) => erase::Serializer::Complete(ok),
941            Err(err) => erase::Serializer::Error(err),
942        };
943    }
944}
945
946impl serde::ser::SerializeSeq for MakeSerializer<&mut dyn SerializeSeq> {
947    type Ok = ();
948    type Error = ErrorImpl;
949
950    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
951    where
952        T: ?Sized + serde::Serialize,
953    {
954        self.0.erased_serialize_element(&value)
955    }
956
957    fn end(self) -> Result<Self::Ok, Self::Error> {
958        self.0.erased_end();
959        Ok(())
960    }
961}
962
963pub trait SerializeTuple {
964    fn erased_serialize_element(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl>;
965    fn erased_end(&mut self);
966}
967
968impl<T> SerializeTuple for erase::Serializer<T>
969where
970    T: serde::Serializer,
971{
972    fn erased_serialize_element(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl> {
973        let erase::Serializer::Tuple(serializer) = self else {
974            unreachable!();
975        };
976        serializer.serialize_element(value).map_err(|err| {
977            *self = erase::Serializer::Error(err);
978            ShortCircuit
979        })
980    }
981
982    fn erased_end(&mut self) {
983        let erase::Serializer::Tuple(serializer) = self.take() else {
984            unreachable!();
985        };
986        *self = match serializer.end() {
987            Ok(ok) => erase::Serializer::Complete(ok),
988            Err(err) => erase::Serializer::Error(err),
989        };
990    }
991}
992
993impl serde::ser::SerializeTuple for MakeSerializer<&mut dyn SerializeTuple> {
994    type Ok = ();
995    type Error = ErrorImpl;
996
997    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
998    where
999        T: ?Sized + serde::Serialize,
1000    {
1001        self.0.erased_serialize_element(&value)
1002    }
1003
1004    fn end(self) -> Result<Self::Ok, Self::Error> {
1005        self.0.erased_end();
1006        Ok(())
1007    }
1008}
1009
1010pub trait SerializeTupleStruct {
1011    fn erased_serialize_field(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl>;
1012    fn erased_end(&mut self);
1013}
1014
1015impl<T> SerializeTupleStruct for erase::Serializer<T>
1016where
1017    T: serde::Serializer,
1018{
1019    fn erased_serialize_field(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl> {
1020        let erase::Serializer::TupleStruct(serializer) = self else {
1021            unreachable!();
1022        };
1023        serializer.serialize_field(value).map_err(|err| {
1024            *self = erase::Serializer::Error(err);
1025            ShortCircuit
1026        })
1027    }
1028
1029    fn erased_end(&mut self) {
1030        let erase::Serializer::TupleStruct(serializer) = self.take() else {
1031            unreachable!();
1032        };
1033        *self = match serializer.end() {
1034            Ok(ok) => erase::Serializer::Complete(ok),
1035            Err(err) => erase::Serializer::Error(err),
1036        };
1037    }
1038}
1039
1040impl serde::ser::SerializeTupleStruct for MakeSerializer<&mut dyn SerializeTupleStruct> {
1041    type Ok = ();
1042    type Error = ErrorImpl;
1043
1044    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
1045    where
1046        T: ?Sized + serde::Serialize,
1047    {
1048        self.0.erased_serialize_field(&value)
1049    }
1050
1051    fn end(self) -> Result<Self::Ok, Self::Error> {
1052        self.0.erased_end();
1053        Ok(())
1054    }
1055}
1056
1057pub trait SerializeTupleVariant {
1058    fn erased_serialize_field(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl>;
1059    fn erased_end(&mut self);
1060}
1061
1062impl<T> SerializeTupleVariant for erase::Serializer<T>
1063where
1064    T: serde::Serializer,
1065{
1066    fn erased_serialize_field(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl> {
1067        let erase::Serializer::TupleVariant(serializer) = self else {
1068            unreachable!();
1069        };
1070        serializer.serialize_field(value).map_err(|err| {
1071            *self = erase::Serializer::Error(err);
1072            ShortCircuit
1073        })
1074    }
1075
1076    fn erased_end(&mut self) {
1077        let erase::Serializer::TupleVariant(serializer) = self.take() else {
1078            unreachable!();
1079        };
1080        *self = match serializer.end() {
1081            Ok(ok) => erase::Serializer::Complete(ok),
1082            Err(err) => erase::Serializer::Error(err),
1083        };
1084    }
1085}
1086
1087impl serde::ser::SerializeTupleVariant for MakeSerializer<&mut dyn SerializeTupleVariant> {
1088    type Ok = ();
1089    type Error = ErrorImpl;
1090
1091    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
1092    where
1093        T: ?Sized + serde::Serialize,
1094    {
1095        self.0.erased_serialize_field(&value)
1096    }
1097
1098    fn end(self) -> Result<Self::Ok, Self::Error> {
1099        self.0.erased_end();
1100        Ok(())
1101    }
1102}
1103
1104pub trait SerializeMap {
1105    fn erased_serialize_key(&mut self, key: &dyn Serialize) -> Result<(), ErrorImpl>;
1106    fn erased_serialize_value(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl>;
1107    fn erased_serialize_entry(
1108        &mut self,
1109        key: &dyn Serialize,
1110        value: &dyn Serialize,
1111    ) -> Result<(), ErrorImpl>;
1112    fn erased_end(&mut self);
1113}
1114
1115impl<T> SerializeMap for erase::Serializer<T>
1116where
1117    T: serde::Serializer,
1118{
1119    fn erased_serialize_key(&mut self, key: &dyn Serialize) -> Result<(), ErrorImpl> {
1120        let erase::Serializer::Map(serializer) = self else {
1121            unreachable!();
1122        };
1123        serializer.serialize_key(key).map_err(|err| {
1124            *self = erase::Serializer::Error(err);
1125            ShortCircuit
1126        })
1127    }
1128
1129    fn erased_serialize_value(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl> {
1130        let erase::Serializer::Map(serializer) = self else {
1131            unreachable!();
1132        };
1133        serializer.serialize_value(value).map_err(|err| {
1134            *self = erase::Serializer::Error(err);
1135            ShortCircuit
1136        })
1137    }
1138
1139    fn erased_serialize_entry(
1140        &mut self,
1141        key: &dyn Serialize,
1142        value: &dyn Serialize,
1143    ) -> Result<(), ErrorImpl> {
1144        let erase::Serializer::Map(serializer) = self else {
1145            unreachable!();
1146        };
1147        serializer.serialize_entry(key, value).map_err(|err| {
1148            *self = erase::Serializer::Error(err);
1149            ShortCircuit
1150        })
1151    }
1152
1153    fn erased_end(&mut self) {
1154        let erase::Serializer::Map(serializer) = self.take() else {
1155            unreachable!();
1156        };
1157        *self = match serializer.end() {
1158            Ok(ok) => erase::Serializer::Complete(ok),
1159            Err(err) => erase::Serializer::Error(err),
1160        };
1161    }
1162}
1163
1164impl serde::ser::SerializeMap for MakeSerializer<&mut dyn SerializeMap> {
1165    type Ok = ();
1166    type Error = ErrorImpl;
1167
1168    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
1169    where
1170        T: ?Sized + serde::Serialize,
1171    {
1172        self.0.erased_serialize_key(&key)
1173    }
1174
1175    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
1176    where
1177        T: ?Sized + serde::Serialize,
1178    {
1179        self.0.erased_serialize_value(&value)
1180    }
1181
1182    fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), Self::Error>
1183    where
1184        K: ?Sized + serde::Serialize,
1185        V: ?Sized + serde::Serialize,
1186    {
1187        self.0.erased_serialize_entry(&key, &value)
1188    }
1189
1190    fn end(self) -> Result<Self::Ok, Self::Error> {
1191        self.0.erased_end();
1192        Ok(())
1193    }
1194}
1195
1196pub trait SerializeStruct {
1197    fn erased_serialize_field(
1198        &mut self,
1199        key: &'static str,
1200        value: &dyn Serialize,
1201    ) -> Result<(), ErrorImpl>;
1202    fn erased_skip_field(&mut self, key: &'static str) -> Result<(), ErrorImpl>;
1203    fn erased_end(&mut self);
1204}
1205
1206impl<T> SerializeStruct for erase::Serializer<T>
1207where
1208    T: serde::Serializer,
1209{
1210    fn erased_serialize_field(
1211        &mut self,
1212        key: &'static str,
1213        value: &dyn Serialize,
1214    ) -> Result<(), ErrorImpl> {
1215        let erase::Serializer::Struct(serializer) = self else {
1216            unreachable!();
1217        };
1218        serializer.serialize_field(key, value).map_err(|err| {
1219            *self = erase::Serializer::Error(err);
1220            ShortCircuit
1221        })
1222    }
1223
1224    fn erased_skip_field(&mut self, key: &'static str) -> Result<(), ErrorImpl> {
1225        let erase::Serializer::Struct(serializer) = self else {
1226            unreachable!();
1227        };
1228        serializer.skip_field(key).map_err(|err| {
1229            *self = erase::Serializer::Error(err);
1230            ShortCircuit
1231        })
1232    }
1233
1234    fn erased_end(&mut self) {
1235        let erase::Serializer::Struct(serializer) = self.take() else {
1236            unreachable!();
1237        };
1238        *self = match serializer.end() {
1239            Ok(ok) => erase::Serializer::Complete(ok),
1240            Err(err) => erase::Serializer::Error(err),
1241        };
1242    }
1243}
1244
1245impl serde::ser::SerializeStruct for MakeSerializer<&mut dyn SerializeStruct> {
1246    type Ok = ();
1247    type Error = ErrorImpl;
1248
1249    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
1250    where
1251        T: ?Sized + serde::Serialize,
1252    {
1253        self.0.erased_serialize_field(key, &value)
1254    }
1255
1256    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
1257        self.0.erased_skip_field(key)
1258    }
1259
1260    fn end(self) -> Result<Self::Ok, Self::Error> {
1261        self.0.erased_end();
1262        Ok(())
1263    }
1264}
1265
1266pub trait SerializeStructVariant {
1267    fn erased_serialize_field(
1268        &mut self,
1269        key: &'static str,
1270        value: &dyn Serialize,
1271    ) -> Result<(), ErrorImpl>;
1272    fn erased_skip_field(&mut self, key: &'static str) -> Result<(), ErrorImpl>;
1273    fn erased_end(&mut self);
1274}
1275
1276impl<T> SerializeStructVariant for erase::Serializer<T>
1277where
1278    T: serde::Serializer,
1279{
1280    fn erased_serialize_field(
1281        &mut self,
1282        key: &'static str,
1283        value: &dyn Serialize,
1284    ) -> Result<(), ErrorImpl> {
1285        let erase::Serializer::StructVariant(serializer) = self else {
1286            unreachable!();
1287        };
1288        serializer.serialize_field(key, value).map_err(|err| {
1289            *self = erase::Serializer::Error(err);
1290            ShortCircuit
1291        })
1292    }
1293
1294    fn erased_skip_field(&mut self, key: &'static str) -> Result<(), ErrorImpl> {
1295        let erase::Serializer::Struct(serializer) = self else {
1296            unreachable!();
1297        };
1298        serializer.skip_field(key).map_err(|err| {
1299            *self = erase::Serializer::Error(err);
1300            ShortCircuit
1301        })
1302    }
1303
1304    fn erased_end(&mut self) {
1305        let erase::Serializer::StructVariant(serializer) = self.take() else {
1306            unreachable!();
1307        };
1308        *self = match serializer.end() {
1309            Ok(ok) => erase::Serializer::Complete(ok),
1310            Err(err) => erase::Serializer::Error(err),
1311        };
1312    }
1313}
1314
1315impl serde::ser::SerializeStructVariant for MakeSerializer<&mut dyn SerializeStructVariant> {
1316    type Ok = ();
1317    type Error = ErrorImpl;
1318
1319    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
1320    where
1321        T: ?Sized + serde::Serialize,
1322    {
1323        self.0.erased_serialize_field(key, &value)
1324    }
1325
1326    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
1327        self.0.erased_skip_field(key)
1328    }
1329
1330    fn end(self) -> Result<Self::Ok, Self::Error> {
1331        self.0.erased_end();
1332        Ok(())
1333    }
1334}
1335
1336// IMPL ERASED SERDE FOR ERASED SERDE //////////////////////////////////////////
1337
1338macro_rules! deref_erased_serializer {
1339    (<$T:ident> Serializer for $ty:ty $(where $($where:tt)*)?) => {
1340        impl<$T> Serializer for $ty $(where $($where)*)? {
1341            fn erased_serialize_bool(&mut self, v: bool) {
1342                (**self).erased_serialize_bool(v);
1343            }
1344
1345            fn erased_serialize_i8(&mut self, v: i8) {
1346                (**self).erased_serialize_i8(v);
1347            }
1348
1349            fn erased_serialize_i16(&mut self, v: i16) {
1350                (**self).erased_serialize_i16(v);
1351            }
1352
1353            fn erased_serialize_i32(&mut self, v: i32) {
1354                (**self).erased_serialize_i32(v);
1355            }
1356
1357            fn erased_serialize_i64(&mut self, v: i64) {
1358                (**self).erased_serialize_i64(v);
1359            }
1360
1361            fn erased_serialize_i128(&mut self, v: i128) {
1362                (**self).erased_serialize_i128(v);
1363            }
1364
1365            fn erased_serialize_u8(&mut self, v: u8) {
1366                (**self).erased_serialize_u8(v);
1367            }
1368
1369            fn erased_serialize_u16(&mut self, v: u16) {
1370                (**self).erased_serialize_u16(v);
1371            }
1372
1373            fn erased_serialize_u32(&mut self, v: u32) {
1374                (**self).erased_serialize_u32(v);
1375            }
1376
1377            fn erased_serialize_u64(&mut self, v: u64) {
1378                (**self).erased_serialize_u64(v);
1379            }
1380
1381            fn erased_serialize_u128(&mut self, v: u128) {
1382                (**self).erased_serialize_u128(v);
1383            }
1384
1385            fn erased_serialize_f32(&mut self, v: f32) {
1386                (**self).erased_serialize_f32(v);
1387            }
1388
1389            fn erased_serialize_f64(&mut self, v: f64) {
1390                (**self).erased_serialize_f64(v);
1391            }
1392
1393            fn erased_serialize_char(&mut self, v: char) {
1394                (**self).erased_serialize_char(v);
1395            }
1396
1397            fn erased_serialize_str(&mut self, v: &str) {
1398                (**self).erased_serialize_str(v);
1399            }
1400
1401            fn erased_serialize_bytes(&mut self, v: &[u8]) {
1402                (**self).erased_serialize_bytes(v);
1403            }
1404
1405            fn erased_serialize_none(&mut self) {
1406                (**self).erased_serialize_none();
1407            }
1408
1409            fn erased_serialize_some(&mut self, value: &dyn Serialize) {
1410                (**self).erased_serialize_some(value);
1411            }
1412
1413            fn erased_serialize_unit(&mut self) {
1414                (**self).erased_serialize_unit();
1415            }
1416
1417            fn erased_serialize_unit_struct(&mut self, name: &'static str) {
1418                (**self).erased_serialize_unit_struct(name);
1419            }
1420
1421            fn erased_serialize_unit_variant(&mut self, name: &'static str, variant_index: u32, variant: &'static str) {
1422                (**self).erased_serialize_unit_variant(name, variant_index, variant);
1423            }
1424
1425            fn erased_serialize_newtype_struct(&mut self, name: &'static str, value: &dyn Serialize) {
1426                (**self).erased_serialize_newtype_struct(name, value);
1427            }
1428
1429            fn erased_serialize_newtype_variant(&mut self, name: &'static str, variant_index: u32, variant: &'static str, value: &dyn Serialize) {
1430                (**self).erased_serialize_newtype_variant(name, variant_index, variant, value);
1431            }
1432
1433            fn erased_serialize_seq(&mut self, len: Option<usize>) -> Result<&mut dyn SerializeSeq, ErrorImpl> {
1434                (**self).erased_serialize_seq(len)
1435            }
1436
1437            fn erased_serialize_tuple(&mut self, len: usize) -> Result<&mut dyn SerializeTuple, ErrorImpl> {
1438                (**self).erased_serialize_tuple(len)
1439            }
1440
1441            fn erased_serialize_tuple_struct(&mut self, name: &'static str, len: usize) -> Result<&mut dyn SerializeTupleStruct, ErrorImpl> {
1442                (**self).erased_serialize_tuple_struct(name, len)
1443            }
1444
1445            fn erased_serialize_tuple_variant(&mut self, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<&mut dyn SerializeTupleVariant, ErrorImpl> {
1446                (**self).erased_serialize_tuple_variant(name, variant_index, variant, len)
1447            }
1448
1449            fn erased_serialize_map(&mut self, len: Option<usize>) -> Result<&mut dyn SerializeMap, ErrorImpl> {
1450                (**self).erased_serialize_map(len)
1451            }
1452
1453            fn erased_serialize_struct(&mut self, name: &'static str, len: usize) -> Result<&mut dyn SerializeStruct, ErrorImpl> {
1454                (**self).erased_serialize_struct(name, len)
1455            }
1456
1457            fn erased_serialize_struct_variant(&mut self, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<&mut dyn SerializeStructVariant, ErrorImpl> {
1458                (**self).erased_serialize_struct_variant(name, variant_index, variant, len)
1459            }
1460
1461            fn erased_is_human_readable(&self) -> bool {
1462                (**self).erased_is_human_readable()
1463            }
1464
1465            fn erased_display_error(&self) -> &dyn Display {
1466                (**self).erased_display_error()
1467            }
1468        }
1469
1470        impl<$T> sealed::serializer::Sealed for $ty $(where $($where)*)? {}
1471    };
1472}
1473
1474deref_erased_serializer!(<T> Serializer for &mut T where T: ?Sized + Serializer);
1475deref_erased_serializer!(<T> Serializer for Box<T> where T: ?Sized + Serializer);
1476
1477// TEST ////////////////////////////////////////////////////////////////////////
1478
1479#[cfg(test)]
1480mod tests {
1481    use super::*;
1482    use alloc::{vec, vec::Vec};
1483    use serde_derive::Serialize;
1484
1485    fn test_json<T>(t: T)
1486    where
1487        T: serde::Serialize,
1488    {
1489        let expected = serde_json::to_vec(&t).unwrap();
1490
1491        // test borrowed trait object
1492        {
1493            let obj: &dyn Serialize = &t;
1494
1495            let mut buf = Vec::new();
1496
1497            {
1498                let mut ser = serde_json::Serializer::new(&mut buf);
1499                let ser: &mut dyn Serializer = &mut <dyn Serializer>::erase(&mut ser);
1500
1501                obj.erased_serialize(ser).unwrap();
1502            }
1503
1504            assert_eq!(buf, expected);
1505        }
1506
1507        // test boxed trait object
1508        {
1509            let obj: Box<dyn Serialize> = Box::new(t);
1510
1511            let mut buf = Vec::new();
1512
1513            {
1514                let mut ser = serde_json::Serializer::new(&mut buf);
1515                let mut ser: Box<dyn Serializer> = Box::new(<dyn Serializer>::erase(&mut ser));
1516
1517                obj.erased_serialize(&mut ser).unwrap();
1518            }
1519
1520            assert_eq!(buf, expected);
1521        }
1522    }
1523
1524    #[test]
1525    fn test_vec() {
1526        test_json(vec!["a", "b"]);
1527    }
1528
1529    #[test]
1530    fn test_struct() {
1531        #[derive(Serialize)]
1532        struct S {
1533            f: usize,
1534        }
1535
1536        test_json(S { f: 256 });
1537    }
1538
1539    #[test]
1540    fn test_enum() {
1541        #[derive(Serialize)]
1542        enum E {
1543            Unit,
1544            Newtype(bool),
1545            Tuple(bool, bool),
1546            Struct { t: bool, f: bool },
1547        }
1548
1549        test_json(E::Unit);
1550        test_json(E::Newtype(true));
1551        test_json(E::Tuple(true, false));
1552        test_json(E::Struct { t: true, f: false });
1553    }
1554
1555    #[test]
1556    fn test_error_custom() {
1557        struct Kaboom;
1558
1559        impl serde::Serialize for Kaboom {
1560            fn serialize<S>(&self, _: S) -> Result<S::Ok, S::Error>
1561            where
1562                S: serde::Serializer,
1563            {
1564                use serde::ser::Error as _;
1565
1566                Err(S::Error::custom("kaboom"))
1567            }
1568        }
1569
1570        let obj: &dyn Serialize = &Kaboom;
1571
1572        let err = serde_json::to_vec(obj).unwrap_err();
1573        assert_eq!(err.to_string(), "kaboom");
1574    }
1575
1576    #[test]
1577    fn assert_serialize() {
1578        fn assert<T: serde::Serialize>() {}
1579
1580        assert::<&dyn Serialize>();
1581        assert::<&(dyn Serialize + Send)>();
1582        assert::<&(dyn Serialize + Sync)>();
1583        assert::<&(dyn Serialize + Send + Sync)>();
1584        assert::<&(dyn Serialize + Sync + Send)>();
1585        assert::<Vec<&dyn Serialize>>();
1586        assert::<Vec<&(dyn Serialize + Send)>>();
1587
1588        assert::<Box<dyn Serialize>>();
1589        assert::<Box<dyn Serialize + Send>>();
1590        assert::<Box<dyn Serialize + Sync>>();
1591        assert::<Box<dyn Serialize + Send + Sync>>();
1592        assert::<Box<dyn Serialize + Sync + Send>>();
1593        assert::<Vec<Box<dyn Serialize>>>();
1594        assert::<Vec<Box<dyn Serialize + Send>>>();
1595    }
1596
1597    #[test]
1598    fn test_dangle() {
1599        let mut json_serializer = serde_json::Serializer::new(Vec::new());
1600        let _erased_serializer = <dyn Serializer>::erase(&mut json_serializer);
1601        drop(json_serializer);
1602    }
1603}
erased_serde/ser.rs

erased_serde/
ser.rs
