refactor away AnyRegions and AllRegions

It's a bit cleaner to just have `AnyBound` and `AllBound`, after all.

Author: nikomatsakis

src/librustc/infer/lexical_region_resolve/mod.rs

@@ -723,13 +723,11 @@ impl<'cx, 'gcx, 'tcx> LexicalResolver<'cx, 'gcx, 'tcx> {
                     && self.bound_is_met(b, var_values, generic_ty, min)
             }
 
-            VerifyBound::AnyRegion(rs) => rs.iter()
-                .map(|&r| var_values.normalize(self.tcx(), r))
-                .any(|r| self.region_rels.is_subregion_of(min, r)),
-
-            VerifyBound::AllRegions(rs) => rs.iter()
-                .map(|&r| var_values.normalize(self.tcx(), r))
-                .all(|r| self.region_rels.is_subregion_of(min, r)),
+            VerifyBound::OutlivedBy(r) =>
+                self.region_rels.is_subregion_of(
+                    min,
+                    var_values.normalize(self.tcx(), r),
+                ),
 
             VerifyBound::AnyBound(bs) => bs.iter()
                 .any(|b| self.bound_is_met(b, var_values, generic_ty, min)),

src/librustc/infer/outlives/verify.rs

@@ -63,13 +63,23 @@ impl<'cx, 'gcx, 'tcx> VerifyBoundCx<'cx, 'gcx, 'tcx> {
     fn param_bound(&self, param_ty: ty::ParamTy) -> VerifyBound<'tcx> {
         debug!("param_bound(param_ty={:?})", param_ty);
 
-        let mut param_bounds = self.declared_generic_bounds_from_env(GenericKind::Param(param_ty));
+        // Start with anything like `T: 'a` we can scrape from the
+        // environment
+        let param_bounds =
+            self.declared_generic_bounds_from_env(GenericKind::Param(param_ty))
+            .into_iter();
 
         // Add in the default bound of fn body that applies to all in
         // scope type parameters:
-        param_bounds.extend(self.implicit_region_bound);
+        let param_bounds =
+            param_bounds
+            .chain(self.implicit_region_bound);
 
-        VerifyBound::AnyRegion(param_bounds)
+        VerifyBound::AnyBound(
+            param_bounds
+                .map(|r| VerifyBound::OutlivedBy(r))
+                .collect()
+        )
     }
 
     /// Given a projection like `T::Item`, searches the environment
@@ -115,20 +125,23 @@ impl<'cx, 'gcx, 'tcx> VerifyBoundCx<'cx, 'gcx, 'tcx> {
         debug!("projection_bound(projection_ty={:?})", projection_ty);
 
         // Search the env for where clauses like `P: 'a`.
-        let mut declared_bounds =
-            self.declared_generic_bounds_from_env(GenericKind::Projection(projection_ty));
+        let env_bounds =
+            self.declared_generic_bounds_from_env(GenericKind::Projection(projection_ty))
+            .into_iter();
 
         // Extend with bounds that we can find from the trait.
-        declared_bounds.extend(self.projection_declared_bounds_from_trait(projection_ty));
-
-        debug!("projection_bound: declared_bounds = {:?}", declared_bounds);
+        let trait_bounds =
+            self.projection_declared_bounds_from_trait(projection_ty)
+            .into_iter();
 
         // see the extensive comment in projection_must_outlive
         let ty = self.tcx
             .mk_projection(projection_ty.item_def_id, projection_ty.substs);
         let recursive_bound = self.recursive_type_bound(ty);
 
-        VerifyBound::AnyRegion(declared_bounds).or(recursive_bound)
+        VerifyBound::AnyBound(
+            env_bounds.chain(trait_bounds).map(|r| VerifyBound::OutlivedBy(r)).collect()
+        ).or(recursive_bound)
     }
 
     fn recursive_type_bound(&self, ty: Ty<'tcx>) -> VerifyBound<'tcx> {
@@ -138,7 +151,11 @@ impl<'cx, 'gcx, 'tcx> VerifyBoundCx<'cx, 'gcx, 'tcx> {
 
         let mut regions = ty.regions();
         regions.retain(|r| !r.is_late_bound()); // ignore late-bound regions
-        bounds.push(VerifyBound::AllRegions(regions));
+        bounds.push(
+            VerifyBound::AllBounds(
+                regions.into_iter().map(|r| VerifyBound::OutlivedBy(r)).collect()
+            )
+        );
 
         // remove bounds that must hold, since they are not interesting
         bounds.retain(|b| !b.must_hold());

src/librustc/infer/region_constraints/mod.rs

@@ -213,40 +213,36 @@ pub enum VerifyBound<'tcx> {
     /// (after inference), and `'a: min`, then `G: min`.
     IfEq(Ty<'tcx>, Box<VerifyBound<'tcx>>),
 
-    /// Given a set of regions `R`, expands to the function:
+    /// Given a region `R`, expands to the function:
     ///
     ///     fn(min) -> bool {
-    ///       exists (r in R) { r: min }
+    ///       R: min
     ///     }
     ///
-    /// In other words, if some r in R outlives min, then G outlives
-    /// min.  This is used when G is known to outlive all the regions
-    /// in R.
-    AnyRegion(Vec<Region<'tcx>>),
-
-    /// Given a set of regions `R`, expands to the function:
-    ///
-    ///     fn(min) -> bool {
-    ///       forall (r in R) { r: min }
-    ///     }
-    ///
-    /// In other words, if all r in R outlives min, then G outlives
-    /// min. This is used when G is known to outlive some region in
-    /// R, but we don't know which.
-    AllRegions(Vec<Region<'tcx>>),
+    /// This is used when we can establish that `G: R` -- therefore,
+    /// if `R: min`, then by transitivity `G: min`.
+    OutlivedBy(Region<'tcx>),
 
     /// Given a set of bounds `B`, expands to the function:
     ///
     ///     fn(min) -> bool {
     ///       exists (b in B) { b(min) }
     ///     }
+    ///
+    /// In other words, if we meet some bound in `B`, that suffices.
+    /// This is used when all the bounds in `B` are known to apply to
+    /// G.
     AnyBound(Vec<VerifyBound<'tcx>>),
 
     /// Given a set of bounds `B`, expands to the function:
     ///
     ///     fn(min) -> bool {
     ///       forall (b in B) { b(min) }
     ///     }
+    ///
+    /// In other words, if we meet *all* bounds in `B`, that suffices.
+    /// This is used when *some* bound in `B` is known to suffice, but
+    /// we don't know which.
     AllBounds(Vec<VerifyBound<'tcx>>),
 }
 
@@ -954,8 +950,8 @@ impl<'a, 'gcx, 'tcx> VerifyBound<'tcx> {
     pub fn must_hold(&self) -> bool {
         match self {
             VerifyBound::IfEq(..) => false,
-            VerifyBound::AnyRegion(bs) => bs.contains(&&ty::ReStatic),
-            VerifyBound::AllRegions(bs) => bs.is_empty(),
+            VerifyBound::OutlivedBy(ty::ReStatic) => true,
+            VerifyBound::OutlivedBy(_) => false,
             VerifyBound::AnyBound(bs) => bs.iter().any(|b| b.must_hold()),
             VerifyBound::AllBounds(bs) => bs.iter().all(|b| b.must_hold()),
         }
@@ -964,8 +960,8 @@ impl<'a, 'gcx, 'tcx> VerifyBound<'tcx> {
     pub fn cannot_hold(&self) -> bool {
         match self {
             VerifyBound::IfEq(_, b) => b.cannot_hold(),
-            VerifyBound::AnyRegion(bs) => bs.is_empty(),
-            VerifyBound::AllRegions(bs) => bs.contains(&&ty::ReEmpty),
+            VerifyBound::OutlivedBy(ty::ReEmpty) => true,
+            VerifyBound::OutlivedBy(_) => false,
             VerifyBound::AnyBound(bs) => bs.iter().all(|b| b.cannot_hold()),
             VerifyBound::AllBounds(bs) => bs.iter().any(|b| b.cannot_hold()),
         }

src/librustc_mir/borrow_check/nll/region_infer/mod.rs

@@ -172,28 +172,19 @@ pub struct TypeTest<'tcx> {
 /// conveniently include disjuction ("a or b must be true").
 #[derive(Clone, Debug)]
 pub enum RegionTest {
-    /// The subject region `'x` must by outlived by *some* region in
-    /// the given set of regions.
+    /// The subject region `'x` must by outlived by the given region.
+    ///
+    /// This test comes from e.g. a where clause like `T: 'a`, which
+    /// implies that we know that `T: 'a`. Therefore, if we are trying
+    /// to prove that `T: 'x`, we can do so by showing that `'a: 'x`.
+    IsOutlivedBy(RegionVid),
+
+    /// Any of the given tests are true.
     ///
     /// This test comes from e.g. a where clause like `T: 'a + 'b`,
     /// which implies that we know that `T: 'a` and that `T:
     /// 'b`. Therefore, if we are trying to prove that `T: 'x`, we can
     /// do so by showing that `'a: 'x` *or* `'b: 'x`.
-    IsOutlivedByAnyRegionIn(Vec<RegionVid>),
-
-    /// The subject region `'x` must by outlived by *all* regions in
-    /// the given set of regions.
-    ///
-    /// This test comes from e.g. a projection type like `T = <u32 as
-    /// Trait<'a, 'b>>::Foo`, which must outlive `'a` or `'b`, and
-    /// maybe both. Therefore we can prove that `T: 'x` if we know
-    /// that `'a: 'x` *and* `'b: 'x`.
-    IsOutlivedByAllRegionsIn(Vec<RegionVid>),
-
-    /// Any of the given tests are true.
-    ///
-    /// This arises from projections, for which there are multiple
-    /// ways to prove an outlives relationship.
     Any(Vec<RegionTest>),
 
     /// All of the given tests are true.
@@ -895,13 +886,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         );
 
         match test {
-            RegionTest::IsOutlivedByAllRegionsIn(regions) => regions
-                .iter()
-                .all(|&r| self.eval_outlives(mir, r, lower_bound)),
-
-            RegionTest::IsOutlivedByAnyRegionIn(regions) => regions
-                .iter()
-                .any(|&r| self.eval_outlives(mir, r, lower_bound)),
+            RegionTest::IsOutlivedBy(r) => self.eval_outlives(mir, *r, lower_bound),
 
             RegionTest::Any(tests) => tests
                 .iter()

src/librustc_mir/borrow_check/nll/type_check/constraint_conversion.rs

@@ -158,15 +158,11 @@ impl<'a, 'gcx, 'tcx> ConstraintConversion<'a, 'gcx, 'tcx> {
         match verify_bound {
             VerifyBound::IfEq(..) => {
                 // FIXME: always false right now
-                RegionTest::IsOutlivedByAnyRegionIn(vec![])
+                RegionTest::Any(vec![])
             }
 
-            VerifyBound::AnyRegion(regions) => RegionTest::IsOutlivedByAnyRegionIn(
-                regions.iter().map(|r| self.to_region_vid(r)).collect(),
-            ),
-
-            VerifyBound::AllRegions(regions) => RegionTest::IsOutlivedByAllRegionsIn(
-                regions.iter().map(|r| self.to_region_vid(r)).collect(),
+            VerifyBound::OutlivedBy(r) => RegionTest::IsOutlivedBy(
+                self.to_region_vid(r)
             ),
 
             VerifyBound::AnyBound(bounds) => RegionTest::Any(