add region outlives to generator witness

Author: csmoe

src/librustc/ty/walk.rs

@@ -0,0 +1,138 @@
+//! An iterator over the type substructure.
+//! WARNING: this does not keep track of the region depth.
+
+use crate::ty::{self, Ty};
+use smallvec::{self, SmallVec};
+
+// The TypeWalker's stack is hot enough that it's worth going to some effort to
+// avoid heap allocations.
+pub type TypeWalkerArray<'tcx> = [Ty<'tcx>; 8];
+pub type TypeWalkerStack<'tcx> = SmallVec<TypeWalkerArray<'tcx>>;
+
+pub struct TypeWalker<'tcx> {
+    stack: TypeWalkerStack<'tcx>,
+    last_subtree: usize,
+}
+
+impl<'tcx> TypeWalker<'tcx> {
+    pub fn new(ty: Ty<'tcx>) -> TypeWalker<'tcx> {
+        TypeWalker { stack: smallvec![ty], last_subtree: 1 }
+    }
+
+    /// Skips the subtree of types corresponding to the last type
+    /// returned by `next()`.
+    ///
+    /// Example: Imagine you are walking `Foo<Bar<int>, usize>`.
+    ///
+    /// ```
+    /// let mut iter: TypeWalker = ...;
+    /// iter.next(); // yields Foo
+    /// iter.next(); // yields Bar<int>
+    /// iter.skip_current_subtree(); // skips int
+    /// iter.next(); // yields usize
+    /// ```
+    pub fn skip_current_subtree(&mut self) {
+        self.stack.truncate(self.last_subtree);
+    }
+}
+
+impl<'tcx> Iterator for TypeWalker<'tcx> {
+    type Item = Ty<'tcx>;
+
+    fn next(&mut self) -> Option<Ty<'tcx>> {
+        debug!("next(): stack={:?}", self.stack);
+        match self.stack.pop() {
+            None => None,
+            Some(ty) => {
+                self.last_subtree = self.stack.len();
+                push_subtypes(&mut self.stack, ty);
+                debug!("next: stack={:?}", self.stack);
+                Some(ty)
+            }
+        }
+    }
+}
+
+pub fn walk_shallow(ty: Ty<'_>) -> smallvec::IntoIter<TypeWalkerArray<'_>> {
+    let mut stack = SmallVec::new();
+    push_subtypes(&mut stack, ty);
+    stack.into_iter()
+}
+
+// We push types on the stack in reverse order so as to
+// maintain a pre-order traversal. As of the time of this
+// writing, the fact that the traversal is pre-order is not
+// known to be significant to any code, but it seems like the
+// natural order one would expect (basically, the order of the
+// types as they are written).
+fn push_subtypes<'tcx>(stack: &mut TypeWalkerStack<'tcx>, parent_ty: Ty<'tcx>) {
+    match parent_ty.kind {
+        ty::Bool
+        | ty::Char
+        | ty::Int(_)
+        | ty::Uint(_)
+        | ty::Float(_)
+        | ty::Str
+        | ty::Infer(_)
+        | ty::Param(_)
+        | ty::Never
+        | ty::Error
+        | ty::Placeholder(..)
+        | ty::Bound(..)
+        | ty::Foreign(..) => {}
+        ty::Array(ty, len) => {
+            if let ty::ConstKind::Unevaluated(_, substs, promoted) = len.val {
+                assert!(promoted.is_none());
+                stack.extend(substs.types().rev());
+            }
+            stack.push(len.ty);
+            stack.push(ty);
+        }
+        ty::Slice(ty) => {
+            stack.push(ty);
+        }
+        ty::RawPtr(ref mt) => {
+            stack.push(mt.ty);
+        }
+        ty::Ref(_, ty, _) => {
+            stack.push(ty);
+        }
+        ty::Projection(ref data) | ty::UnnormalizedProjection(ref data) => {
+            stack.extend(data.substs.types().rev());
+        }
+        ty::Dynamic(ref obj, ..) => {
+            stack.extend(obj.iter().rev().flat_map(|predicate| {
+                let (substs, opt_ty) = match *predicate.skip_binder() {
+                    ty::ExistentialPredicate::Trait(tr) => (tr.substs, None),
+                    ty::ExistentialPredicate::Projection(p) => (p.substs, Some(p.ty)),
+                    ty::ExistentialPredicate::AutoTrait(_) =>
+                    // Empty iterator
+                    {
+                        (ty::InternalSubsts::empty(), None)
+                    }
+                };
+
+                substs.types().rev().chain(opt_ty)
+            }));
+        }
+        ty::Adt(_, substs) | ty::Opaque(_, substs) => {
+            stack.extend(substs.types().rev());
+        }
+        ty::Closure(_, ref substs) | ty::Generator(_, ref substs, _) => {
+            stack.extend(substs.types().rev());
+        }
+        ty::GeneratorWitness(ts, _) => {
+            stack.extend(ts.skip_binder().iter().cloned().rev());
+        }
+        ty::Tuple(..) => {
+            stack.extend(parent_ty.tuple_fields().rev());
+        }
+        ty::FnDef(_, substs) => {
+            stack.extend(substs.types().rev());
+        }
+        ty::FnPtr(sig) => {
+            stack.push(sig.skip_binder().output());
+            stack.extend(sig.skip_binder().inputs().iter().cloned().rev());
+        }
+    }
+}

src/librustc_infer/infer/region_constraints/mod.rs

@@ -146,12 +146,18 @@ impl<'tcx> Constraint<'tcx> {
         }
     }
 
-    pub fn to_region_outlives_predicate(self) -> OutlivesPredicate<RegionKind, RegionKind> {
+    pub fn to_region_outlives_predicate(
+        &self,
+        tcx: &TyCtxt<'tcx>,
+    ) -> RegionOutlivesPredicate<Region<'tcx>, Region<'tcx>> {
         match self {
-            Self::VarSubVar(a, b) => OutlivesPredicate(RegionKind::ReVar(a), RegionKind::ReVar(b)),
-            Self::RegSubVar(a, b) => OutlivesPredicate(*a, RegionKind::ReVar(b)),
-            Self::VarSubReg(a, b) => OutlivesPredicate(RegionKind::ReVar(a), *b),
-            Self::RegSubReg(a, b) => OutlivesPredicate(*a, *b),
+            Self::VarSubVar(a, b) => OutlivesPredicate(
+                tcx.mk_region(RegionKind::ReVar(*a)),
+                tcx.mk_region(RegionKind::ReVar(*b)),
+            ),
+            Self::RegSubVar(a, b) => OutlivesPredicate(a, tcx.mk_region(RegionKind::ReVar(*b))),
+            Self::VarSubReg(a, b) => OutlivesPredicate(tcx.mk_region(RegionKind::ReVar(*a)), b),
+            Self::RegSubReg(a, b) => OutlivesPredicate(a, b),
         }
     }
 }

src/librustc_middle/ty/context.rs

@@ -2329,8 +2329,12 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     #[inline]
-    pub fn mk_generator_witness(self, types: ty::Binder<&'tcx List<Ty<'tcx>>>) -> Ty<'tcx> {
-        self.mk_ty(GeneratorWitness(types))
+    pub fn mk_generator_witness(
+        self,
+        types: ty::Binder<&'tcx List<Ty<'tcx>>>,
+        region_outlives: &'tcx List<ty::RegionOutlivesPredicate<'tcx>>,
+    ) -> Ty<'tcx> {
+        self.mk_ty(GeneratorWitness(types, region_outlives))
     }
 
     #[inline]

src/librustc_middle/ty/fast_reject.rs

@@ -84,7 +84,7 @@ pub fn simplify_type(
         }
         ty::FnDef(def_id, _) | ty::Closure(def_id, _) => Some(ClosureSimplifiedType(def_id)),
         ty::Generator(def_id, _, _) => Some(GeneratorSimplifiedType(def_id)),
-        ty::GeneratorWitness(ref tys) => {
+        ty::GeneratorWitness(ref tys, _) => {
             Some(GeneratorWitnessSimplifiedType(tys.skip_binder().len()))
         }
         ty::Never => Some(NeverSimplifiedType),

src/librustc_middle/ty/flags.rs

@@ -81,7 +81,7 @@ impl FlagComputation {
                 self.add_substs(substs);
             }
 
-            &ty::GeneratorWitness(ref ts) => {
+            &ty::GeneratorWitness(ref ts, _) => {
                 let mut computation = FlagComputation::new();
                 computation.add_tys(&ts.skip_binder()[..]);
                 self.add_bound_computation(&computation);

src/librustc_middle/ty/mod.rs

@@ -795,6 +795,7 @@ impl<'a, T> IntoIterator for &'a List<T> {
 }
 
 impl<'tcx> rustc_serialize::UseSpecializedDecodable for &'tcx List<Ty<'tcx>> {}
+impl<'tcx> rustc_serialize::UseSpecializedDecodable for &'tcx List<RegionOutlivesPredicate<'tcx>> {}
 
 impl<T> List<T> {
     #[inline(always)]

src/librustc_middle/ty/print/obsolete.rs

@@ -151,7 +151,7 @@ impl DefPathBasedNames<'tcx> {
             | ty::UnnormalizedProjection(..)
             | ty::Projection(..)
             | ty::Param(_)
-            | ty::GeneratorWitness(_)
+            | ty::GeneratorWitness(..)
             | ty::Opaque(..) => {
                 if debug {
                     output.push_str(&format!("`{:?}`", t));

src/librustc_middle/ty/print/pretty.rs

@@ -643,7 +643,7 @@ pub trait PrettyPrinter<'tcx>:
 
                 p!(write("]"))
             }
-            ty::GeneratorWitness(types) => {
+            ty::GeneratorWitness(types, _) => {
                 p!(in_binder(&types));
             }
             ty::Closure(did, substs) => {

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, Ty, TyCtxt, TypeFoldable};
+use crate::ty::{self, List, Ty, TyCtxt, TypeFoldable};
 use rustc_hir as ast;
 use rustc_hir::def_id::DefId;
 use rustc_target::spec::abi;
@@ -396,14 +396,14 @@ 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, _), &ty::GeneratorWitness(b_types, _)) => {
             // 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);
             // 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))
+            Ok(tcx.mk_generator_witness(types, List::empty()))
         }
 
         (&ty::Closure(a_id, a_substs), &ty::Closure(b_id, b_substs)) if a_id == b_id => {

src/librustc_middle/ty/structural_impls.rs

@@ -884,7 +884,9 @@ impl<'tcx> TypeFoldable<'tcx> for Ty<'tcx> {
             ty::Generator(did, substs, movability) => {
                 ty::Generator(did, substs.fold_with(folder), movability)
             }
-            ty::GeneratorWitness(types) => ty::GeneratorWitness(types.fold_with(folder)),
+            ty::GeneratorWitness(types, region_outlives) => {
+                ty::GeneratorWitness(types.fold_with(folder), region_outlives)
+            }
             ty::Closure(did, substs) => ty::Closure(did, substs.fold_with(folder)),
             ty::Projection(ref data) => ty::Projection(data.fold_with(folder)),
             ty::UnnormalizedProjection(ref data) => {
@@ -928,7 +930,7 @@ impl<'tcx> TypeFoldable<'tcx> for Ty<'tcx> {
             ty::FnPtr(ref f) => f.visit_with(visitor),
             ty::Ref(r, ty, _) => r.visit_with(visitor) || ty.visit_with(visitor),
             ty::Generator(_did, ref substs, _) => substs.visit_with(visitor),
-            ty::GeneratorWitness(ref types) => types.visit_with(visitor),
+            ty::GeneratorWitness(ref types, _) => types.visit_with(visitor),
             ty::Closure(_did, ref substs) => substs.visit_with(visitor),
             ty::Projection(ref data) | ty::UnnormalizedProjection(ref data) => {
                 data.visit_with(visitor)