Move codec over to rustc_type_ir, move more implementations over

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;
@@ -36,6 +35,7 @@ use rustc_span::{
     BlobDecoder, BytePos, ByteSymbol, DUMMY_SP, Pos, RemapPathScopeComponents, SpanData,
     SpanDecoder, Symbol, SyntaxContext, kw,
 };
+use rustc_type_ir::codec::TyDecoder;
 use tracing::debug;
 
 use crate::creader::CStore;
@@ -387,6 +387,8 @@ impl<'a> BlobDecodeContext<'a> {
 }
 
 impl<'a, 'tcx> TyDecoder<'tcx> for MetadataDecodeContext<'a, 'tcx> {
+    type Interner = TyCtxt<'tcx>;
+
     const CLEAR_CROSS_CRATE: bool = true;
 
     #[inline]

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};
@@ -33,6 +32,7 @@ use rustc_span::{
     ByteSymbol, ExternalSource, FileName, SourceFile, SpanData, SpanEncoder, StableSourceFileId,
     Symbol, SyntaxContext, sym,
 };
+use rustc_type_ir::codec::TyEncoder;
 use tracing::{debug, instrument, trace};
 
 use crate::eii::EiiMapEncodedKeyValue;
@@ -369,6 +369,8 @@ impl<'a, 'tcx> Encodable<EncodeContext<'a, 'tcx>> for [u8] {
 }
 
 impl<'a, 'tcx> TyEncoder<'tcx> for EncodeContext<'a, 'tcx> {
+    type Interner = TyCtxt<'tcx>;
+
     const CLEAR_CROSS_CRATE: bool = true;
 
     fn position(&self) -> usize {

compiler/rustc_middle/src/query/on_disk_cache.rs

@@ -28,7 +28,7 @@ use crate::dep_graph::{DepNodeIndex, 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, TyEncoder};
 use crate::ty::{self, Ty, TyCtxt};
 
 const TAG_FILE_FOOTER: u128 = 0xC0FFEE_C0FFEE_C0FFEE_C0FFEE_C0FFEE;
@@ -526,7 +526,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]
@@ -963,7 +965,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

@@ -6,16 +6,12 @@
 //! The functionality in here is shared between persisting to crate metadata and
 //! persisting to incr. comp. caches.
 
-use std::hash::Hash;
-use std::intrinsics;
-use std::marker::{DiscriminantKind, PointeeSized};
-
 use rustc_abi::FieldIdx;
-use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::LocalDefId;
 use rustc_serialize::{Decodable, Encodable};
+use rustc_span::Span;
 use rustc_span::source_map::Spanned;
-use rustc_span::{Span, SpanDecoder, SpanEncoder};
+use rustc_type_ir::codec as ir_codec;
 
 use crate::arena::ArenaAllocatable;
 use crate::infer::canonical::{CanonicalVarKind, CanonicalVarKinds};
@@ -25,66 +21,13 @@ use crate::mir::{self};
 use crate::traits;
 use crate::ty::{self, AdtDef, GenericArgsRef, Ty, TyCtxt};
 
-/// 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 {
-    const CLEAR_CROSS_CRATE: bool;
-
-    fn position(&self) -> usize;
-
-    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;
+pub trait TyEncoder<'tcx>: ir_codec::TyEncoder<'tcx, Interner = TyCtxt<'tcx>> {}
+impl<'tcx, T> TyEncoder<'tcx> for T where T: ir_codec::TyEncoder<'tcx, Interner = TyCtxt<'tcx>> {}
 
-    fn positioned_at_shorthand(&self) -> bool {
-        (self.peek_byte() & (SHORTHAND_OFFSET as u8)) != 0
-    }
-
-    fn decode_alloc_id(&mut self) -> AllocId;
-}
+pub trait TyDecoder<'tcx>: ir_codec::TyDecoder<'tcx, Interner = TyCtxt<'tcx>> {}
+impl<'tcx, T> TyDecoder<'tcx> for T where T: ir_codec::TyDecoder<'tcx, Interner = TyCtxt<'tcx>> {}
 
-pub trait EncodableWithShorthand<'tcx, E: TyEncoder<'tcx>>: Copy + Eq + Hash {
-    type Variant: Encodable<E>;
-    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>;
-
-    #[inline]
-    fn variant(&self) -> &Self::Variant {
-        self
-    }
-}
+pub use ir_codec::{EncodableWithShorthand, SHORTHAND_OFFSET, encode_with_shorthand};
 
 /// Trait for decoding to a reference.
 ///
@@ -96,55 +39,10 @@ impl<'tcx, E: TyEncoder<'tcx>> EncodableWithShorthand<'tcx, E> for ty::Predicate
 ///
 /// `Decodable` can still be implemented in cases where `Decodable` is required
 /// by a trait bound.
-pub trait RefDecodable<'tcx, D: TyDecoder<'tcx>>: PointeeSized {
+pub trait RefDecodable<'tcx, D: TyDecoder<'tcx>>: std::marker::PointeeSized {
     fn decode(d: &mut D) -> &'tcx Self;
 }
 
-/// Encode the given value or a previously cached shorthand.
-pub fn encode_with_shorthand<'tcx, E, T, M>(encoder: &mut E, value: &T, cache: M)
-where
-    E: TyEncoder<'tcx>,
-    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>,
-{
-    let existing_shorthand = cache(encoder).get(value).copied();
-    if let Some(shorthand) = existing_shorthand {
-        encoder.emit_usize(shorthand);
-        return;
-    }
-
-    let variant = value.variant();
-
-    let start = encoder.position();
-    variant.encode(encoder);
-    let len = encoder.position() - start;
-
-    // The shorthand encoding uses the same usize as the
-    // discriminant, with an offset so they can't conflict.
-    let discriminant = intrinsics::discriminant_value(variant);
-    assert!(SHORTHAND_OFFSET > discriminant as usize);
-
-    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) {
-        cache(encoder).insert(*value, shorthand);
-    }
-}
-
-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();
@@ -231,25 +129,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/context/impl_interner.rs

@@ -4,6 +4,7 @@ use std::fmt;
 
 use rustc_abi::ExternAbi;
 use rustc_data_structures::debug_assert_matches;
+use rustc_data_structures::intern::Interned;
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind};
 use rustc_hir::def_id::{DefId, LocalDefId};
@@ -43,6 +44,8 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     type ImplId = DefId;
     type UnevaluatedConstId = DefId;
     type Span = Span;
+    type Interned<T: Copy + Clone + std::fmt::Debug + std::hash::Hash + Eq + PartialEq> =
+        Interned<'tcx, T>;
 
     type GenericArgs = ty::GenericArgsRef<'tcx>;
 
@@ -79,7 +82,6 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     fn with_cached_task<T>(self, task: impl FnOnce() -> T) -> (T, DepNodeIndex) {
         self.dep_graph.with_anon_task(self, crate::dep_graph::dep_kinds::TraitSelect, task)
     }
-    type Ty = Ty<'tcx>;
     type Tys = &'tcx List<Ty<'tcx>>;
 
     type FnInputTys = &'tcx [Ty<'tcx>];
@@ -292,6 +294,22 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self.mk_type_list_from_iter(args)
     }
 
+    fn mk_ty_from_kind(self, kind: ty::TyKind<'tcx>) -> Ty<'tcx> {
+        self.mk_ty_from_kind(kind)
+    }
+
+    fn mk_coroutine_witness_for_coroutine(
+        self,
+        def_id: DefId,
+        args: Self::GenericArgs,
+    ) -> Ty<'tcx> {
+        Ty::new_coroutine_witness_for_coroutine(self, def_id, args)
+    }
+
+    fn ty_discriminant_ty(self, ty: Ty<'tcx>) -> Ty<'tcx> {
+        ty.discriminant_ty(self)
+    }
+
     fn parent(self, def_id: DefId) -> DefId {
         self.parent(def_id)
     }

compiler/rustc_middle/src/ty/diagnostics.rs

@@ -19,15 +19,6 @@ use crate::ty::{
     TypeSuperVisitable, TypeVisitable, TypeVisitor,
 };
 
-impl IntoDiagArg for Ty<'_> {
-    fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
-        ty::tls::with(|tcx| {
-            let ty = tcx.short_string(self, path);
-            DiagArgValue::Str(std::borrow::Cow::Owned(ty))
-        })
-    }
-}
-
 impl IntoDiagArg for Instance<'_> {
     fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
         ty::tls::with(|tcx| {

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -3094,7 +3094,6 @@ macro_rules! define_print_and_forward_display {
 
 forward_display_to_print! {
     ty::Region<'tcx>,
-    Ty<'tcx>,
     &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,
     ty::Const<'tcx>
 }

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -86,12 +86,6 @@ impl fmt::Debug for ty::LateParamRegionKind {
     }
 }
 
-impl<'tcx> fmt::Debug for Ty<'tcx> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        with_no_trimmed_paths!(fmt::Debug::fmt(self.kind(), f))
-    }
-}
-
 impl fmt::Debug for ty::ParamTy {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}/#{}", self.name, self.index)

compiler/rustc_middle/src/ty/sty.rs

@@ -8,7 +8,7 @@ use std::ops::{ControlFlow, Range};
 use hir::def::{CtorKind, DefKind};
 use rustc_abi::{FIRST_VARIANT, FieldIdx, ScalableElt, VariantIdx};
 use rustc_data_structures::debug_assert_matches;
-use rustc_errors::{ErrorGuaranteed, MultiSpan};
+use rustc_errors::MultiSpan;
 use rustc_hir as hir;
 use rustc_hir::LangItem;
 use rustc_hir::def_id::DefId;
@@ -27,7 +27,7 @@ use crate::traits::ObligationCause;
 use crate::ty::InferTy::*;
 use crate::ty::{
     self, AdtDef, Discr, GenericArg, GenericArgs, GenericArgsRef, List, ParamEnv, Region, TyCtxt,
-    TypeFlags, TypeSuperVisitable, TypeVisitable, TypeVisitor, UintTy,
+    TypeSuperVisitable, TypeVisitable, TypeVisitor, UintTy,
 };
 
 // Re-export and re-parameterize some `I = TyCtxt<'tcx>` types here