feat: Add ViewKind as a mirror on TyKind

Marwes · Marwes · commit 8010cf818aad · 2020-01-05T16:07:51.000+01:00
But it instead provies "view" types when possible
diff --git a/src/librustc/infer/lexical_region_resolve/mod.rs b/src/librustc/infer/lexical_region_resolve/mod.rs
@@ -606,7 +606,7 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> {
                 continue;
             }
 
-            let verify_kind_ty = verify.kind.to_ty(self.tcx());
+            let verify_kind_ty = verify.kind.as_ty();
             if self.bound_is_met(&verify.bound, var_data, verify_kind_ty, sub) {
                 continue;
             }
diff --git a/src/librustc/infer/outlives/obligations.rs b/src/librustc/infer/outlives/obligations.rs
@@ -348,7 +348,7 @@ where
         &mut self,
         origin: infer::SubregionOrigin<'tcx>,
         region: ty::Region<'tcx>,
-        projection_ty: ty::ProjectionTy<'tcx>,
+        projection_ty: ty::View<'tcx, ty::ProjectionTy<'tcx>>,
     ) where
         'tcx: 'e,
     {
@@ -389,8 +389,8 @@ where
         // #55756) in cases where you have e.g., `<T as Foo<'a>>::Item:
         // 'a` in the environment but `trait Foo<'b> { type Item: 'b
         // }` in the trait definition.
-        approx_env_bounds.retain(|bound| match bound.0.kind {
-            ty::Projection(projection_ty) => self
+        approx_env_bounds.retain(|bound| match bound.0.into() {
+            ty::view::Projection(projection_ty) => self
                 .verify_bound
                 .projection_declared_bounds_from_trait(projection_ty)
                 .all(|r| r != bound.1),
diff --git a/src/librustc/infer/outlives/verify.rs b/src/librustc/infer/outlives/verify.rs
@@ -41,9 +41,9 @@ impl<'cx, 'tcx, 'e> VerifyBoundCx<'cx, 'tcx, 'e> {
     }
 
     fn type_bound(&mut self, ty: Ty<'tcx>) -> VerifyBound<'tcx> {
-        match ty.kind {
-            ty::Param(_) => self.param_bound(View::new(ty).unwrap()),
-            ty::Projection(data) => self.projection_bound(data),
+        match ty.into() {
+            ty::view::Param(p) => self.param_bound(p),
+            ty::view::Projection(data) => self.projection_bound(data),
             _ => self.recursive_type_bound(ty),
         }
     }
@@ -78,12 +78,12 @@ impl<'cx, 'tcx, 'e> VerifyBoundCx<'cx, 'tcx, 'e> {
     /// this list.
     pub fn projection_approx_declared_bounds_from_env(
         &self,
-        projection_ty: ty::ProjectionTy<'tcx>,
+        projection_ty: ty::View<'tcx, ty::ProjectionTy<'tcx>>,
     ) -> impl Iterator<Item = ty::OutlivesPredicate<Ty<'tcx>, ty::Region<'tcx>>> + Captures2<'cx, 'tcx>
     {
         let tcx = self.tcx;
 
-        let projection_ty = GenericKind::Projection(projection_ty).to_ty(tcx);
+        let projection_ty = projection_ty.as_ty();
         let erased_projection_ty = tcx.erase_regions(&projection_ty);
         self.declared_generic_bounds_from_env_with_compare_fn(move |ty| {
             if let ty::Projection(..) = ty.kind {
@@ -100,16 +100,18 @@ impl<'cx, 'tcx, 'e> VerifyBoundCx<'cx, 'tcx, 'e> {
     /// exact match.
     pub fn projection_declared_bounds_from_trait<'a>(
         &'a mut self,
-        projection_ty: ty::ProjectionTy<'tcx>,
+        projection_ty: ty::View<'tcx, ty::ProjectionTy<'tcx>>,
     ) -> impl Iterator<Item = ty::Region<'tcx>> + 'a + Captures3<'cx, 'tcx, 'e> {
         self.declared_projection_bounds_from_trait(projection_ty)
     }
 
-    pub fn projection_bound(&mut self, projection_ty: ty::ProjectionTy<'tcx>) -> VerifyBound<'tcx> {
+    pub fn projection_bound(
+        &mut self,
+        projection_ty: ty::View<'tcx, ty::ProjectionTy<'tcx>>,
+    ) -> VerifyBound<'tcx> {
         debug!("projection_bound(projection_ty={:?})", projection_ty);
 
-        let projection_ty_as_ty =
-            self.tcx.mk_projection(projection_ty.item_def_id, projection_ty.substs);
+        let projection_ty_as_ty = projection_ty.as_ty();
 
         // Search the env for where clauses like `P: 'a`.
         let mut bounds = Vec::new();
@@ -136,7 +138,7 @@ impl<'cx, 'tcx, 'e> VerifyBoundCx<'cx, 'tcx, 'e> {
 
         VerifyBound::AnyBound(bounds).or(|| {
             // see the extensive comment in projection_must_outlive
-            let ty = self.tcx.mk_projection(projection_ty.item_def_id, projection_ty.substs);
+            let ty = projection_ty.as_ty();
             self.recursive_type_bound(ty)
         })
     }
@@ -178,8 +180,6 @@ impl<'cx, 'tcx, 'e> VerifyBoundCx<'cx, 'tcx, 'e> {
         compare_ty: impl Fn(Ty<'tcx>) -> bool + Clone + 'tcx + Captures<'cx>,
     ) -> impl Iterator<Item = ty::OutlivesPredicate<Ty<'tcx>, ty::Region<'tcx>>> + Captures2<'cx, 'tcx>
     {
-        let tcx = self.tcx;
-
         // To start, collect bounds from user environment. Note that
         // parameter environments are already elaborated, so we don't
         // have to worry about that. Comparing using `==` is a bit
@@ -205,7 +205,7 @@ impl<'cx, 'tcx, 'e> VerifyBoundCx<'cx, 'tcx, 'e> {
                 "declared_generic_bounds_from_env_with_compare_fn: region_bound_pair = {:?}",
                 (r, p)
             );
-            let p_ty = p.to_ty(tcx);
+            let p_ty = p.as_ty();
             compare_ty(p_ty).then_some(ty::OutlivesPredicate(p_ty, r))
         });
 
@@ -231,7 +231,7 @@ impl<'cx, 'tcx, 'e> VerifyBoundCx<'cx, 'tcx, 'e> {
     /// `region_bounds_declared_on_associated_item`.
     fn declared_projection_bounds_from_trait<'a>(
         &'a mut self,
-        projection_ty: ty::ProjectionTy<'tcx>,
+        projection_ty: ty::View<'tcx, ty::ProjectionTy<'tcx>>,
     ) -> impl Iterator<Item = ty::Region<'tcx>> + 'a + Captures3<'cx, 'tcx, 'e> {
         debug!("projection_bounds(projection_ty={:?})", projection_ty);
         let tcx = self.tcx;
diff --git a/src/librustc/infer/region_constraints/mod.rs b/src/librustc/infer/region_constraints/mod.rs
@@ -185,7 +185,7 @@ pub struct Verify<'tcx> {
 #[derive(Copy, Clone, PartialEq, Eq, Hash, TypeFoldable)]
 pub enum GenericKind<'tcx> {
     Param(ty::View<'tcx, ty::ParamTy>),
-    Projection(ty::ProjectionTy<'tcx>),
+    Projection(ty::View<'tcx, ty::ProjectionTy<'tcx>>),
 }
 
 /// Describes the things that some `GenericKind` value `G` is known to
@@ -875,10 +875,10 @@ impl<'tcx> fmt::Display for GenericKind<'tcx> {
 }
 
 impl<'tcx> GenericKind<'tcx> {
-    pub fn to_ty(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
+    pub fn as_ty(&self) -> Ty<'tcx> {
         match *self {
-            GenericKind::Param(ref p) => p.to_ty(tcx),
-            GenericKind::Projection(ref p) => tcx.mk_projection(p.item_def_id, p.substs),
+            GenericKind::Param(ref p) => p.as_ty(),
+            GenericKind::Projection(ref p) => p.as_ty(),
         }
     }
 }
diff --git a/src/librustc/traits/query/outlives_bounds.rs b/src/librustc/traits/query/outlives_bounds.rs
@@ -21,7 +21,7 @@ use std::mem;
 pub enum OutlivesBound<'tcx> {
     RegionSubRegion(ty::Region<'tcx>, ty::Region<'tcx>),
     RegionSubParam(ty::Region<'tcx>, ty::View<'tcx, ty::ParamTy>),
-    RegionSubProjection(ty::Region<'tcx>, ty::ProjectionTy<'tcx>),
+    RegionSubProjection(ty::Region<'tcx>, ty::View<'tcx, ty::ProjectionTy<'tcx>>),
 }
 
 impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for OutlivesBound<'tcx> {
diff --git a/src/librustc/ty/outlives.rs b/src/librustc/ty/outlives.rs
@@ -20,7 +20,7 @@ pub enum Component<'tcx> {
     // is not in a position to judge which is the best technique, so
     // we just product the projection as a component and leave it to
     // the consumer to decide (but see `EscapingProjection` below).
-    Projection(ty::ProjectionTy<'tcx>),
+    Projection(ty::View<'tcx, ty::ProjectionTy<'tcx>>),
 
     // In the case where a projection has escaping regions -- meaning
     // regions bound within the type itself -- we always use
@@ -63,14 +63,14 @@ impl<'tcx> TyCtxt<'tcx> {
         // with `collect()` because of the need to sometimes skip subtrees
         // in the `subtys` iterator (e.g., when encountering a
         // projection).
-        match ty.kind {
-            ty::Closure(def_id, ref substs) => {
+        match ty.into() {
+            ty::view::Closure(def_id, ref substs) => {
                 for upvar_ty in substs.as_closure().upvar_tys(def_id, *self) {
                     self.compute_components(upvar_ty, out);
                 }
             }
 
-            ty::Generator(def_id, ref substs, _) => {
+            ty::view::Generator(def_id, ref substs, _) => {
                 // Same as the closure case
                 for upvar_ty in substs.as_generator().upvar_tys(def_id, *self) {
                     self.compute_components(upvar_ty, out);
@@ -81,12 +81,12 @@ impl<'tcx> TyCtxt<'tcx> {
             }
 
             // All regions are bound inside a witness
-            ty::GeneratorWitness(..) => (),
+            ty::view::GeneratorWitness(..) => (),
 
             // OutlivesTypeParameterEnv -- the actual checking that `X:'a`
             // is implied by the environment is done in regionck.
-            ty::Param(_) => {
-                out.push(Component::Param(ty::View::new(ty).unwrap()));
+            ty::view::Param(p) => {
+                out.push(Component::Param(p));
             }
 
             // For projections, we prefer to generate an obligation like
@@ -97,15 +97,15 @@ impl<'tcx> TyCtxt<'tcx> {
             // trait-ref. Therefore, if we see any higher-ranke regions,
             // we simply fallback to the most restrictive rule, which
             // requires that `Pi: 'a` for all `i`.
-            ty::Projection(ref data) => {
+            ty::view::Projection(data) => {
                 if !data.has_escaping_bound_vars() {
                     // best case: no escaping regions, so push the
                     // projection and skip the subtree (thus generating no
                     // constraints for Pi). This defers the choice between
                     // the rules OutlivesProjectionEnv,
                     // OutlivesProjectionTraitDef, and
                     // OutlivesProjectionComponents to regionck.
-                    out.push(Component::Projection(*data));
+                    out.push(Component::Projection(data));
                 } else {
                     // fallback case: hard code
                     // OutlivesProjectionComponents.  Continue walking
@@ -115,12 +115,12 @@ impl<'tcx> TyCtxt<'tcx> {
                 }
             }
 
-            ty::UnnormalizedProjection(..) => bug!("only used with chalk-engine"),
+            ty::view::UnnormalizedProjection(..) => bug!("only used with chalk-engine"),
 
             // We assume that inference variables are fully resolved.
             // So, if we encounter an inference variable, just record
             // the unresolved variable as a component.
-            ty::Infer(infer_ty) => {
+            ty::view::Infer(infer_ty) => {
                 out.push(Component::UnresolvedInferenceVariable(infer_ty));
             }
 
@@ -130,27 +130,27 @@ impl<'tcx> TyCtxt<'tcx> {
             // the type and then visits the types that are lexically
             // contained within. (The comments refer to relevant rules
             // from RFC1214.)
-            ty::Bool |            // OutlivesScalar
-            ty::Char |            // OutlivesScalar
-            ty::Int(..) |         // OutlivesScalar
-            ty::Uint(..) |        // OutlivesScalar
-            ty::Float(..) |       // OutlivesScalar
-            ty::Never |           // ...
-            ty::Adt(..) |         // OutlivesNominalType
-            ty::Opaque(..) |        // OutlivesNominalType (ish)
-            ty::Foreign(..) |     // OutlivesNominalType
-            ty::Str |             // OutlivesScalar (ish)
-            ty::Array(..) |       // ...
-            ty::Slice(..) |       // ...
-            ty::RawPtr(..) |      // ...
-            ty::Ref(..) |         // OutlivesReference
-            ty::Tuple(..) |       // ...
-            ty::FnDef(..) |       // OutlivesFunction (*)
-            ty::FnPtr(_) |        // OutlivesFunction (*)
-            ty::Dynamic(..) |       // OutlivesObject, OutlivesFragment (*)
-            ty::Placeholder(..) |
-            ty::Bound(..) |
-            ty::Error => {
+            ty::view::Bool |            // OutlivesScalar
+            ty::view::Char |            // OutlivesScalar
+            ty::view::Int(..) |         // OutlivesScalar
+            ty::view::Uint(..) |        // OutlivesScalar
+            ty::view::Float(..) |       // OutlivesScalar
+            ty::view::Never |           // ...
+            ty::view::Adt(..) |         // OutlivesNominalType
+            ty::view::Opaque(..) |        // OutlivesNominalType (ish)
+            ty::view::Foreign(..) |     // OutlivesNominalType
+            ty::view::Str |             // OutlivesScalar (ish)
+            ty::view::Array(..) |       // ...
+            ty::view::Slice(..) |       // ...
+            ty::view::RawPtr(..) |      // ...
+            ty::view::Ref(..) |         // OutlivesReference
+            ty::view::Tuple(..) |       // ...
+            ty::view::FnDef(..) |       // OutlivesFunction (*)
+            ty::view::FnPtr(_) |        // OutlivesFunction (*)
+            ty::view::Dynamic(..) |       // OutlivesObject, OutlivesFragment (*)
+            ty::view::Placeholder(..) |
+            ty::view::Bound(..) |
+            ty::view::Error => {
                 // (*) Bare functions and traits are both binders. In the
                 // RFC, this means we would add the bound regions to the
                 // "bound regions list".  In our representation, no such
diff --git a/src/librustc/ty/view.rs b/src/librustc/ty/view.rs
@@ -79,70 +79,51 @@ 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,
+macro_rules! impl_ty_deref {
+    ($ty: ty, $variant: ident) => {
+        unsafe impl<'tcx> TyDeref<'tcx> for $ty {
+            fn ty_deref(ty: Ty<'tcx>) -> Option<&'tcx Self> {
+                match &ty.kind {
+                    ty::$variant(p) => Some(p),
+                    _ => None,
+                }
+            }
         }
-    }
+    };
 }
 
+impl_ty_deref! { ty::ParamTy, Param }
+impl_ty_deref! { ty::ProjectionTy<'tcx>, Projection }
+
+/// Mirror of `TyKind`, but with `View` fields where there is need for it
 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>),
-
+    Projection(View<'tcx, ProjectionTy<'tcx>>),
     UnnormalizedProjection(ProjectionTy<'tcx>),
-
     Opaque(DefId, SubstsRef<'tcx>),
-
     Param(View<'tcx, ParamTy>),
-
     Bound(ty::DebruijnIndex, BoundTy),
-
     Placeholder(ty::PlaceholderType),
-
     Infer(InferTy),
-
     Error,
 }
 
@@ -161,7 +142,7 @@ impl<'tcx> From<Ty<'tcx>> for ViewKind<'tcx> {
             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::Projection(_) => Self::Projection(View::new(ty).unwrap()),
             ty::UnnormalizedProjection(data) => Self::UnnormalizedProjection(data),
             ty::Opaque(did, substs) => Self::Opaque(did, substs),
             ty::Bool => Self::Bool,
diff --git a/src/librustc_mir/borrow_check/region_infer/mod.rs b/src/librustc_mir/borrow_check/region_infer/mod.rs
@@ -815,7 +815,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         for type_test in &self.type_tests {
             debug!("check_type_test: {:?}", type_test);
 
-            let generic_ty = type_test.generic_kind.to_ty(tcx);
+            let generic_ty = type_test.generic_kind.as_ty();
             if self.eval_verify_bound(
                 tcx,
                 body,
@@ -910,7 +910,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
 
         let TypeTest { generic_kind, lower_bound, locations, verify_bound: _ } = type_test;
 
-        let generic_ty = generic_kind.to_ty(tcx);
+        let generic_ty = generic_kind.as_ty();
         let subject = match self.try_promote_type_test_subject(infcx, generic_ty) {
             Some(s) => s,
             None => return false,

Original file line number	Diff line number	Diff line change
`@@ -606,7 +606,7 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> {`
`606`	`606`	`continue;`
`607`	`607`	`}`
`608`	`608`
`609`		`- let verify_kind_ty = verify.kind.to_ty(self.tcx());`
	`609`	`+ let verify_kind_ty = verify.kind.as_ty();`
`610`	`610`	`if self.bound_is_met(&verify.bound, var_data, verify_kind_ty, sub) {`
`611`	`611`	`continue;`
`612`	`612`	`}`
Original file line number	Diff line number	Diff line change
`@@ -185,7 +185,7 @@ pub struct Verify<'tcx> {`
`185`	`185`	`#[derive(Copy, Clone, PartialEq, Eq, Hash, TypeFoldable)]`
`186`	`186`	`pub enum GenericKind<'tcx> {`
`187`	`187`	`Param(ty::View<'tcx, ty::ParamTy>),`
`188`		`- Projection(ty::ProjectionTy<'tcx>),`
	`188`	`+ Projection(ty::View<'tcx, ty::ProjectionTy<'tcx>>),`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	/// Describes the things that some `GenericKind` value `G` is known to
`@@ -875,10 +875,10 @@ impl<'tcx> fmt::Display for GenericKind<'tcx> {`
`875`	`875`	`}`
`876`	`876`
`877`	`877`	`impl<'tcx> GenericKind<'tcx> {`
`878`		`- pub fn to_ty(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {`
	`878`	`+ pub fn as_ty(&self) -> Ty<'tcx> {`
`879`	`879`	`match *self {`
`880`		`- GenericKind::Param(ref p) => p.to_ty(tcx),`
`881`		`- GenericKind::Projection(ref p) => tcx.mk_projection(p.item_def_id, p.substs),`
	`880`	`+ GenericKind::Param(ref p) => p.as_ty(),`
	`881`	`+ GenericKind::Projection(ref p) => p.as_ty(),`
`882`	`882`	`}`
`883`	`883`	`}`
`884`	`884`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ use std::mem;`
`21`	`21`	`pub enum OutlivesBound<'tcx> {`
`22`	`22`	`RegionSubRegion(ty::Region<'tcx>, ty::Region<'tcx>),`
`23`	`23`	`RegionSubParam(ty::Region<'tcx>, ty::View<'tcx, ty::ParamTy>),`
`24`		`- RegionSubProjection(ty::Region<'tcx>, ty::ProjectionTy<'tcx>),`
	`24`	`+ RegionSubProjection(ty::Region<'tcx>, ty::View<'tcx, ty::ProjectionTy<'tcx>>),`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for OutlivesBound<'tcx> {`