1 //! Support code for encoding and decoding types.
4 Core encoding and decoding interfaces.
8 use std
::cell
::{Cell, RefCell}
;
9 use std
::marker
::PhantomData
;
18 fn emit_unit(&mut self) -> Result
<(), Self::Error
>;
19 fn emit_usize(&mut self, v
: usize) -> Result
<(), Self::Error
>;
20 fn emit_u128(&mut self, v
: u128
) -> Result
<(), Self::Error
>;
21 fn emit_u64(&mut self, v
: u64) -> Result
<(), Self::Error
>;
22 fn emit_u32(&mut self, v
: u32) -> Result
<(), Self::Error
>;
23 fn emit_u16(&mut self, v
: u16) -> Result
<(), Self::Error
>;
24 fn emit_u8(&mut self, v
: u8) -> Result
<(), Self::Error
>;
25 fn emit_isize(&mut self, v
: isize) -> Result
<(), Self::Error
>;
26 fn emit_i128(&mut self, v
: i128
) -> Result
<(), Self::Error
>;
27 fn emit_i64(&mut self, v
: i64) -> Result
<(), Self::Error
>;
28 fn emit_i32(&mut self, v
: i32) -> Result
<(), Self::Error
>;
29 fn emit_i16(&mut self, v
: i16) -> Result
<(), Self::Error
>;
30 fn emit_i8(&mut self, v
: i8) -> Result
<(), Self::Error
>;
31 fn emit_bool(&mut self, v
: bool
) -> Result
<(), Self::Error
>;
32 fn emit_f64(&mut self, v
: f64) -> Result
<(), Self::Error
>;
33 fn emit_f32(&mut self, v
: f32) -> Result
<(), Self::Error
>;
34 fn emit_char(&mut self, v
: char) -> Result
<(), Self::Error
>;
35 fn emit_str(&mut self, v
: &str) -> Result
<(), Self::Error
>;
36 fn emit_raw_bytes(&mut self, s
: &[u8]) -> Result
<(), Self::Error
>;
40 fn emit_enum
<F
>(&mut self, f
: F
) -> Result
<(), Self::Error
>
42 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
47 fn emit_enum_variant
<F
>(
53 ) -> Result
<(), Self::Error
>
55 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
57 self.emit_usize(v_id
)?
;
61 // We put the field index in a const generic to allow the emit_usize to be
62 // compiled into a more efficient form. In practice, the variant index is
63 // known at compile-time, and that knowledge allows much more efficient
64 // codegen than we'd otherwise get. LLVM isn't always able to make the
65 // optimization that would otherwise be necessary here, likely due to the
66 // multiple levels of inlining and const-prop that are needed.
68 fn emit_fieldless_enum_variant
<const ID
: usize>(
71 ) -> Result
<(), Self::Error
> {
76 fn emit_enum_variant_arg
<F
>(&mut self, _first
: bool
, f
: F
) -> Result
<(), Self::Error
>
78 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
84 fn emit_struct
<F
>(&mut self, _no_fields
: bool
, f
: F
) -> Result
<(), Self::Error
>
86 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
92 fn emit_struct_field
<F
>(&mut self, _f_name
: &str, _first
: bool
, f
: F
) -> Result
<(), Self::Error
>
94 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
100 fn emit_tuple
<F
>(&mut self, _len
: usize, f
: F
) -> Result
<(), Self::Error
>
102 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
108 fn emit_tuple_arg
<F
>(&mut self, _idx
: usize, f
: F
) -> Result
<(), Self::Error
>
110 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
115 // Specialized types:
116 fn emit_option
<F
>(&mut self, f
: F
) -> Result
<(), Self::Error
>
118 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
124 fn emit_option_none(&mut self) -> Result
<(), Self::Error
> {
125 self.emit_enum_variant("None", 0, 0, |_
| Ok(()))
128 fn emit_option_some
<F
>(&mut self, f
: F
) -> Result
<(), Self::Error
>
130 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
132 self.emit_enum_variant("Some", 1, 1, f
)
135 fn emit_seq
<F
>(&mut self, len
: usize, f
: F
) -> Result
<(), Self::Error
>
137 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
139 self.emit_usize(len
)?
;
144 fn emit_seq_elt
<F
>(&mut self, _idx
: usize, f
: F
) -> Result
<(), Self::Error
>
146 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
151 fn emit_map
<F
>(&mut self, len
: usize, f
: F
) -> Result
<(), Self::Error
>
153 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
155 self.emit_usize(len
)?
;
160 fn emit_map_elt_key
<F
>(&mut self, _idx
: usize, f
: F
) -> Result
<(), Self::Error
>
162 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
168 fn emit_map_elt_val
<F
>(&mut self, f
: F
) -> Result
<(), Self::Error
>
170 F
: FnOnce(&mut Self) -> Result
<(), Self::Error
>,
180 fn read_nil(&mut self) -> Result
<(), Self::Error
>;
181 fn read_usize(&mut self) -> Result
<usize, Self::Error
>;
182 fn read_u128(&mut self) -> Result
<u128
, Self::Error
>;
183 fn read_u64(&mut self) -> Result
<u64, Self::Error
>;
184 fn read_u32(&mut self) -> Result
<u32, Self::Error
>;
185 fn read_u16(&mut self) -> Result
<u16, Self::Error
>;
186 fn read_u8(&mut self) -> Result
<u8, Self::Error
>;
187 fn read_isize(&mut self) -> Result
<isize, Self::Error
>;
188 fn read_i128(&mut self) -> Result
<i128
, Self::Error
>;
189 fn read_i64(&mut self) -> Result
<i64, Self::Error
>;
190 fn read_i32(&mut self) -> Result
<i32, Self::Error
>;
191 fn read_i16(&mut self) -> Result
<i16, Self::Error
>;
192 fn read_i8(&mut self) -> Result
<i8, Self::Error
>;
193 fn read_bool(&mut self) -> Result
<bool
, Self::Error
>;
194 fn read_f64(&mut self) -> Result
<f64, Self::Error
>;
195 fn read_f32(&mut self) -> Result
<f32, Self::Error
>;
196 fn read_char(&mut self) -> Result
<char, Self::Error
>;
197 fn read_str(&mut self) -> Result
<Cow
<'_
, str>, Self::Error
>;
198 fn read_raw_bytes_into(&mut self, s
: &mut [u8]) -> Result
<(), Self::Error
>;
202 fn read_enum
<T
, F
>(&mut self, f
: F
) -> Result
<T
, Self::Error
>
204 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
210 fn read_enum_variant
<T
, F
>(&mut self, _names
: &[&str], mut f
: F
) -> Result
<T
, Self::Error
>
212 F
: FnMut(&mut Self, usize) -> Result
<T
, Self::Error
>,
214 let disr
= self.read_usize()?
;
219 fn read_enum_variant_arg
<T
, F
>(&mut self, f
: F
) -> Result
<T
, Self::Error
>
221 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
227 fn read_struct
<T
, F
>(&mut self, f
: F
) -> Result
<T
, Self::Error
>
229 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
235 fn read_struct_field
<T
, F
>(&mut self, _f_name
: &str, f
: F
) -> Result
<T
, Self::Error
>
237 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
243 fn read_tuple
<T
, F
>(&mut self, _len
: usize, f
: F
) -> Result
<T
, Self::Error
>
245 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
251 fn read_tuple_arg
<T
, F
>(&mut self, f
: F
) -> Result
<T
, Self::Error
>
253 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
258 // Specialized types:
259 fn read_option
<T
, F
>(&mut self, mut f
: F
) -> Result
<T
, Self::Error
>
261 F
: FnMut(&mut Self, bool
) -> Result
<T
, Self::Error
>,
263 self.read_enum(move |this
| {
264 this
.read_enum_variant(&["None", "Some"], move |this
, idx
| match idx
{
267 _
=> Err(this
.error("read_option: expected 0 for None or 1 for Some")),
272 fn read_seq
<T
, F
>(&mut self, f
: F
) -> Result
<T
, Self::Error
>
274 F
: FnOnce(&mut Self, usize) -> Result
<T
, Self::Error
>,
276 let len
= self.read_usize()?
;
281 fn read_seq_elt
<T
, F
>(&mut self, f
: F
) -> Result
<T
, Self::Error
>
283 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
288 fn read_map
<T
, F
>(&mut self, f
: F
) -> Result
<T
, Self::Error
>
290 F
: FnOnce(&mut Self, usize) -> Result
<T
, Self::Error
>,
292 let len
= self.read_usize()?
;
297 fn read_map_elt_key
<T
, F
>(&mut self, f
: F
) -> Result
<T
, Self::Error
>
299 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
305 fn read_map_elt_val
<T
, F
>(&mut self, f
: F
) -> Result
<T
, Self::Error
>
307 F
: FnOnce(&mut Self) -> Result
<T
, Self::Error
>,
313 fn error(&mut self, err
: &str) -> Self::Error
;
316 /// Trait for types that can be serialized
318 /// This can be implemented using the `Encodable`, `TyEncodable` and
319 /// `MetadataEncodable` macros.
321 /// * `Encodable` should be used in crates that don't depend on
323 /// * `MetadataEncodable` is used in `rustc_metadata` for types that contain
324 /// `rustc_metadata::rmeta::Lazy`.
325 /// * `TyEncodable` should be used for types that are only serialized in crate
326 /// metadata or the incremental cache. This is most types in `rustc_middle`.
327 pub trait Encodable
<S
: Encoder
> {
328 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
>;
331 /// Trait for types that can be deserialized
333 /// This can be implemented using the `Decodable`, `TyDecodable` and
334 /// `MetadataDecodable` macros.
336 /// * `Decodable` should be used in crates that don't depend on
338 /// * `MetadataDecodable` is used in `rustc_metadata` for types that contain
339 /// `rustc_metadata::rmeta::Lazy`.
340 /// * `TyDecodable` should be used for types that are only serialized in crate
341 /// metadata or the incremental cache. This is most types in `rustc_middle`.
342 pub trait Decodable
<D
: Decoder
>: Sized
{
343 fn decode(d
: &mut D
) -> Result
<Self, D
::Error
>;
346 macro_rules
! direct_serialize_impls
{
347 ($
($ty
:ident $emit_method
:ident $read_method
:ident
),*) => {
349 impl<S
: Encoder
> Encodable
<S
> for $ty
{
350 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
351 s
.$
emit_method(*self)
355 impl<D
: Decoder
> Decodable
<D
> for $ty
{
356 fn decode(d
: &mut D
) -> Result
<$ty
, D
::Error
> {
364 direct_serialize_impls
! {
365 usize emit_usize read_usize
,
367 u16 emit_u16 read_u16
,
368 u32 emit_u32 read_u32
,
369 u64 emit_u64 read_u64
,
370 u128 emit_u128 read_u128
,
371 isize emit_isize read_isize
,
373 i16 emit_i16 read_i16
,
374 i32 emit_i32 read_i32
,
375 i64 emit_i64 read_i64
,
376 i128 emit_i128 read_i128
,
377 f32 emit_f32 read_f32
,
378 f64 emit_f64 read_f64
,
379 bool emit_bool read_bool
,
380 char emit_char read_char
383 impl<S
: Encoder
> Encodable
<S
> for ! {
384 fn encode(&self, _s
: &mut S
) -> Result
<(), S
::Error
> {
389 impl<D
: Decoder
> Decodable
<D
> for ! {
390 fn decode(_d
: &mut D
) -> Result
<!, D
::Error
> {
395 impl<S
: Encoder
> Encodable
<S
> for ::std
::num
::NonZeroU32
{
396 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
397 s
.emit_u32(self.get())
401 impl<D
: Decoder
> Decodable
<D
> for ::std
::num
::NonZeroU32
{
402 fn decode(d
: &mut D
) -> Result
<Self, D
::Error
> {
403 d
.read_u32().map(|d
| ::std
::num
::NonZeroU32
::new(d
).unwrap())
407 impl<S
: Encoder
> Encodable
<S
> for str {
408 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
413 impl<S
: Encoder
> Encodable
<S
> for &str {
414 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
419 impl<S
: Encoder
> Encodable
<S
> for String
{
420 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
421 s
.emit_str(&self[..])
425 impl<D
: Decoder
> Decodable
<D
> for String
{
426 fn decode(d
: &mut D
) -> Result
<String
, D
::Error
> {
427 Ok(d
.read_str()?
.into_owned())
431 impl<S
: Encoder
> Encodable
<S
> for () {
432 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
437 impl<D
: Decoder
> Decodable
<D
> for () {
438 fn decode(d
: &mut D
) -> Result
<(), D
::Error
> {
443 impl<S
: Encoder
, T
> Encodable
<S
> for PhantomData
<T
> {
444 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
449 impl<D
: Decoder
, T
> Decodable
<D
> for PhantomData
<T
> {
450 fn decode(d
: &mut D
) -> Result
<PhantomData
<T
>, D
::Error
> {
456 impl<D
: Decoder
, T
: Decodable
<D
>> Decodable
<D
> for Box
<[T
]> {
457 fn decode(d
: &mut D
) -> Result
<Box
<[T
]>, D
::Error
> {
458 let v
: Vec
<T
> = Decodable
::decode(d
)?
;
459 Ok(v
.into_boxed_slice())
463 impl<S
: Encoder
, T
: Encodable
<S
>> Encodable
<S
> for Rc
<T
> {
464 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
469 impl<D
: Decoder
, T
: Decodable
<D
>> Decodable
<D
> for Rc
<T
> {
470 fn decode(d
: &mut D
) -> Result
<Rc
<T
>, D
::Error
> {
471 Ok(Rc
::new(Decodable
::decode(d
)?
))
475 impl<S
: Encoder
, T
: Encodable
<S
>> Encodable
<S
> for [T
] {
476 default fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
477 s
.emit_seq(self.len(), |s
| {
478 for (i
, e
) in self.iter().enumerate() {
479 s
.emit_seq_elt(i
, |s
| e
.encode(s
))?
486 impl<S
: Encoder
, T
: Encodable
<S
>> Encodable
<S
> for Vec
<T
> {
487 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
488 let slice
: &[T
] = self;
493 impl<D
: Decoder
, T
: Decodable
<D
>> Decodable
<D
> for Vec
<T
> {
494 default fn decode(d
: &mut D
) -> Result
<Vec
<T
>, D
::Error
> {
495 d
.read_seq(|d
, len
| {
496 let mut v
= Vec
::with_capacity(len
);
498 v
.push(d
.read_seq_elt(|d
| Decodable
::decode(d
))?
);
505 impl<S
: Encoder
, T
: Encodable
<S
>, const N
: usize> Encodable
<S
> for [T
; N
] {
506 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
507 let slice
: &[T
] = self;
512 impl<D
: Decoder
, const N
: usize> Decodable
<D
> for [u8; N
] {
513 fn decode(d
: &mut D
) -> Result
<[u8; N
], D
::Error
> {
514 d
.read_seq(|d
, len
| {
516 let mut v
= [0u8; N
];
518 v
[i
] = d
.read_seq_elt(|d
| Decodable
::decode(d
))?
;
525 impl<'a
, S
: Encoder
, T
: Encodable
<S
>> Encodable
<S
> for Cow
<'a
, [T
]>
527 [T
]: ToOwned
<Owned
= Vec
<T
>>,
529 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
530 let slice
: &[T
] = self;
535 impl<D
: Decoder
, T
: Decodable
<D
> + ToOwned
> Decodable
<D
> for Cow
<'
static, [T
]>
537 [T
]: ToOwned
<Owned
= Vec
<T
>>,
539 fn decode(d
: &mut D
) -> Result
<Cow
<'
static, [T
]>, D
::Error
> {
540 let v
: Vec
<T
> = Decodable
::decode(d
)?
;
545 impl<S
: Encoder
, T
: Encodable
<S
>> Encodable
<S
> for Option
<T
> {
546 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
547 s
.emit_option(|s
| match *self {
548 None
=> s
.emit_option_none(),
549 Some(ref v
) => s
.emit_option_some(|s
| v
.encode(s
)),
554 impl<D
: Decoder
, T
: Decodable
<D
>> Decodable
<D
> for Option
<T
> {
555 fn decode(d
: &mut D
) -> Result
<Option
<T
>, D
::Error
> {
556 d
.read_option(|d
, b
| if b { Ok(Some(Decodable::decode(d)?)) }
else { Ok(None) }
)
560 impl<S
: Encoder
, T1
: Encodable
<S
>, T2
: Encodable
<S
>> Encodable
<S
> for Result
<T1
, T2
> {
561 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
562 s
.emit_enum(|s
| match *self {
564 s
.emit_enum_variant("Ok", 0, 1, |s
| s
.emit_enum_variant_arg(true, |s
| v
.encode(s
)))
567 s
.emit_enum_variant("Err", 1, 1, |s
| s
.emit_enum_variant_arg(true, |s
| v
.encode(s
)))
573 impl<D
: Decoder
, T1
: Decodable
<D
>, T2
: Decodable
<D
>> Decodable
<D
> for Result
<T1
, T2
> {
574 fn decode(d
: &mut D
) -> Result
<Result
<T1
, T2
>, D
::Error
> {
576 d
.read_enum_variant(&["Ok", "Err"], |d
, disr
| match disr
{
577 0 => Ok(Ok(d
.read_enum_variant_arg(|d
| T1
::decode(d
))?
)),
578 1 => Ok(Err(d
.read_enum_variant_arg(|d
| T2
::decode(d
))?
)),
581 "Encountered invalid discriminant while \
591 ($name
:ident
, $
($other
:ident
,)*) => (tuple
! { $($other,)* }
)
594 /// Evaluates to the number of tokens passed to it.
596 /// Logarithmic counting: every one or two recursive expansions, the number of
597 /// tokens to count is divided by two, instead of being reduced by one.
598 /// Therefore, the recursion depth is the binary logarithm of the number of
599 /// tokens to count, and the expanded tree is likewise very small.
602 ($one
:tt
) => (1usize
);
603 ($
($pairs
:tt $_p
:tt
)*) => (count
!($
($pairs
)*) << 1usize
);
604 ($odd
:tt $
($rest
:tt
)*) => (count
!($
($rest
)*) | 1usize
);
609 ( $
($name
:ident
,)+ ) => (
610 impl<D
: Decoder
, $
($name
: Decodable
<D
>),+> Decodable
<D
> for ($
($name
,)+) {
611 #[allow(non_snake_case)]
612 fn decode(d
: &mut D
) -> Result
<($
($name
,)+), D
::Error
> {
613 let len
: usize = count
!($
($name
)+);
614 d
.read_tuple(len
, |d
| {
615 let ret
= ($
(d
.read_tuple_arg(|d
| -> Result
<$name
, D
::Error
> {
622 impl<S
: Encoder
, $
($name
: Encodable
<S
>),+> Encodable
<S
> for ($
($name
,)+) {
623 #[allow(non_snake_case)]
624 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
625 let ($
(ref $name
,)+) = *self;
627 $
(let $name
= $name
; n
+= 1;)+
628 s
.emit_tuple(n
, |s
| {
630 $
(s
.emit_tuple_arg({ i+=1; i-1 }
, |s
| $name
.encode(s
))?
;)+
639 tuple
! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
641 impl<S
: Encoder
> Encodable
<S
> for path
::Path
{
642 fn encode(&self, e
: &mut S
) -> Result
<(), S
::Error
> {
643 self.to_str().unwrap().encode(e
)
647 impl<S
: Encoder
> Encodable
<S
> for path
::PathBuf
{
648 fn encode(&self, e
: &mut S
) -> Result
<(), S
::Error
> {
649 path
::Path
::encode(self, e
)
653 impl<D
: Decoder
> Decodable
<D
> for path
::PathBuf
{
654 fn decode(d
: &mut D
) -> Result
<path
::PathBuf
, D
::Error
> {
655 let bytes
: String
= Decodable
::decode(d
)?
;
656 Ok(path
::PathBuf
::from(bytes
))
660 impl<S
: Encoder
, T
: Encodable
<S
> + Copy
> Encodable
<S
> for Cell
<T
> {
661 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
666 impl<D
: Decoder
, T
: Decodable
<D
> + Copy
> Decodable
<D
> for Cell
<T
> {
667 fn decode(d
: &mut D
) -> Result
<Cell
<T
>, D
::Error
> {
668 Ok(Cell
::new(Decodable
::decode(d
)?
))
673 // Should use `try_borrow`, returning an
674 // `encoder.error("attempting to Encode borrowed RefCell")`
675 // from `encode` when `try_borrow` returns `None`.
677 impl<S
: Encoder
, T
: Encodable
<S
>> Encodable
<S
> for RefCell
<T
> {
678 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
679 self.borrow().encode(s
)
683 impl<D
: Decoder
, T
: Decodable
<D
>> Decodable
<D
> for RefCell
<T
> {
684 fn decode(d
: &mut D
) -> Result
<RefCell
<T
>, D
::Error
> {
685 Ok(RefCell
::new(Decodable
::decode(d
)?
))
689 impl<S
: Encoder
, T
: Encodable
<S
>> Encodable
<S
> for Arc
<T
> {
690 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
695 impl<D
: Decoder
, T
: Decodable
<D
>> Decodable
<D
> for Arc
<T
> {
696 fn decode(d
: &mut D
) -> Result
<Arc
<T
>, D
::Error
> {
697 Ok(Arc
::new(Decodable
::decode(d
)?
))
701 impl<S
: Encoder
, T
: ?Sized
+ Encodable
<S
>> Encodable
<S
> for Box
<T
> {
702 fn encode(&self, s
: &mut S
) -> Result
<(), S
::Error
> {
706 impl<D
: Decoder
, T
: Decodable
<D
>> Decodable
<D
> for Box
<T
> {
707 fn decode(d
: &mut D
) -> Result
<Box
<T
>, D
::Error
> {
708 Ok(Box
::new(Decodable
::decode(d
)?
))