intern regionoutlivespredicate

Author: csmoe

src/librustc_middle/ty/context.rs

@@ -30,7 +30,10 @@ use crate::ty::{self, DefIdTree, Ty, TypeAndMut};
 use crate::ty::{AdtDef, AdtKind, Const, Region};
 use crate::ty::{BindingMode, BoundVar};
 use crate::ty::{ConstVid, FloatVar, FloatVid, IntVar, IntVid, TyVar, TyVid};
-use crate::ty::{ExistentialPredicate, InferTy, ParamTy, PolyFnSig, Predicate, ProjectionTy};
+use crate::ty::{
+    ExistentialPredicate, InferTy, ParamTy, PolyFnSig, Predicate, ProjectionTy,
+    RegionOutlivesPredicate,
+};
 use crate::ty::{InferConst, ParamConst};
 use crate::ty::{List, TyKind, TyS};
 use rustc_ast::ast;
@@ -91,6 +94,7 @@ pub struct CtxtInterners<'tcx> {
     canonical_var_infos: InternedSet<'tcx, List<CanonicalVarInfo>>,
     region: InternedSet<'tcx, RegionKind>,
     existential_predicates: InternedSet<'tcx, List<ExistentialPredicate<'tcx>>>,
+    region_outlives_predicates: InternedSet<'tcx, List<RegionOutlivesPredicate<'tcx>>>,
     predicates: InternedSet<'tcx, List<Predicate<'tcx>>>,
     clauses: InternedSet<'tcx, List<Clause<'tcx>>>,
     goal: InternedSet<'tcx, GoalKind<'tcx>>,
@@ -109,6 +113,7 @@ impl<'tcx> CtxtInterners<'tcx> {
             substs: Default::default(),
             region: Default::default(),
             existential_predicates: Default::default(),
+            region_outlives_predicates: Default::default(),
             canonical_var_infos: Default::default(),
             predicates: Default::default(),
             clauses: Default::default(),
@@ -1588,6 +1593,7 @@ nop_list_lift! {goal_list; Goal<'a> => Goal<'tcx>}
 nop_list_lift! {clauses; Clause<'a> => Clause<'tcx>}
 nop_list_lift! {type_list; Ty<'a> => Ty<'tcx>}
 nop_list_lift! {existential_predicates; ExistentialPredicate<'a> => ExistentialPredicate<'tcx>}
+nop_list_lift! {region_outlives_predicates; RegionOutlivesPredicate<'a> => RegionOutlivesPredicate<'tcx>}
 nop_list_lift! {predicates; Predicate<'a> => Predicate<'tcx>}
 nop_list_lift! {canonical_var_infos; CanonicalVarInfo => CanonicalVarInfo}
 nop_list_lift! {projs; ProjectionKind => ProjectionKind}
@@ -2010,6 +2016,14 @@ impl<'tcx> Borrow<[ExistentialPredicate<'tcx>]>
     }
 }
 
+impl<'tcx> Borrow<[RegionOutlivesPredicate<'tcx>]>
+    for Interned<'tcx, List<RegionOutlivesPredicate<'tcx>>>
+{
+    fn borrow<'a>(&'a self) -> &'a [RegionOutlivesPredicate<'tcx>] {
+        &self.0[..]
+    }
+}
+
 impl<'tcx> Borrow<[Predicate<'tcx>]> for Interned<'tcx, List<Predicate<'tcx>>> {
     fn borrow<'a>(&'a self) -> &'a [Predicate<'tcx>] {
         &self.0[..]
@@ -2083,6 +2097,7 @@ slice_interners!(
     substs: _intern_substs(GenericArg<'tcx>),
     canonical_var_infos: _intern_canonical_var_infos(CanonicalVarInfo),
     existential_predicates: _intern_existential_predicates(ExistentialPredicate<'tcx>),
+    region_outlives_predicates: _intern_region_outlive_predicates(RegionOutlivesPredicate<'tcx>),
     predicates: _intern_predicates(Predicate<'tcx>),
     clauses: _intern_clauses(Clause<'tcx>),
     goal_list: _intern_goals(Goal<'tcx>),
@@ -2332,7 +2347,7 @@ impl<'tcx> TyCtxt<'tcx> {
     pub fn mk_generator_witness(
         self,
         types: ty::Binder<&'tcx List<Ty<'tcx>>>,
-        region_outlives: ty::Binder<&'tcx List<Predicate<'tcx>>>,
+        region_outlives: ty::Binder<&'tcx List<RegionOutlivesPredicate<'tcx>>>,
     ) -> Ty<'tcx> {
         self.mk_ty(GeneratorWitness(types, region_outlives))
     }
@@ -2445,6 +2460,16 @@ impl<'tcx> TyCtxt<'tcx> {
         self._intern_existential_predicates(eps)
     }
 
+    pub fn intern_region_outlives_predicates(
+        self,
+        predicates: &[RegionOutlivesPredicate<'tcx>],
+    ) -> &'tcx List<RegionOutlivesPredicate<'tcx>> {
+        if predicates.is_empty() {
+            List::empty()
+        } else {
+            self._intern_region_outlive_predicates(predicates)
+        }
+    }
     pub fn intern_predicates(self, preds: &[Predicate<'tcx>]) -> &'tcx List<Predicate<'tcx>> {
         // FIXME consider asking the input slice to be sorted to avoid
         // re-interning permutations, in which case that would be asserted
@@ -2513,6 +2538,15 @@ impl<'tcx> TyCtxt<'tcx> {
         iter.intern_with(|xs| self.intern_existential_predicates(xs))
     }
 
+    pub fn mk_region_outlives_predicates<
+        I: InternAs<[RegionOutlivesPredicate<'tcx>], &'tcx List<RegionOutlivesPredicate<'tcx>>>,
+    >(
+        self,
+        iter: I,
+    ) -> I::Output {
+        iter.intern_with(|xs| self.intern_region_outlives_predicates(xs))
+    }
+
     pub fn mk_predicates<I: InternAs<[Predicate<'tcx>], &'tcx List<Predicate<'tcx>>>>(
         self,
         iter: I,

src/librustc_middle/ty/relate.rs

@@ -308,19 +308,38 @@ impl<'tcx> Relate<'tcx> for ty::ExistentialTraitRef<'tcx> {
     }
 }
 
+impl<'tcx> Relate<'tcx> for ty::RegionOutlivesPredicate<'tcx> {
+    fn relate<R: TypeRelation<'tcx>>(
+        relation: &mut R,
+        a: &Self,
+        b: &Self,
+    ) -> RelateResult<'tcx, Self> {
+        let a_region = relation.relate(&a.0, &b.0)?;
+        let b_region = relation.relate(&a.1, &b.1)?;
+        Ok(ty::OutlivesPredicate(a_region, b_region))
+    }
+}
+
 #[derive(Debug, Clone, TypeFoldable)]
-struct GeneratorWitness<'tcx>(&'tcx ty::List<Ty<'tcx>>);
+struct GeneratorWitness<'tcx>(
+    &'tcx ty::List<Ty<'tcx>>,
+    &'tcx ty::List<ty::RegionOutlivesPredicate<'tcx>>,
+);
 
 impl<'tcx> Relate<'tcx> for GeneratorWitness<'tcx> {
     fn relate<R: TypeRelation<'tcx>>(
         relation: &mut R,
-        a: &GeneratorWitness<'tcx>,
-        b: &GeneratorWitness<'tcx>,
-    ) -> RelateResult<'tcx, GeneratorWitness<'tcx>> {
+        a: &Self,
+        b: &Self,
+    ) -> RelateResult<'tcx, Self> {
         assert_eq!(a.0.len(), b.0.len());
+        assert_eq!(a.1.len(), b.1.len());
         let tcx = relation.tcx();
         let types = tcx.mk_type_list(a.0.iter().zip(b.0).map(|(a, b)| relation.relate(a, b)))?;
-        Ok(GeneratorWitness(types))
+        let predicates = tcx.mk_region_outlives_predicates(
+            a.1.iter().zip(b.1).map(|(a, b)| relation.relate(a, b)),
+        )?;
+        Ok(GeneratorWitness(types, predicates))
     }
 }
 
@@ -396,14 +415,19 @@ pub fn super_relate_tys<R: TypeRelation<'tcx>>(
             Ok(tcx.mk_generator(a_id, substs, movability))
         }
 
-        (&ty::GeneratorWitness(a_types, _), &ty::GeneratorWitness(b_types, _)) => {
+        (
+            &ty::GeneratorWitness(a_types, a_outlive_predicates),
+            &ty::GeneratorWitness(b_types, b_outlive_predicates),
+        ) => {
             // Wrap our types with a temporary GeneratorWitness struct
             // inside the binder so we can related them
-            let a_types = a_types.map_bound(GeneratorWitness);
-            let b_types = b_types.map_bound(GeneratorWitness);
+            let a_witness = a_types.fuse(a_outlive_predicates, GeneratorWitness);
+            let b_witness = b_types.fuse(b_outlive_predicates, GeneratorWitness);
             // Then remove the GeneratorWitness for the result
-            let types = relation.relate(&a_types, &b_types)?.map_bound(|witness| witness.0);
-            Ok(tcx.mk_generator_witness(types, ty::Binder::dummy()))
+            let types = relation.relate(&a_witness, &b_witness)?.map_bound(|witness| witness.0);
+            let predicates =
+                relation.relate(&a_witness, &b_witness)?.map_bound(|witness| witness.1);
+            Ok(tcx.mk_generator_witness(types, predicates))
         }
 
         (&ty::Closure(a_id, a_substs), &ty::Closure(b_id, b_substs)) if a_id == b_id => {

src/librustc_middle/ty/structural_impls.rs

@@ -800,6 +800,16 @@ impl<'tcx> TypeFoldable<'tcx> for &'tcx ty::List<ty::ExistentialPredicate<'tcx>>
     }
 }
 
+impl<'tcx> TypeFoldable<'tcx> for &'tcx ty::List<ty::RegionOutlivesPredicate<'tcx>> {
+    fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
+        fold_list(*self, folder, |tcx, v| tcx.intern_region_outlives_predicates(v))
+    }
+
+    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
+        self.iter().any(|p| p.visit_with(visitor))
+    }
+}
+
 impl<'tcx> TypeFoldable<'tcx> for &'tcx ty::List<Ty<'tcx>> {
     fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
         fold_list(*self, folder, |tcx, v| tcx.intern_type_list(v))

src/librustc_middle/ty/sty.rs

@@ -168,7 +168,10 @@ pub enum TyKind<'tcx> {
 
     /// A type representin the types stored inside a generator.
     /// This should only appear in GeneratorInteriors.
-    GeneratorWitness(Binder<&'tcx List<Ty<'tcx>>>, Binder<&'tcx List<ty::Predicate<'tcx>>>),
+    GeneratorWitness(
+        Binder<&'tcx List<Ty<'tcx>>>,
+        Binder<&'tcx List<ty::RegionOutlivesPredicate<'tcx>>>,
+    ),
 
     /// The never type `!`
     Never,

src/librustc_typeck/check/generator_interior.rs

@@ -192,14 +192,12 @@ pub fn resolve_interior<'a, 'tcx>(
         constraints_data
             .constraints
             .keys()
-            .map(|constraints| {
-                ty::Binder::bind(constraints.to_region_outlives_predicate(fcx.tcx)).to_predicate()
-            })
+            .map(|constraints| constraints.to_region_outlives_predicate(fcx.tcx))
             .collect::<Vec<_>>()
     });
     debug!("region outlives inside generator: {:?}", region_constraints);
 
-    let region_outlives_list = fcx.tcx.mk_predicates(region_constraints.iter());
+    let region_outlives_list = fcx.tcx.mk_region_outlives_predicates(region_constraints.iter());
 
     let witness = fcx
         .tcx