Implement LUB algorithm and add new unit-testing infrastructure for infer.

r=brson

Author: nikomatsakis

src/librustc/middle/ty.rs

@@ -41,6 +41,7 @@ export expr_is_lval, expr_kind;
 export ExprKind, LvalueExpr, RvalueDatumExpr, RvalueDpsExpr, RvalueStmtExpr;
 export field_ty;
 export fold_ty, fold_sty_to_ty, fold_region, fold_regions;
+export apply_op_on_t_to_ty_fn;
 export fold_regions_and_ty, walk_regions_and_ty;
 export field;
 export field_idx, field_idx_strict;
@@ -1482,6 +1483,30 @@ fn fold_regions_and_ty(
     }
 }
 
+/* A little utility: it often happens that I have a `fn_ty`,
+ * but I want to use some function like `fold_regions_and_ty()`
+ * that is defined over all types.  This utility converts to
+ * a full type and back.  It's not the best way to do this (somewhat
+ * inefficient to do the conversion), it would be better to refactor
+ * all this folding business.  However, I've been waiting on that
+ * until trait support is improved. */
+fn apply_op_on_t_to_ty_fn(
+    cx: ctxt,
+    f: &FnTy,
+    t_op: fn(t) -> t) -> FnTy
+{
+    let t0 = ty::mk_fn(cx, *f);
+    let t1 = t_op(t0);
+    match ty::get(t1).sty {
+        ty::ty_fn(copy f) => {
+            move f
+        }
+        _ => {
+            cx.sess.bug(~"`t_op` did not return a function type");
+        }
+    }
+}
+
 // n.b. this function is intended to eventually replace fold_region() below,
 // that is why its name is so similar.
 fn fold_regions(

src/librustc/middle/typeck.rs

@@ -251,6 +251,29 @@ fn require_same_types(
     }
 }
 
+// a list of mapping from in-scope-region-names ("isr") to the
+// corresponding ty::Region
+type isr_alist = @List<(ty::bound_region, ty::Region)>;
+
+trait get_and_find_region {
+    fn get(br: ty::bound_region) -> ty::Region;
+    fn find(br: ty::bound_region) -> Option<ty::Region>;
+}
+
+impl isr_alist: get_and_find_region {
+    fn get(br: ty::bound_region) -> ty::Region {
+        self.find(br).get()
+    }
+
+    fn find(br: ty::bound_region) -> Option<ty::Region> {
+        for list::each(self) |isr| {
+            let (isr_br, isr_r) = *isr;
+            if isr_br == br { return Some(isr_r); }
+        }
+        return None;
+    }
+}
+
 fn arg_is_argv_ty(tcx: ty::ctxt, a: ty::arg) -> bool {
     match ty::resolved_mode(tcx, a.mode) {
         ast::by_val => { /*ok*/ }

src/librustc/middle/typeck/check.rs

@@ -166,29 +166,6 @@ fn blank_fn_ctxt(ccx: @crate_ctxt, rty: ty::t,
     }
 }
 
-// a list of mapping from in-scope-region-names ("isr") to the
-// corresponding ty::Region
-type isr_alist = @List<(ty::bound_region, ty::Region)>;
-
-trait get_and_find_region {
-    fn get(br: ty::bound_region) -> ty::Region;
-    fn find(br: ty::bound_region) -> Option<ty::Region>;
-}
-
-impl isr_alist: get_and_find_region {
-    fn get(br: ty::bound_region) -> ty::Region {
-        self.find(br).get()
-    }
-
-    fn find(br: ty::bound_region) -> Option<ty::Region> {
-        for list::each(self) |isr| {
-            let (isr_br, isr_r) = *isr;
-            if isr_br == br { return Some(isr_r); }
-        }
-        return None;
-    }
-}
-
 fn check_item_types(ccx: @crate_ctxt, crate: @ast::crate) {
     let visit = visit::mk_simple_visitor(@{
         visit_item: |a| check_item(ccx, a),

src/librustc/middle/typeck/infer.rs

@@ -722,5 +722,24 @@ impl infer_ctxt {
         self.type_error_message(sp, mk_msg, a, Some(err));
     }
 
+    fn replace_bound_regions_with_fresh_regions(
+        &self, span: span,
+        fty: &ty::FnTy) -> (ty::FnTy, isr_alist)
+    {
+        let {fn_ty, isr, _} =
+            replace_bound_regions_in_fn_ty(self.tcx, @Nil, None, fty, |br| {
+                // N.B.: The name of the bound region doesn't have anything to
+                // do with the region variable that's created for it.  The
+                // only thing we're doing with `br` here is using it in the
+                // debug message.
+                let rvar = self.next_region_var_nb(span);
+                debug!("Bound region %s maps to %?",
+                       bound_region_to_str(self.tcx, br),
+                       rvar);
+                rvar
+            });
+        (fn_ty, isr)
+    }
+
 }
 

src/librustc/middle/typeck/infer/combine.rs

@@ -290,7 +290,9 @@ fn super_args<C:combine>(
 
 fn super_vstores<C:combine>(
     self: &C, vk: ty::terr_vstore_kind,
-    a: ty::vstore, b: ty::vstore) -> cres<ty::vstore> {
+    a: ty::vstore, b: ty::vstore) -> cres<ty::vstore>
+{
+    debug!("%s.super_vstores(a=%?, b=%?)", self.tag(), a, b);
 
     match (a, b) {
       (ty::vstore_slice(a_r), ty::vstore_slice(b_r)) => {
@@ -517,4 +519,3 @@ fn super_tys<C:combine>(
       _ => Err(ty::terr_sorts(expected_found(self, a, b)))
     }
 }
-

src/librustc/middle/typeck/infer/lub.rs

@@ -3,6 +3,8 @@ use lattice::*;
 use to_str::ToStr;
 use syntax::ast::{Many, Once};
 
+fn macros() { include!("macros.rs"); } // FIXME(#3114): Macro import/export.
+
 enum Lub = combine_fields;  // "subtype", "subregion" etc
 
 impl Lub: combine {
@@ -102,6 +104,100 @@ impl Lub: combine {
         }
     }
 
+    fn fns(a: &ty::FnTy, b: &ty::FnTy) -> cres<ty::FnTy> {
+        // Note: this is a subtle algorithm.  For a full explanation,
+        // please see the large comment in `region_inference.rs`.
+
+        // Take a snapshot.  We'll never roll this back, but in later
+        // phases we do want to be able to examine "all bindings that
+        // were created as part of this type comparison", and making a
+        // snapshot is a convenient way to do that.
+        let snapshot = self.infcx.region_vars.start_snapshot();
+
+        // Instantiate each bound region with a fresh region variable.
+        let (a_with_fresh, a_isr) =
+            self.infcx.replace_bound_regions_with_fresh_regions(
+                self.span, a);
+        let (b_with_fresh, _) =
+            self.infcx.replace_bound_regions_with_fresh_regions(
+                self.span, b);
+
+        // Collect constraints.
+        let fn_ty0 = if_ok!(super_fns(&self, &a_with_fresh, &b_with_fresh));
+        debug!("fn_ty0 = %s", fn_ty0.to_str(self.infcx));
+
+        // Generalize the regions appearing in fn_ty0 if possible
+        let new_vars =
+            self.infcx.region_vars.vars_created_since_snapshot(snapshot);
+        let fn_ty1 =
+            ty::apply_op_on_t_to_ty_fn(
+                self.infcx.tcx, &fn_ty0,
+                |t| ty::fold_regions(
+                    self.infcx.tcx, t,
+                    |r, _in_fn| generalize_region(&self, snapshot,
+                                                  new_vars, a_isr, r)));
+        return Ok(move fn_ty1);
+
+        fn generalize_region(self: &Lub,
+                             snapshot: uint,
+                             new_vars: &[RegionVid],
+                             a_isr: isr_alist,
+                             r0: ty::Region) -> ty::Region {
+            // Regions that pre-dated the LUB computation stay as they are.
+            if !is_new_var(new_vars, r0) {
+                debug!("generalize_region(r0=%?): not new variable", r0);
+                return r0;
+            }
+
+            let tainted = self.infcx.region_vars.tainted(snapshot, r0);
+
+            // Variables created during LUB computation which are
+            // *related* to regions that pre-date the LUB computation
+            // stay as they are.
+            if !tainted.all(|r| is_new_var(new_vars, *r)) {
+                debug!("generalize_region(r0=%?): \
+                        non-new-variables found in %?",
+                       r0, tainted);
+                return r0;
+            }
+
+            // Otherwise, the variable must be associated with at
+            // least one of the variables representing bound regions
+            // in both A and B.  Replace the variable with the "first"
+            // bound region from A that we find it to be associated
+            // with.
+            for list::each(a_isr) |pair| {
+                let (a_br, a_r) = *pair;
+                if tainted.contains(&a_r) {
+                    debug!("generalize_region(r0=%?): \
+                            replacing with %?, tainted=%?",
+                           r0, a_br, tainted);
+                    return ty::re_bound(a_br);
+                }
+            }
+
+            self.infcx.tcx.sess.span_bug(
+                self.span,
+                fmt!("Region %? is not associated with \
+                      any bound region from A!", r0));
+        }
+
+        fn is_new_var(new_vars: &[RegionVid], r: ty::Region) -> bool {
+            match r {
+                ty::re_infer(ty::ReVar(ref v)) => new_vars.contains(v),
+                _ => false
+            }
+        }
+    }
+
+    fn fn_metas(a: &ty::FnMeta, b: &ty::FnMeta) -> cres<ty::FnMeta> {
+        super_fn_metas(&self, a, b)
+    }
+
+    fn fn_sigs(a: &ty::FnSig, b: &ty::FnSig) -> cres<ty::FnSig> {
+        super_fn_sigs(&self, a, b)
+    }
+
     // Traits please (FIXME: #2794):
 
     fn tys(a: ty::t, b: ty::t) -> cres<ty::t> {
@@ -125,18 +221,6 @@ impl Lub: combine {
         super_args(&self, a, b)
     }
 
-    fn fns(a: &ty::FnTy, b: &ty::FnTy) -> cres<ty::FnTy> {
-        super_fns(&self, a, b)
-    }
-
-    fn fn_metas(a: &ty::FnMeta, b: &ty::FnMeta) -> cres<ty::FnMeta> {
-        super_fn_metas(&self, a, b)
-    }
-
-    fn fn_sigs(a: &ty::FnSig, b: &ty::FnSig) -> cres<ty::FnSig> {
-        super_fn_sigs(&self, a, b)
-    }
-
     fn substs(did: ast::def_id,
               as_: &ty::substs,
               bs: &ty::substs) -> cres<ty::substs> {