rustc_type_ir/
serialize.rs

1use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
2
3use crate::inherent::*;
4use crate::visit::TypeVisitable;
5use crate::{self as ty, Interner, Region, RegionKind, UnsafeBinderInner};
6
7/// A decoder that can reconstruct interned type IR values by supplying the
8/// interner that owns the decoded data.
9///
10/// Some serialized type IR wrappers only store their structural kind. When
11/// decoding, those kinds have to be re-interned instead of rebuilt as raw
12/// values, so their `Decodable` impls need access to the active interner in
13/// addition to the byte stream.
14pub trait InternerDecoder: Decoder {
15    type Interner: Interner;
16
17    fn interner(&self) -> Self::Interner;
18}
19
20macro_rules! impl_binder_encode_decode {
21    ($($t:ty),+ $(,)?) => {
22        $(
23            impl<I: Interner, E: rustc_serialize::Encoder> rustc_serialize::Encodable<E> for ty::Binder<I, $t>
24            where
25                $t: rustc_serialize::Encodable<E>,
26                I::BoundVarKinds: rustc_serialize::Encodable<E>,
27            {
28                fn encode(&self, e: &mut E) {
29                    self.bound_vars().encode(e);
30                    self.as_ref().skip_binder().encode(e);
31                }
32            }
33            impl<I: Interner, D: rustc_serialize::Decoder> rustc_serialize::Decodable<D> for ty::Binder<I, $t>
34            where
35                $t: TypeVisitable<I> + rustc_serialize::Decodable<D>,
36                I::BoundVarKinds: rustc_serialize::Decodable<D>,
37            {
38                fn decode(decoder: &mut D) -> Self {
39                    let bound_vars = rustc_serialize::Decodable::decode(decoder);
40                    ty::Binder::bind_with_vars(rustc_serialize::Decodable::decode(decoder), bound_vars)
41                }
42            }
43        )*
44    }
45}
46
47impl<I: Interner, E: rustc_serialize::Encoder> rustc_serialize::Encodable<E>
    for ty::Binder<I, ty::HostEffectPredicate<I>> where
    ty::HostEffectPredicate<I>: rustc_serialize::Encodable<E>,
    I::BoundVarKinds: rustc_serialize::Encodable<E> {
    fn encode(&self, e: &mut E) {
        self.bound_vars().encode(e);
        self.as_ref().skip_binder().encode(e);
    }
}
impl<I: Interner, D: rustc_serialize::Decoder> rustc_serialize::Decodable<D>
    for ty::Binder<I, ty::HostEffectPredicate<I>> where
    ty::HostEffectPredicate<I>: TypeVisitable<I> +
    rustc_serialize::Decodable<D>,
    I::BoundVarKinds: rustc_serialize::Decodable<D> {
    fn decode(decoder: &mut D) -> Self {
        let bound_vars = rustc_serialize::Decodable::decode(decoder);
        ty::Binder::bind_with_vars(rustc_serialize::Decodable::decode(decoder),
            bound_vars)
    }
}impl_binder_encode_decode! {
48    ty::FnSig<I>,
49    ty::FnSigTys<I>,
50    ty::TraitPredicate<I>,
51    ty::ExistentialPredicate<I>,
52    ty::TraitRef<I>,
53    ty::ExistentialTraitRef<I>,
54    ty::HostEffectPredicate<I>,
55}
56
57impl<T: GenericArgs<I>, I: Interner<GenericArgs = T>, E: Encoder> Encodable<E> for ty::Binder<I, T>
58where
59    T: Encodable<E>,
60    I::BoundVarKinds: Encodable<E>,
61{
62    fn encode(&self, e: &mut E) {
63        self.bound_vars().encode(e);
64        self.as_ref().skip_binder().encode(e);
65    }
66}
67
68impl<T: GenericArgs<I>, I: Interner<GenericArgs = T>, D: Decoder> Decodable<D> for ty::Binder<I, T>
69where
70    T: TypeVisitable<I> + Decodable<D>,
71    I::BoundVarKinds: Decodable<D>,
72{
73    fn decode(decoder: &mut D) -> Self {
74        let bound_vars = Decodable::decode(decoder);
75        ty::Binder::bind_with_vars(Decodable::decode(decoder), bound_vars)
76    }
77}
78
79impl<I: Interner, E: Encoder> Encodable<E> for UnsafeBinderInner<I>
80where
81    I::Ty: Encodable<E>,
82    I::BoundVarKinds: Encodable<E>,
83{
84    fn encode(&self, e: &mut E) {
85        self.bound_vars().encode(e);
86        self.as_ref().skip_binder().encode(e);
87    }
88}
89
90impl<I: Interner, D: Decoder> Decodable<D> for UnsafeBinderInner<I>
91where
92    I::Ty: TypeVisitable<I> + Decodable<D>,
93    I::BoundVarKinds: Decodable<D>,
94{
95    fn decode(decoder: &mut D) -> Self {
96        let bound_vars = Decodable::decode(decoder);
97        ty::Binder::bind_with_vars(Decodable::decode(decoder), bound_vars).into()
98    }
99}
100
101impl<I: Interner, E: Encoder> Encodable<E> for Region<I>
102where
103    RegionKind<I>: Encodable<E>,
104{
105    fn encode(&self, e: &mut E) {
106        self.kind().encode(e);
107    }
108}
109
110// Decoding a region needs an interner so it can decode a RegionKind and
111// re-intern it.
112impl<I: Interner, D: InternerDecoder<Interner = I>> Decodable<D> for Region<I>
113where
114    RegionKind<I>: Decodable<D>,
115{
116    fn decode(decoder: &mut D) -> Self {
117        decoder.interner().intern_region(Decodable::decode(decoder))
118    }
119}
rustc_type_ir/serialize.rs

rustc_type_ir/
serialize.rs
