move encoder/decoder impls to rustc_type_ir

Author: Jamesbarford

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -24,7 +24,6 @@ use rustc_index::Idx;
 use rustc_middle::middle::lib_features::LibFeatures;
 use rustc_middle::mir::interpret::{AllocDecodingSession, AllocDecodingState};
 use rustc_middle::ty::Visibility;
-use rustc_middle::ty::codec::TyDecoder;
 use rustc_middle::{bug, implement_ty_decoder};
 use rustc_proc_macro::bridge::client::ProcMacro;
 use rustc_serialize::opaque::MemDecoder;
@@ -386,7 +385,7 @@ impl<'a> BlobDecodeContext<'a> {
     }
 }
 
-impl<'a, 'tcx> TyDecoder<'tcx> for MetadataDecodeContext<'a, 'tcx> {
+impl<'a, 'tcx> rustc_type_ir::codec::TyDecoder<'tcx> for MetadataDecodeContext<'a, 'tcx> {
     type Interner = TyCtxt<'tcx>;
 
     const CLEAR_CROSS_CRATE: bool = true;

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -23,7 +23,6 @@ use rustc_middle::mir::interpret;
 use rustc_middle::query::Providers;
 use rustc_middle::traits::specialization_graph;
 use rustc_middle::ty::AssocContainer;
-use rustc_middle::ty::codec::TyEncoder;
 use rustc_middle::ty::fast_reject::{self, TreatParams};
 use rustc_middle::{bug, span_bug};
 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder, opaque};
@@ -368,7 +367,7 @@ impl<'a, 'tcx> Encodable<EncodeContext<'a, 'tcx>> for [u8] {
     }
 }
 
-impl<'a, 'tcx> TyEncoder<'tcx> for EncodeContext<'a, 'tcx> {
+impl<'a, 'tcx> rustc_type_ir::codec::TyEncoder<'tcx> for EncodeContext<'a, 'tcx> {
     type Interner = TyCtxt<'tcx>;
 
     const CLEAR_CROSS_CRATE: bool = true;

compiler/rustc_middle/src/query/on_disk_cache.rs

@@ -26,7 +26,7 @@ use crate::dep_graph::{DepNodeIndex, QuerySideEffect, SerializedDepNodeIndex};
 use crate::mir::interpret::{AllocDecodingSession, AllocDecodingState};
 use crate::mir::mono::MonoItem;
 use crate::mir::{self, interpret};
-use crate::ty::codec::{RefDecodable, TyDecoder, TyEncoder};
+use crate::ty::codec::RefDecodable;
 use crate::ty::{self, Ty, TyCtxt};
 
 const TAG_FILE_FOOTER: u128 = 0xC0FFEE_C0FFEE_C0FFEE_C0FFEE_C0FFEE;
@@ -513,7 +513,9 @@ where
     value
 }
 
-impl<'a, 'tcx> TyDecoder<'tcx> for CacheDecoder<'a, 'tcx> {
+impl<'a, 'tcx> rustc_type_ir::codec::TyDecoder<'tcx> for CacheDecoder<'a, 'tcx> {
+    type Interner = TyCtxt<'tcx>;
+
     const CLEAR_CROSS_CRATE: bool = false;
 
     #[inline]
@@ -957,7 +959,9 @@ impl<'a, 'tcx> SpanEncoder for CacheEncoder<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> TyEncoder<'tcx> for CacheEncoder<'a, 'tcx> {
+impl<'a, 'tcx> rustc_type_ir::codec::TyEncoder<'tcx> for CacheEncoder<'a, 'tcx> {
+    type Interner = TyCtxt<'tcx>;
+
     const CLEAR_CROSS_CRATE: bool = false;
 
     #[inline]

compiler/rustc_middle/src/ty/codec.rs

@@ -15,7 +15,8 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::LocalDefId;
 use rustc_middle::ty::Const;
 use rustc_serialize::{Decodable, Encodable};
-use rustc_span::{Span, SpanDecoder, SpanEncoder, Spanned};
+use rustc_span::{Span, Spanned};
+use rustc_type_ir::codec::{SHORTHAND_OFFSET, TyDecoder as IrTyDecoder, TyEncoder as IrTyEncoder};
 
 use crate::arena::ArenaAllocatable;
 use crate::infer::canonical::{CanonicalVarKind, CanonicalVarKinds};
@@ -24,58 +25,19 @@ use crate::mir::mono::MonoItem;
 use crate::ty::{self, AdtDef, GenericArgsRef, Ty, TyCtxt};
 use crate::{mir, traits};
 
-/// The shorthand encoding uses an enum's variant index `usize`
-/// and is offset by this value so it never matches a real variant.
-/// This offset is also chosen so that the first byte is never < 0x80.
-pub const SHORTHAND_OFFSET: usize = 0x80;
+pub trait TyEncoder<'tcx>: IrTyEncoder<'tcx, Interner = TyCtxt<'tcx>> {}
 
-pub trait TyEncoder<'tcx>: SpanEncoder {
-    const CLEAR_CROSS_CRATE: bool;
+impl<'tcx, T> TyEncoder<'tcx> for T where T: IrTyEncoder<'tcx, Interner = TyCtxt<'tcx>> {}
 
-    fn position(&self) -> usize;
+pub trait TyDecoder<'tcx>: IrTyDecoder<'tcx, Interner = TyCtxt<'tcx>> {}
 
-    fn type_shorthands(&mut self) -> &mut FxHashMap<Ty<'tcx>, usize>;
-
-    fn predicate_shorthands(&mut self) -> &mut FxHashMap<ty::PredicateKind<'tcx>, usize>;
-
-    fn encode_alloc_id(&mut self, alloc_id: &AllocId);
-}
-
-pub trait TyDecoder<'tcx>: SpanDecoder {
-    const CLEAR_CROSS_CRATE: bool;
-
-    fn interner(&self) -> TyCtxt<'tcx>;
-
-    fn cached_ty_for_shorthand<F>(&mut self, shorthand: usize, or_insert_with: F) -> Ty<'tcx>
-    where
-        F: FnOnce(&mut Self) -> Ty<'tcx>;
-
-    fn with_position<F, R>(&mut self, pos: usize, f: F) -> R
-    where
-        F: FnOnce(&mut Self) -> R;
-
-    fn positioned_at_shorthand(&self) -> bool {
-        (self.peek_byte() & (SHORTHAND_OFFSET as u8)) != 0
-    }
-
-    fn decode_alloc_id(&mut self) -> AllocId;
-}
+impl<'tcx, T> TyDecoder<'tcx> for T where T: IrTyDecoder<'tcx, Interner = TyCtxt<'tcx>> {}
 
 pub trait EncodableWithShorthand<'tcx, E: TyEncoder<'tcx>>: Copy + Eq + Hash {
-    type Variant: Encodable<E>;
+    type Variant;
     fn variant(&self) -> &Self::Variant;
 }
 
-#[allow(rustc::usage_of_ty_tykind)]
-impl<'tcx, E: TyEncoder<'tcx>> EncodableWithShorthand<'tcx, E> for Ty<'tcx> {
-    type Variant = ty::TyKind<'tcx>;
-
-    #[inline]
-    fn variant(&self) -> &Self::Variant {
-        self.kind()
-    }
-}
-
 impl<'tcx, E: TyEncoder<'tcx>> EncodableWithShorthand<'tcx, E> for ty::PredicateKind<'tcx> {
     type Variant = ty::PredicateKind<'tcx>;
 
@@ -106,7 +68,7 @@ where
     M: for<'b> Fn(&'b mut E) -> &'b mut FxHashMap<T, usize>,
     T: EncodableWithShorthand<'tcx, E>,
     // The discriminant and shorthand must have the same size.
-    T::Variant: DiscriminantKind<Discriminant = isize>,
+    T::Variant: DiscriminantKind<Discriminant = isize> + Encodable<E>,
 {
     let existing_shorthand = cache(encoder).get(value).copied();
     if let Some(shorthand) = existing_shorthand {
@@ -138,17 +100,11 @@ where
     }
 }
 
-impl<'tcx, E: TyEncoder<'tcx>> Encodable<E> for Ty<'tcx> {
-    fn encode(&self, e: &mut E) {
-        encode_with_shorthand(e, self, TyEncoder::type_shorthands);
-    }
-}
-
 impl<'tcx, E: TyEncoder<'tcx>> Encodable<E> for ty::Predicate<'tcx> {
     fn encode(&self, e: &mut E) {
         let kind = self.kind();
         kind.bound_vars().encode(e);
-        encode_with_shorthand(e, &kind.skip_binder(), TyEncoder::predicate_shorthands);
+        encode_with_shorthand(e, &kind.skip_binder(), |e| e.predicate_shorthands());
     }
 }
 
@@ -230,25 +186,6 @@ fn decode_arena_allocable_slice<
     decoder.interner().arena.alloc_from_iter(<Vec<T> as Decodable<D>>::decode(decoder))
 }
 
-impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for Ty<'tcx> {
-    #[allow(rustc::usage_of_ty_tykind)]
-    fn decode(decoder: &mut D) -> Ty<'tcx> {
-        // Handle shorthands first, if we have a usize > 0x80.
-        if decoder.positioned_at_shorthand() {
-            let pos = decoder.read_usize();
-            assert!(pos >= SHORTHAND_OFFSET);
-            let shorthand = pos - SHORTHAND_OFFSET;
-
-            decoder.cached_ty_for_shorthand(shorthand, |decoder| {
-                decoder.with_position(shorthand, Ty::decode)
-            })
-        } else {
-            let tcx = decoder.interner();
-            tcx.mk_ty_from_kind(ty::TyKind::decode(decoder))
-        }
-    }
-}
-
 impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for ty::Predicate<'tcx> {
     fn decode(decoder: &mut D) -> ty::Predicate<'tcx> {
         let bound_vars = Decodable::decode(decoder);

compiler/rustc_middle/src/ty/mod.rs

@@ -122,7 +122,7 @@ use crate::middle::privacy::EffectiveVisibilities;
 use crate::mir::{Body, CoroutineLayout, CoroutineSavedLocal, SourceInfo};
 use crate::query::{IntoQueryParam, Providers};
 use crate::ty;
-use crate::ty::codec::{TyDecoder, TyEncoder};
+use crate::ty::codec::{TyDecoder as CodecTyDecoder, TyEncoder as CodecTyEncoder};
 pub use crate::ty::diagnostics::*;
 use crate::ty::fast_reject::SimplifiedType;
 use crate::ty::layout::{FnAbiError, LayoutError};
@@ -558,13 +558,13 @@ impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for Term<'tcx> {
     }
 }
 
-impl<'tcx, E: TyEncoder<'tcx>> Encodable<E> for Term<'tcx> {
+impl<'tcx, E: CodecTyEncoder<'tcx>> Encodable<E> for Term<'tcx> {
     fn encode(&self, e: &mut E) {
         self.kind().encode(e)
     }
 }
 
-impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for Term<'tcx> {
+impl<'tcx, D: CodecTyDecoder<'tcx>> Decodable<D> for Term<'tcx> {
     fn decode(d: &mut D) -> Self {
         let res: TermKind<'tcx> = Decodable::decode(d);
         res.pack()

compiler/rustc_type_ir/src/codec.rs

@@ -0,0 +1,105 @@
+use rustc_hash::FxHashMap;
+use rustc_serialize::{Decodable, Encodable};
+use rustc_span::{SpanDecoder, SpanEncoder};
+
+use crate::{Interner, PredicateKind, Ty, TyKind};
+
+/// The shorthand encoding uses an enum's variant index `usize`
+/// and is offset by this value so it never matches a real variant.
+/// This offset is also chosen so that the first byte is never < 0x80.
+pub const SHORTHAND_OFFSET: usize = 0x80;
+
+pub trait TyEncoder<'tcx>: SpanEncoder {
+    type Interner: Interner;
+
+    const CLEAR_CROSS_CRATE: bool;
+
+    fn position(&self) -> usize;
+
+    fn type_shorthands(&mut self) -> &mut FxHashMap<Ty<Self::Interner>, usize>;
+
+    fn predicate_shorthands(&mut self) -> &mut FxHashMap<PredicateKind<Self::Interner>, usize>;
+
+    fn encode_alloc_id(&mut self, alloc_id: &<Self::Interner as Interner>::AllocId);
+}
+
+pub trait TyDecoder<'tcx>: SpanDecoder {
+    type Interner: Interner;
+
+    const CLEAR_CROSS_CRATE: bool;
+
+    fn interner(&self) -> Self::Interner;
+
+    fn cached_ty_for_shorthand<F>(
+        &mut self,
+        shorthand: usize,
+        or_insert_with: F,
+    ) -> Ty<Self::Interner>
+    where
+        F: FnOnce(&mut Self) -> Ty<Self::Interner>;
+
+    fn with_position<F, R>(&mut self, pos: usize, f: F) -> R
+    where
+        F: FnOnce(&mut Self) -> R;
+
+    fn positioned_at_shorthand(&self) -> bool {
+        (self.peek_byte() & (SHORTHAND_OFFSET as u8)) != 0
+    }
+
+    fn decode_alloc_id(&mut self) -> <Self::Interner as Interner>::AllocId;
+}
+
+impl<'tcx, I, E> Encodable<E> for Ty<I>
+where
+    I: Interner,
+    E: TyEncoder<'tcx, Interner = I>,
+    TyKind<I>: Encodable<E>,
+{
+    fn encode(&self, e: &mut E) {
+        let existing_shorthand = e.type_shorthands().get(self).copied();
+        if let Some(shorthand) = existing_shorthand {
+            e.emit_usize(shorthand);
+            return;
+        }
+
+        let kind = crate::inherent::IntoKind::kind(*self);
+        let start = e.position();
+        kind.encode(e);
+        let len = e.position() - start;
+
+        let shorthand = start + SHORTHAND_OFFSET;
+
+        // Get the number of bits that leb128 could fit
+        // in the same space as the fully encoded type.
+        let leb128_bits = len * 7;
+
+        // Check that the shorthand is a not longer than the
+        // full encoding itself, i.e., it's an obvious win.
+        if leb128_bits >= 64 || (shorthand as u64) < (1 << leb128_bits) {
+            e.type_shorthands().insert(*self, shorthand);
+        }
+    }
+}
+
+impl<'tcx, I, D> Decodable<D> for Ty<I>
+where
+    I: Interner,
+    D: TyDecoder<'tcx, Interner = I>,
+    TyKind<I>: Decodable<D>,
+{
+    fn decode(decoder: &mut D) -> Ty<I> {
+        // Handle shorthands first, if we have a usize > 0x80.
+        if decoder.positioned_at_shorthand() {
+            let pos = decoder.read_usize();
+            assert!(pos >= SHORTHAND_OFFSET);
+            let shorthand = pos - SHORTHAND_OFFSET;
+
+            decoder.cached_ty_for_shorthand(shorthand, |decoder| {
+                decoder.with_position(shorthand, Ty::decode)
+            })
+        } else {
+            let interner = decoder.interner();
+            interner.mk_ty_from_kind(TyKind::decode(decoder))
+        }
+    }
+}

compiler/rustc_type_ir/src/lib.rs

@@ -19,6 +19,8 @@ use rustc_macros::{Decodable, Encodable, HashStable_NoContext};
 
 // These modules are `pub` since they are not glob-imported.
 #[cfg(feature = "nightly")]
+pub mod codec;
+#[cfg(feature = "nightly")]
 pub mod data_structures;
 pub mod elaborate;
 pub mod error;
@@ -65,6 +67,8 @@ pub use TyKind::*;
 pub use Variance::*;
 pub use binder::{Placeholder, *};
 pub use canonical::*;
+#[cfg(feature = "nightly")]
+pub use codec::*;
 pub use const_kind::*;
 pub use flags::*;
 pub use fold::*;