feat: Add ViewKind as a mirror on TyKind

Marwes · Marwes · commit 1b633b4f33ab · 2020-01-17T23:22:42.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
@@ -602,7 +602,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
@@ -337,7 +337,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>>,
     ) {
         debug!(
             "projection_must_outlive(region={:?}, projection_ty={:?}, origin={:?})",
@@ -376,8 +376,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
@@ -39,9 +39,9 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
     }
 
     fn type_bound(&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,9 +78,9 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
     /// this list.
     pub fn projection_approx_declared_bounds_from_env(
         &self,
-        projection_ty: ty::ProjectionTy<'tcx>,
+        projection_ty: ty::View<'tcx, ty::ProjectionTy<'tcx>>,
     ) -> Vec<ty::OutlivesPredicate<Ty<'tcx>, ty::Region<'tcx>>> {
-        let projection_ty = GenericKind::Projection(projection_ty).to_ty(self.tcx);
+        let projection_ty = projection_ty.as_ty();
         let erased_projection_ty = self.tcx.erase_regions(&projection_ty);
         self.declared_generic_bounds_from_env_with_compare_fn(|ty| {
             if let ty::Projection(..) = ty.kind {
@@ -97,32 +97,37 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
     /// exact match.
     pub fn projection_declared_bounds_from_trait(
         &self,
-        projection_ty: ty::ProjectionTy<'tcx>,
+        projection_ty: ty::View<'tcx, ty::ProjectionTy<'tcx>>,
     ) -> impl Iterator<Item = ty::Region<'tcx>> + 'cx + Captures<'tcx> {
         self.declared_projection_bounds_from_trait(projection_ty)
     }
 
-    pub fn projection_bound(&self, projection_ty: ty::ProjectionTy<'tcx>) -> VerifyBound<'tcx> {
+    pub fn projection_bound(
+        &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();
+
+        let mut bounds = Vec::new();
 
         // Search the env for where clauses like `P: 'a`.
-        let env_bounds = self
-            .projection_approx_declared_bounds_from_env(projection_ty)
-            .into_iter()
-            .map(|ty::OutlivesPredicate(ty, r)| {
-                let vb = VerifyBound::OutlivedBy(r);
-                if ty == projection_ty_as_ty {
-                    // Micro-optimize if this is an exact match (this
-                    // occurs often when there are no region variables
-                    // involved).
-                    vb
-                } else {
-                    VerifyBound::IfEq(ty, Box::new(vb))
-                }
-            });
+        bounds.extend(
+            self.projection_approx_declared_bounds_from_env(projection_ty).into_iter().map(
+                |ty::OutlivesPredicate(ty, r)| {
+                    let vb = VerifyBound::OutlivedBy(r);
+                    if ty == projection_ty_as_ty {
+                        // Micro-optimize if this is an exact match (this
+                        // occurs often when there are no region variables
+                        // involved).
+                        vb
+                    } else {
+                        VerifyBound::IfEq(ty, Box::new(vb))
+                    }
+                },
+            ),
+        );
 
         // Extend with bounds that we can find from the trait.
         let trait_bounds = self
@@ -198,7 +203,7 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
                 "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))
         });
 
@@ -227,7 +232,7 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
     /// `region_bounds_declared_on_associated_item`.
     fn declared_projection_bounds_from_trait(
         &self,
-        projection_ty: ty::ProjectionTy<'tcx>,
+        projection_ty: ty::View<'tcx, ty::ProjectionTy<'tcx>>,
     ) -> impl Iterator<Item = ty::Region<'tcx>> + 'cx + Captures<'tcx> {
         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(),
         }
     }
 }
@@ -904,13 +904,18 @@ impl<'tcx> VerifyBound<'tcx> {
         }
     }
 
-    pub fn or(self, vb: VerifyBound<'tcx>) -> VerifyBound<'tcx> {
-        if self.must_hold() || vb.cannot_hold() {
+    pub fn or(self, vb: impl FnOnce() -> VerifyBound<'tcx>) -> VerifyBound<'tcx> {
+        if self.must_hold() {
             self
-        } else if self.cannot_hold() || vb.must_hold() {
-            vb
         } else {
-            VerifyBound::AnyBound(vec![self, vb])
+            let vb = vb();
+            if vb.cannot_hold() {
+                self
+            } else if self.cannot_hold() || vb.must_hold() {
+                vb
+            } else {
+                VerifyBound::AnyBound(vec![self, vb])
+            }
         }
     }
 
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
@@ -61,13 +61,13 @@ fn compute_components(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, out: &mut SmallVec<[Compo
     // in the `subtys` iterator (e.g., when encountering a
     // projection).
     match ty.kind {
-            ty::Closure(def_id, ref substs) => {
+            ty::view::Closure(def_id, ref substs) => {
                 for upvar_ty in substs.as_closure().upvar_tys(def_id, tcx) {
                     compute_components(tcx, 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, tcx) {
                     compute_components(tcx, upvar_ty, out);
@@ -78,12 +78,12 @@ fn compute_components(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, out: &mut SmallVec<[Compo
             }
 
             // 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
@@ -94,15 +94,15 @@ fn compute_components(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, out: &mut SmallVec<[Compo
             // 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
@@ -112,12 +112,12 @@ fn compute_components(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, out: &mut SmallVec<[Compo
                 }
             }
 
-            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));
             }
 
@@ -127,27 +127,27 @@ fn compute_components(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, out: &mut SmallVec<[Compo
             // 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
diff --git a/src/librustc_data_structures/captures.rs b/src/librustc_data_structures/captures.rs
diff --git a/src/librustc_mir/borrow_check/region_infer/mod.rs b/src/librustc_mir/borrow_check/region_infer/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -602,7 +602,7 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> {`
`602`	`602`	`continue;`
`603`	`603`	`}`
`604`	`604`
`605`		`- let verify_kind_ty = verify.kind.to_ty(self.tcx());`
	`605`	`+ let verify_kind_ty = verify.kind.as_ty();`
`606`	`606`	`if self.bound_is_met(&verify.bound, var_data, verify_kind_ty, sub) {`
`607`	`607`	`continue;`
`608`	`608`	`}`
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`	`}`
`@@ -904,13 +904,18 @@ impl<'tcx> VerifyBound<'tcx> {`
`904`	`904`	`}`
`905`	`905`	`}`
`906`	`906`
`907`		`- pub fn or(self, vb: VerifyBound<'tcx>) -> VerifyBound<'tcx> {`
`908`		`- if self.must_hold() \|\| vb.cannot_hold() {`
	`907`	`+ pub fn or(self, vb: impl FnOnce() -> VerifyBound<'tcx>) -> VerifyBound<'tcx> {`
	`908`	`+ if self.must_hold() {`
`909`	`909`	`self`
`910`		`- } else if self.cannot_hold() \|\| vb.must_hold() {`
`911`		`- vb`
`912`	`910`	`} else {`
`913`		`- VerifyBound::AnyBound(vec![self, vb])`
	`911`	`+ let vb = vb();`
	`912`	`+ if vb.cannot_hold() {`
	`913`	`+ self`
	`914`	`+ } else if self.cannot_hold() \|\| vb.must_hold() {`
	`915`	`+ vb`
	`916`	`+ } else {`
	`917`	`+ VerifyBound::AnyBound(vec![self, vb])`
	`918`	`+ }`
`914`	`919`	`}`
`915`	`920`	`}`
`916`	`921`
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> {`