intern region outlives predicate

Author: csmoe

src/librustc_infer/infer/region_constraints/mod.rs

@@ -13,7 +13,7 @@ use rustc_hir::def_id::DefId;
 use rustc_index::vec::IndexVec;
 use rustc_middle::ty::ReStatic;
 use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_middle::ty::{OutlivesPredicate, ReLateBound, ReVar, RegionKind};
+use rustc_middle::ty::{OutlivesPredicate, ReLateBound, ReVar, RegionKind, RegionOutlivesPredicate};
 use rustc_middle::ty::{Region, RegionVid};
 use rustc_span::Span;
 
@@ -146,10 +146,7 @@ impl<'tcx> Constraint<'tcx> {
         }
     }
 
-    pub fn to_region_outlives_predicate(
-        &self,
-        tcx: &TyCtxt<'tcx>,
-    ) -> RegionOutlivesPredicate<Region<'tcx>, Region<'tcx>> {
+    pub fn to_region_outlives_predicate(&self, tcx: TyCtxt<'tcx>) -> RegionOutlivesPredicate<'tcx> {
         match self {
             Self::VarSubVar(a, b) => OutlivesPredicate(
                 tcx.mk_region(RegionKind::ReVar(*a)),

src/librustc_middle/ty/context.rs

@@ -2332,7 +2332,7 @@ impl<'tcx> TyCtxt<'tcx> {
     pub fn mk_generator_witness(
         self,
         types: ty::Binder<&'tcx List<Ty<'tcx>>>,
-        region_outlives: &'tcx List<ty::RegionOutlivesPredicate<'tcx>>,
+        region_outlives: ty::Binder<&'tcx List<Predicate<'tcx>>>,
     ) -> Ty<'tcx> {
         self.mk_ty(GeneratorWitness(types, region_outlives))
     }

src/librustc_middle/ty/mod.rs

@@ -1372,7 +1372,7 @@ pub type PolySubtypePredicate<'tcx> = ty::Binder<SubtypePredicate<'tcx>>;
 /// equality between arbitrary types. Processing an instance of
 /// Form #2 eventually yields one of these `ProjectionPredicate`
 /// instances to normalize the LHS.
-#[derive(Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
 #[derive(HashStable, TypeFoldable)]
 pub struct ProjectionPredicate<'tcx> {
     pub projection_ty: ProjectionTy<'tcx>,

src/librustc_middle/ty/relate.rs

@@ -8,7 +8,7 @@ use crate::mir::interpret::{get_slice_bytes, ConstValue};
 use crate::traits;
 use crate::ty::error::{ExpectedFound, TypeError};
 use crate::ty::subst::{GenericArg, GenericArgKind, SubstsRef};
-use crate::ty::{self, List, Ty, TyCtxt, TypeFoldable};
+use crate::ty::{self, Ty, TyCtxt, TypeFoldable};
 use rustc_hir as ast;
 use rustc_hir::def_id::DefId;
 use rustc_target::spec::abi;
@@ -403,7 +403,7 @@ pub fn super_relate_tys<R: TypeRelation<'tcx>>(
             let b_types = b_types.map_bound(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, List::empty()))
+            Ok(tcx.mk_generator_witness(types, ty::Binder::dummy()))
         }
 
         (&ty::Closure(a_id, a_substs), &ty::Closure(b_id, b_substs)) if a_id == b_id => {

src/librustc_middle/ty/sty.rs

@@ -12,8 +12,7 @@ use crate::mir::interpret::{LitToConstInput, Scalar};
 use crate::mir::Promoted;
 use crate::ty::subst::{GenericArg, InternalSubsts, Subst, SubstsRef};
 use crate::ty::{
-    self, AdtDef, DefIdTree, Discr, RegionOutlivesPredicate, Ty, TyCtxt, TypeFlags, TypeFoldable,
-    WithConstness,
+    self, AdtDef, DefIdTree, Discr, Ty, TyCtxt, TypeFlags, TypeFoldable, WithConstness,
 };
 use crate::ty::{List, ParamEnv, ParamEnvAnd, TyS};
 use polonius_engine::Atom;
@@ -169,7 +168,7 @@ 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>>>, &'tcx List<RegionOutlivesPredicate<'tcx>>),
+    GeneratorWitness(Binder<&'tcx List<Ty<'tcx>>>, Binder<&'tcx List<ty::Predicate<'tcx>>>),
 
     /// The never type `!`
     Never,

src/librustc_typeck/check/generator_interior.rs

@@ -11,7 +11,7 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc_hir::{Expr, ExprKind, Pat, PatKind};
 use rustc_middle::middle::region::{self, YieldData};
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::{self, ToPredicate, Ty};
 use rustc_span::Span;
 
 struct InteriorVisitor<'a, 'tcx> {
@@ -192,14 +192,18 @@ pub fn resolve_interior<'a, 'tcx>(
         constraints_data
             .constraints
             .keys()
-            .map(|constraints| constraints.to_region_outlives_predicate())
+            .map(|constraints| {
+                ty::Binder::bind(constraints.to_region_outlives_predicate(fcx.tcx)).to_predicate()
+            })
             .collect::<Vec<_>>()
     });
     debug!("region outlives inside generator: {:?}", region_constraints);
 
     let region_outlives_list = fcx.tcx.mk_predicates(region_constraints.iter());
 
-    let witness = fcx.tcx.mk_generator_witness(ty::Binder::bind(type_list), region_outlives_list);
+    let witness = fcx
+        .tcx
+        .mk_generator_witness(ty::Binder::bind(type_list), ty::Binder::bind(region_outlives_list));
 
     // Store the generator types and spans into the tables for this generator.
     visitor.fcx.inh.tables.borrow_mut().generator_interior_types = type_causes;