Add an intermediate level of type/region variable resolution forcing

And change structurally_resolved_type() to force resolution of
non-region variables.

Author: lkuper

src/rustc/middle/typeck/check.rs

@@ -76,6 +76,8 @@ import rscope::{in_binding_rscope, region_scope, type_rscope};
 import syntax::ast::{ty_char, ty_i};
 import typeck::infer::{root, to_str};
 import typeck::infer::{unify_methods}; // infcx.set()
+import typeck::infer::{force_level, force_none, force_non_region_vars_only,
+                       force_all};
 
 type fn_ctxt =
     // var_bindings, locals and next_var_id are shared
@@ -1040,7 +1042,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
         -> option<O> {
         alt expected {
           some(t) {
-            alt infer::resolve_shallow(fcx.infcx, t, false) {
+            alt infer::resolve_shallow(fcx.infcx, t, force_none) {
               result::ok(t) { unpack(ty::get(t).struct) }
               _ { none }
             }
@@ -2184,7 +2186,8 @@ fn instantiate_path(fcx: @fn_ctxt,
 // Resolves `typ` by a single level if `typ` is a type variable.  If no
 // resolution is possible, then an error is reported.
 fn structurally_resolved_type(fcx: @fn_ctxt, sp: span, tp: ty::t) -> ty::t {
-    alt infer::resolve_shallow(fcx.infcx, tp, false) {
+    alt infer::resolve_shallow(fcx.infcx, tp,
+                               force_non_region_vars_only) {
       result::ok(t_s) if !ty::type_is_var(t_s) { ret t_s; }
       _ {
         fcx.ccx.tcx.sess.span_fatal
@@ -2357,5 +2360,3 @@ fn check_intrinsic_type(ccx: @crate_ctxt, it: @ast::native_item) {
                      ty_to_str(ccx.tcx, fty)]});
     }
 }
-
-

src/rustc/middle/typeck/check/regionck.rs

@@ -115,7 +115,7 @@ fn visit_node(id: ast::node_id, span: span, rcx: rcx) -> bool {
     // is going to fail anyway, so just stop here and let typeck
     // report errors later on in the writeback phase.
     let ty0 = fcx.node_ty(id);
-    let ty = alt infer::resolve_deep(fcx.infcx, ty0, false) {
+    let ty = alt infer::resolve_deep(fcx.infcx, ty0, force_none) {
       result::err(_) { ret true; }
       result::ok(ty) { ty }
     };

src/rustc/middle/typeck/check/vtable.rs

@@ -168,7 +168,7 @@ fn lookup_vtable(fcx: @fn_ctxt, isc: resolve::iscopes, sp: span,
 
 fn fixup_ty(fcx: @fn_ctxt, sp: span, ty: ty::t) -> ty::t {
     let tcx = fcx.ccx.tcx;
-    alt infer::resolve_deep(fcx.infcx, ty, true) {
+    alt infer::resolve_deep(fcx.infcx, ty, force_all) {
       result::ok(new_type) { new_type }
       result::err(e) {
         tcx.sess.span_fatal(

src/rustc/middle/typeck/check/writeback.rs

@@ -10,7 +10,7 @@ export resolve_type_vars_in_expr;
 fn resolve_type_vars_in_type(fcx: @fn_ctxt, sp: span, typ: ty::t) ->
     option<ty::t> {
     if !ty::type_needs_infer(typ) { ret some(typ); }
-    alt infer::resolve_deep(fcx.infcx, typ, true) {
+    alt infer::resolve_deep(fcx.infcx, typ, force_all) {
       result::ok(new_type) { ret some(new_type); }
       result::err(e) {
         if !fcx.ccx.tcx.sess.has_errors() {
@@ -131,7 +131,7 @@ fn visit_pat(p: @ast::pat, wbcx: wb_ctxt, v: wb_vt) {
 fn visit_local(l: @ast::local, wbcx: wb_ctxt, v: wb_vt) {
     if !wbcx.success { ret; }
     let var_id = lookup_local(wbcx.fcx, l.span, l.node.id);
-    alt infer::resolve_deep_var(wbcx.fcx.infcx, var_id, true) {
+    alt infer::resolve_deep_var(wbcx.fcx.infcx, var_id, force_all) {
       result::ok(lty) {
         #debug["Type for local %s (id %d) resolved to %s",
                pat_to_str(l.node.pat), l.node.id,

src/rustc/middle/typeck/infer.rs

@@ -176,6 +176,7 @@ export fixup_err, fixup_err_to_str;
 export assignment;
 export root, to_str;
 export int_ty_set_all;
+export force_level, force_none, force_non_region_vars_only, force_all;
 
 // Bitvector to represent sets of integral types
 enum int_ty_set = uint;
@@ -380,18 +381,19 @@ fn compare_tys(tcx: ty::ctxt, a: ty::t, b: ty::t) -> ures {
 
 // See comment on the type `resolve_state` below
 fn resolve_shallow(cx: infer_ctxt, a: ty::t,
-                   force_vars: bool) -> fres<ty::t> {
+                   force_vars: force_level) -> fres<ty::t> {
     resolver(cx, false, force_vars).resolve(a)
 }
 
 // See comment on the type `resolve_state` below
 fn resolve_deep_var(cx: infer_ctxt, vid: tv_vid,
-                    force_vars: bool) -> fres<ty::t> {
+                    force_vars: force_level) -> fres<ty::t> {
     resolver(cx, true, force_vars).resolve(ty::mk_var(cx.tcx, vid))
 }
 
 // See comment on the type `resolve_state` below
-fn resolve_deep(cx: infer_ctxt, a: ty::t, force_vars: bool) -> fres<ty::t> {
+fn resolve_deep(cx: infer_ctxt, a: ty::t, force_vars: force_level)
+    -> fres<ty::t> {
     resolver(cx, true, force_vars).resolve(a)
 }
 
@@ -618,7 +620,7 @@ impl methods for infer_ctxt {
     }
 
     fn resolve_type_vars_if_possible(typ: ty::t) -> ty::t {
-        alt infer::resolve_deep(self, typ, false) {
+        alt infer::resolve_deep(self, typ, force_none) {
           result::ok(new_type) { ret new_type; }
           result::err(_) { ret typ; }
         }
@@ -995,20 +997,34 @@ impl unify_methods for infer_ctxt {
 // A <: [B] and B <: int, then shallow resolution on A would yield
 // [B].  Deep resolution, on the other hand, would yield [int].
 //
-// But there is one more knob: the force_vars variable controls the
-// behavior in the face of unconstrained variables.  If it is true,
-// then unconstrained variables result in an error.
+// But there is one more knob: the `force_level` variable controls
+// the behavior in the face of unconstrained type and region
+// variables.
+
+enum force_level {
+    // Any unconstrained variables are OK.
+    force_none,
+
+    // Unconstrained region vars are OK; unconstrained ty vars and
+    // integral ty vars result in an error.
+    force_non_region_vars_only,
+
+    // Any unconstrained variables result in an error.
+    force_all,
+}
+
 
 type resolve_state = @{
     infcx: infer_ctxt,
     deep: bool,
-    force_vars: bool,
+    force_vars: force_level,
     mut err: option<fixup_err>,
     mut r_seen: [region_vid],
     mut v_seen: [tv_vid]
 };
 
-fn resolver(infcx: infer_ctxt, deep: bool, fvars: bool) -> resolve_state {
+fn resolver(infcx: infer_ctxt, deep: bool, fvars: force_level)
+    -> resolve_state {
     @{infcx: infcx,
       deep: deep,
       force_vars: fvars,
@@ -1021,7 +1037,7 @@ impl methods for resolve_state {
     fn resolve(typ: ty::t) -> fres<ty::t> {
         self.err = none;
 
-        #debug["Resolving %s (deep=%b, force_vars=%b)",
+        #debug["Resolving %s (deep=%b, force_vars=%?)",
                ty_to_str(self.infcx.tcx, typ),
                self.deep,
                self.force_vars];
@@ -1034,7 +1050,7 @@ impl methods for resolve_state {
         assert vec::is_empty(self.v_seen) && vec::is_empty(self.r_seen);
         alt self.err {
           none {
-            #debug["Resolved to %s (deep=%b, force_vars=%b)",
+            #debug["Resolved to %s (deep=%b, force_vars=%?)",
                    ty_to_str(self.infcx.tcx, rty),
                    self.deep,
                    self.force_vars];
@@ -1095,8 +1111,11 @@ impl methods for resolve_state {
               { ub:_, lb:some(t) } { self.resolve_region(t) }
               { ub:some(t), lb:_ } { self.resolve_region(t) }
               { ub:none, lb:none } {
-                if self.force_vars {
+                alt self.force_vars {
+                  force_all {
                     self.err = some(unresolved_region(rid));
+                  }
+                  _ { /* ok */ }
                 }
                 ty::re_var(rid)
               }
@@ -1127,8 +1146,11 @@ impl methods for resolve_state {
               { ub:some(t), lb:_ } { self.resolve1(t) }
               { ub:_, lb:some(t) } { self.resolve1(t) }
               { ub:none, lb:none } {
-                if self.force_vars {
+                alt self.force_vars {
+                  force_non_region_vars_only | force_all {
                     self.err = some(unresolved_ty(vid));
+                  }
+                  force_none { /* ok */ }
                 }
                 ty::mk_var(tcx, vid)
               }
@@ -1146,21 +1168,23 @@ impl methods for resolve_state {
         alt single_type_contained_in(self.infcx.tcx, pt) {
           some(t) { t }
           none {
-            if self.force_vars {
+            alt self.force_vars {
+              force_non_region_vars_only | force_all {
                 // As a last resort, default to int.
                 let ty = ty::mk_int(self.infcx.tcx);
                 self.infcx.set(
                     self.infcx.tvib, vid,
                     root(convert_integral_ty_to_int_ty_set(self.infcx.tcx,
                                                            ty)));
                 ty
-            } else {
+              }
+              force_none {
                 ty::mk_var_integral(self.infcx.tcx, vid)
+              }
             }
           }
         }
     }
-
 }
 
 // ______________________________________________________________________