make solving "universe aware", in a simplistic way

This simple change says that if you have a constraint like

``` exists<'a> { for<'b> { 'a: 'b } } ```

you can solve it by making 'a static. This is "good enough" for now,
though not super smart, since for example

``` exists<'a> { for<'b> { if ('a: 'b) { 'a: 'b } } } ```

will still force 'a to be 'static, though it should not. (We don't
intend to fix that in this PR series; current rustc kind of sidesteps
the need to consider such concerns at the moment.)

Author: sgrif

src/librustc/infer/lexical_region_resolve/mod.rs

@@ -12,11 +12,8 @@
 
 use infer::SubregionOrigin;
 use infer::RegionVariableOrigin;
-use infer::region_constraints::Constraint;
-use infer::region_constraints::GenericKind;
-use infer::region_constraints::RegionConstraintData;
-use infer::region_constraints::VarInfos;
-use infer::region_constraints::VerifyBound;
+use infer::region_constraints::{Constraint, GenericKind, RegionConstraintData,
+                                VarInfos, VerifyBound, region_universe};
 use middle::free_region::RegionRelations;
 use rustc_data_structures::indexed_vec::{Idx, IndexVec};
 use rustc_data_structures::fx::FxHashSet;
@@ -232,11 +229,40 @@ impl<'cx, 'gcx, 'tcx> LexicalResolver<'cx, 'gcx, 'tcx> {
 
         match *b_data {
             VarValue::Value(cur_region) => {
-                let lub = self.lub_concrete_regions(a_region, cur_region);
+                let b_universe = self.var_infos[b_vid].universe;
+                let mut lub = self.lub_concrete_regions(a_region, cur_region);
                 if lub == cur_region {
                     return false;
                 }
 
+                // Find the universe of the new value (`lub`) and
+                // check whether this value is something that we can
+                // legally name in this variable. If not, promote the
+                // variable to `'static`, which is surely greater than
+                // or equal to `lub`. This is obviously a kind of sub-optimal
+                // choice -- in the future, when we incorporate a knowledge
+                // of the parameter environment, we might be able to find a
+                // tighter bound than `'static`.
+                //
+                // To make this more concrete, imagine a bound like:
+                //
+                //     for<'a> '0: 'a
+                //
+                // Here we have that `'0` must outlive `'a` -- no
+                // matter what `'a` is. When solving such a
+                // constraint, we would initially assign `'0` to be
+                // `'empty`. We would then compute the LUB of `'empty`
+                // and `'a` (which is something like `ReSkolemized(1)`),
+                // resulting in `'a`.
+                //
+                // At this point, `lub_universe` would be `1` and
+                // `b_universe` would be `0`, and hence we would wind
+                // up promoting `lub` to `'static`.
+                let lub_universe = region_universe(&self.var_infos, lub);
+                if !lub_universe.is_visible_in(b_universe) {
+                    lub = self.region_rels.tcx.types.re_static;
+                }
+
                 debug!(
                     "Expanding value of {:?} from {:?} to {:?}",
                     b_vid,

src/librustc/infer/region_constraints/mod.rs

@@ -30,7 +30,7 @@ use std::{cmp, fmt, mem, u32};
 mod taint;
 
 pub struct RegionConstraintCollector<'tcx> {
-    /// For each `RegionVid`, the corresponding `RegionVariableOrigin`.
+    /// For each `RegionVid`, the corresponding `RegionVariableInfo`.
     var_infos: IndexVec<RegionVid, RegionVariableInfo>,
 
     data: RegionConstraintData<'tcx>,
@@ -817,8 +817,8 @@ impl<'tcx> RegionConstraintCollector<'tcx> {
         if let Some(&c) = self.combine_map(t).get(&vars) {
             return tcx.mk_region(ReVar(c));
         }
-        let a_universe = self.universe(a);
-        let b_universe = self.universe(b);
+        let a_universe = region_universe(&self.var_infos, a);
+        let b_universe = region_universe(&self.var_infos, b);
         let c_universe = cmp::max(a_universe, b_universe);
         let c = self.new_region_var(c_universe, MiscVariable(origin.span()));
         self.combine_map(t).insert(vars, c);
@@ -836,22 +836,6 @@ impl<'tcx> RegionConstraintCollector<'tcx> {
         new_r
     }
 
-    fn universe(&self, region: Region<'tcx>) -> ty::UniverseIndex {
-        match *region {
-            ty::ReScope(..) |
-            ty::ReStatic |
-            ty::ReEmpty |
-            ty::ReErased |
-            ty::ReFree(..) |
-            ty::ReEarlyBound(..) => ty::UniverseIndex::ROOT,
-            ty::ReSkolemized(universe, _) => universe,
-            ty::ReClosureBound(vid) |
-            ty::ReVar(vid) => self.var_universe(vid),
-            ty::ReLateBound(..) =>
-                bug!("universe(): encountered bound region {:?}", region),
-        }
-    }
-
     pub fn vars_created_since_snapshot(&self, mark: &RegionSnapshot) -> Vec<RegionVid> {
         self.undo_log[mark.length..]
             .iter()
@@ -894,6 +878,22 @@ impl<'tcx> RegionConstraintCollector<'tcx> {
     }
 }
 
+pub fn region_universe(var_infos: &VarInfos, region: Region<'_>) -> ty::UniverseIndex {
+    match *region {
+        ty::ReScope(..) |
+        ty::ReStatic |
+        ty::ReEmpty |
+        ty::ReErased |
+        ty::ReFree(..) |
+        ty::ReEarlyBound(..) => ty::UniverseIndex::ROOT,
+        ty::ReSkolemized(universe, _) => universe,
+        ty::ReClosureBound(vid) |
+        ty::ReVar(vid) => var_infos[vid].universe,
+        ty::ReLateBound(..) =>
+            bug!("region_universe(): encountered bound region {:?}", region),
+    }
+}
+
 impl fmt::Debug for RegionSnapshot {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(

src/librustc/ty/mod.rs

@@ -1358,6 +1358,12 @@ impl UniverseIndex {
     pub fn as_usize(&self) -> usize {
         self.0 as usize
     }
+
+    /// Indicates whether a name in this universe is visible in the
+    /// universe `other`.
+    pub fn is_visible_in(self, other: UniverseIndex) -> bool {
+        self <= other
+    }
 }
 
 impl From<u32> for UniverseIndex {