feat: Add a ty::View

`ty::View<'tcx, T>` acts like a `T` but internally stores a `Ty<'tcx>`
pointer. Thanks to this, it is possible to retrieve the original `Ty`
value without needing to ask the interner for it.

Looking up the already created type (`T`) takes a good chunk of the
time in `infer/outlives/verify.rs` so this should be a good speedup.
It may be applicable in other places as well, but those are far lower
when profiling.

Author: Marwes

src/librustc/infer/outlives/obligations.rs

@@ -321,7 +321,7 @@ where
         &mut self,
         origin: infer::SubregionOrigin<'tcx>,
         region: ty::Region<'tcx>,
-        param_ty: ty::ParamTy,
+        param_ty: ty::View<'tcx, ty::ParamTy>,
     ) {
         debug!(
             "param_ty_must_outlive(region={:?}, param_ty={:?}, origin={:?})",

src/librustc/infer/outlives/verify.rs

@@ -2,7 +2,7 @@ use crate::infer::outlives::env::RegionBoundPairs;
 use crate::infer::{GenericKind, VerifyBound};
 use crate::traits;
 use crate::ty::subst::{InternalSubsts, Subst};
-use crate::ty::{self, Ty, TyCtxt};
+use crate::ty::{self, Ty, TyCtxt, View};
 use rustc_data_structures::captures::Captures;
 use rustc_hir::def_id::DefId;
 
@@ -40,13 +40,13 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
 
     fn type_bound(&self, ty: Ty<'tcx>) -> VerifyBound<'tcx> {
         match ty.kind {
-            ty::Param(p) => self.param_bound(p),
+            ty::Param(_) => self.param_bound(View::new(ty).unwrap()),
             ty::Projection(data) => self.projection_bound(data),
             _ => self.recursive_type_bound(ty),
         }
     }
 
-    fn param_bound(&self, param_ty: ty::ParamTy) -> VerifyBound<'tcx> {
+    fn param_bound(&self, param_ty: View<'tcx, ty::ParamTy>) -> VerifyBound<'tcx> {
         debug!("param_bound(param_ty={:?})", param_ty);
 
         // Start with anything like `T: 'a` we can scrape from the
@@ -161,9 +161,9 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
     /// bounds, but all the bounds it returns can be relied upon.
     fn declared_generic_bounds_from_env(
         &self,
-        generic: GenericKind<'tcx>,
+        generic: View<'tcx, ty::ParamTy>,
     ) -> Vec<ty::OutlivesPredicate<Ty<'tcx>, ty::Region<'tcx>>> {
-        let generic_ty = generic.to_ty(self.tcx);
+        let generic_ty = generic.as_ty();
         self.declared_generic_bounds_from_env_with_compare_fn(|ty| ty == generic_ty)
     }
 

src/librustc/infer/region_constraints/mod.rs

@@ -184,7 +184,7 @@ pub struct Verify<'tcx> {
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, TypeFoldable)]
 pub enum GenericKind<'tcx> {
-    Param(ty::ParamTy),
+    Param(ty::View<'tcx, ty::ParamTy>),
     Projection(ty::ProjectionTy<'tcx>),
 }
 

src/librustc/traits/query/outlives_bounds.rs

@@ -20,7 +20,7 @@ use std::mem;
 #[derive(Clone, Debug, TypeFoldable, Lift)]
 pub enum OutlivesBound<'tcx> {
     RegionSubRegion(ty::Region<'tcx>, ty::Region<'tcx>),
-    RegionSubParam(ty::Region<'tcx>, ty::ParamTy),
+    RegionSubParam(ty::Region<'tcx>, ty::View<'tcx, ty::ParamTy>),
     RegionSubProjection(ty::Region<'tcx>, ty::ProjectionTy<'tcx>),
 }
 

src/librustc/ty/mod.rs

@@ -91,6 +91,8 @@ pub use self::trait_def::TraitDef;
 
 pub use self::query::queries;
 
+pub use self::view::View;
+
 pub mod adjustment;
 pub mod binding;
 pub mod cast;
@@ -114,6 +116,7 @@ pub mod steal;
 pub mod subst;
 pub mod trait_def;
 pub mod util;
+pub mod view;
 pub mod walk;
 
 mod context;

src/librustc/ty/outlives.rs

@@ -8,7 +8,7 @@ use smallvec::SmallVec;
 #[derive(Debug)]
 pub enum Component<'tcx> {
     Region(ty::Region<'tcx>),
-    Param(ty::ParamTy),
+    Param(ty::View<'tcx, ty::ParamTy>),
     UnresolvedInferenceVariable(ty::InferTy),
 
     // Projections like `T::Foo` are tricky because a constraint like
@@ -82,8 +82,8 @@ fn compute_components(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, out: &mut SmallVec<[Compo
 
             // OutlivesTypeParameterEnv -- the actual checking that `X:'a`
             // is implied by the environment is done in regionck.
-            ty::Param(p) => {
-                out.push(Component::Param(p));
+            ty::Param(_) => {
+                out.push(Component::Param(ty::View::new(ty).unwrap()));
             }
 
             // For projections, we prefer to generate an obligation like

src/librustc/ty/structural_impls.rs

@@ -13,6 +13,7 @@ use rustc_index::vec::{Idx, IndexVec};
 
 use smallvec::SmallVec;
 use std::fmt;
+use std::marker::PhantomData;
 use std::rc::Rc;
 use std::sync::Arc;
 
@@ -389,6 +390,13 @@ impl<'tcx, I: Idx, T: Lift<'tcx>> Lift<'tcx> for IndexVec<I, T> {
     }
 }
 
+impl<'tcx, T: Lift<'tcx>> Lift<'tcx> for PhantomData<T> {
+    type Lifted = PhantomData<T::Lifted>;
+    fn lift_to_tcx(&self, _tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
+        Some(PhantomData)
+    }
+}
+
 impl<'a, 'tcx> Lift<'tcx> for ty::TraitRef<'a> {
     type Lifted = ty::TraitRef<'tcx>;
     fn lift_to_tcx(&self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
@@ -1067,3 +1075,13 @@ impl<'tcx> TypeFoldable<'tcx> for InferConst<'tcx> {
         false
     }
 }
+
+impl<'tcx, T> TypeFoldable<'tcx> for PhantomData<T> {
+    fn super_fold_with<F: TypeFolder<'tcx>>(&self, _folder: &mut F) -> Self {
+        *self
+    }
+
+    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, _visitor: &mut V) -> bool {
+        false
+    }
+}

src/librustc/ty/view.rs

@@ -0,0 +1,182 @@
+use std::{fmt, marker::PhantomData};
+
+use syntax::ast;
+
+use crate::{
+    hir::{self, def_id::DefId},
+    ty::{
+        self, AdtDef, Binder, BoundTy, ExistentialPredicate, InferTy, List, ParamTy, PolyFnSig,
+        ProjectionTy, Region, SubstsRef, Ty, TypeAndMut,
+    },
+};
+
+pub use self::ViewKind::*;
+
+// TODO Forward eq/hash?
+#[derive(Eq, PartialEq, Hash, TypeFoldable, Lift)]
+pub struct View<'tcx, T> {
+    ty: Ty<'tcx>,
+    _marker: PhantomData<T>,
+}
+
+impl<T> Copy for View<'_, T> {}
+impl<T> Clone for View<'_, T> {
+    fn clone(&self) -> Self {
+        View { ty: self.ty, _marker: PhantomData }
+    }
+}
+
+impl<'tcx, T> fmt::Debug for View<'tcx, T>
+where
+    T: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.ty.fmt(f)
+    }
+}
+
+impl<'tcx, T> fmt::Display for View<'tcx, T>
+where
+    T: fmt::Display + TyDeref<'tcx> + 'tcx,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+impl<'tcx, T> std::ops::Deref for View<'tcx, T>
+where
+    T: TyDeref<'tcx> + 'tcx,
+{
+    type Target = T;
+    fn deref(&self) -> &Self::Target {
+        match T::ty_deref(self.ty) {
+            Some(t) => t,
+            // SAFETY verified by `View::new`
+            None => unsafe { std::hint::unreachable_unchecked() },
+        }
+    }
+}
+
+impl<'tcx, T> View<'tcx, T>
+where
+    T: TyDeref<'tcx> + 'tcx,
+{
+    pub fn new(ty: Ty<'tcx>) -> Option<Self> {
+        T::ty_deref(ty)?;
+        Some(View { ty, _marker: PhantomData })
+    }
+}
+
+impl<'tcx, T> View<'tcx, T> {
+    pub fn as_ty(&self) -> Ty<'tcx> {
+        self.ty
+    }
+}
+
+/// SAFETY If `Some` is returned for `ty` then `Some` must always be returned for any subsequent
+/// call with the same `Ty` value
+pub unsafe trait TyDeref<'tcx>: Sized {
+    fn ty_deref(ty: Ty<'tcx>) -> Option<&'tcx Self>;
+}
+
+unsafe impl<'tcx> TyDeref<'tcx> for ty::ParamTy {
+    fn ty_deref(ty: Ty<'tcx>) -> Option<&'tcx Self> {
+        match &ty.kind {
+            ty::Param(p) => Some(p),
+            _ => None,
+        }
+    }
+}
+
+pub enum ViewKind<'tcx> {
+    Bool,
+
+    Char,
+
+    Int(ast::IntTy),
+
+    Uint(ast::UintTy),
+
+    Float(ast::FloatTy),
+
+    Adt(&'tcx AdtDef, SubstsRef<'tcx>),
+
+    Foreign(DefId),
+
+    Str,
+
+    Array(Ty<'tcx>, &'tcx ty::Const<'tcx>),
+
+    Slice(Ty<'tcx>),
+
+    RawPtr(TypeAndMut<'tcx>),
+
+    Ref(Region<'tcx>, Ty<'tcx>, hir::Mutability),
+
+    FnDef(DefId, SubstsRef<'tcx>),
+
+    FnPtr(PolyFnSig<'tcx>),
+
+    Dynamic(Binder<&'tcx List<ExistentialPredicate<'tcx>>>, ty::Region<'tcx>),
+
+    Closure(DefId, SubstsRef<'tcx>),
+
+    Generator(DefId, SubstsRef<'tcx>, hir::Movability),
+
+    GeneratorWitness(Binder<&'tcx List<Ty<'tcx>>>),
+
+    Never,
+
+    Tuple(SubstsRef<'tcx>),
+
+    Projection(ProjectionTy<'tcx>),
+
+    UnnormalizedProjection(ProjectionTy<'tcx>),
+
+    Opaque(DefId, SubstsRef<'tcx>),
+
+    Param(View<'tcx, ParamTy>),
+
+    Bound(ty::DebruijnIndex, BoundTy),
+
+    Placeholder(ty::PlaceholderType),
+
+    Infer(InferTy),
+
+    Error,
+}
+
+impl<'tcx> From<Ty<'tcx>> for ViewKind<'tcx> {
+    fn from(ty: Ty<'tcx>) -> Self {
+        match ty.kind {
+            ty::RawPtr(tm) => Self::RawPtr(tm),
+            ty::Array(typ, sz) => Self::Array(typ, sz),
+            ty::Slice(typ) => Self::Slice(typ),
+            ty::Adt(tid, substs) => Self::Adt(tid, substs),
+            ty::Dynamic(trait_ty, region) => Self::Dynamic(trait_ty, region),
+            ty::Tuple(ts) => Self::Tuple(ts),
+            ty::FnDef(def_id, substs) => Self::FnDef(def_id, substs),
+            ty::FnPtr(f) => Self::FnPtr(f),
+            ty::Ref(r, ty, mutbl) => Self::Ref(r, ty, mutbl),
+            ty::Generator(did, substs, movability) => Self::Generator(did, substs, movability),
+            ty::GeneratorWitness(types) => Self::GeneratorWitness(types),
+            ty::Closure(did, substs) => Self::Closure(did, substs),
+            ty::Projection(data) => Self::Projection(data),
+            ty::UnnormalizedProjection(data) => Self::UnnormalizedProjection(data),
+            ty::Opaque(did, substs) => Self::Opaque(did, substs),
+            ty::Bool => Self::Bool,
+            ty::Char => Self::Char,
+            ty::Str => Self::Str,
+            ty::Int(i) => Self::Int(i),
+            ty::Uint(i) => Self::Uint(i),
+            ty::Float(f) => Self::Float(f),
+            ty::Error => Self::Error,
+            ty::Infer(i) => Self::Infer(i),
+            ty::Param(_) => Self::Param(View::new(ty).unwrap()),
+            ty::Bound(b, c) => Self::Bound(b, c),
+            ty::Placeholder(p) => Self::Placeholder(p),
+            ty::Never => Self::Never,
+            ty::Foreign(f) => Self::Foreign(f),
+        }
+    }
+}