Fix "cannot encode region variables" error

src/librustc/middle/trans/base.rs

@@ -1579,7 +1579,17 @@ pub fn new_fn_ctxt_w_id(ccx: @CrateContext,
                         id: ast::node_id,
                         impl_id: Option<ast::def_id>,
                         param_substs: Option<@param_substs>,
-                        sp: Option<span>) -> fn_ctxt {
+                        sp: Option<span>) -> fn_ctxt
+{
+    for param_substs.each |p| { p.validate(); }
+
+    debug!("new_fn_ctxt_w_id(path=%s, id=%?, impl_id=%?, \
+            param_substs=%s",
+           path_str(ccx.sess, path),
+           id,
+           impl_id,
+           opt_param_substs_to_str(ccx.tcx, &param_substs));
+
     let llbbs = mk_standard_basic_blocks(llfndecl);
     return @mut fn_ctxt_ {
           llfn: llfndecl,

src/librustc/middle/trans/callee.rs

@@ -217,7 +217,7 @@ pub fn trans_fn_ref_with_vtables(
     // - `type_params`: values for each of the fn/method's type parameters
     // - `vtables`: values for each bound on each of the type parameters
 
-    let _icx = bcx.insn_ctxt("trans_fn_with_vtables");
+    let _icx = bcx.insn_ctxt("trans_fn_ref_with_vtables");
     let ccx = bcx.ccx();
     let tcx = ccx.tcx;
 
@@ -228,6 +228,8 @@ pub fn trans_fn_ref_with_vtables(
            vtables);
     let _indenter = indenter();
 
+    fail_unless!(type_params.all(|t| !ty::type_needs_infer(*t)));
+
     // Polytype of the function item (may have type params)
     let fn_tpt = ty::lookup_item_type(tcx, def_id);
 

src/librustc/middle/trans/common.rs

@@ -250,13 +250,25 @@ pub struct param_substs {
     self_ty: Option<ty::t>
 }
 
+pub impl param_substs {
+    fn validate(&self) {
+        for self.tys.each |t| { fail_unless!(!ty::type_needs_infer(*t)); }
+        for self.self_ty.each |t| { fail_unless!(!ty::type_needs_infer(*t)); }
+    }
+}
+
 pub fn param_substs_to_str(tcx: ty::ctxt, substs: &param_substs) -> ~str {
     fmt!("param_substs {tys:%?, vtables:%?, bounds:%?}",
          substs.tys.map(|t| ty_to_str(tcx, *t)),
          substs.vtables.map(|vs| vs.map(|v| v.to_str(tcx))),
          substs.bounds.map(|b| ty::param_bounds_to_str(tcx, *b)))
 }
 
+pub fn opt_param_substs_to_str(tcx: ty::ctxt,
+                               substs: &Option<@param_substs>) -> ~str {
+    substs.map_default(~"None", |&ps| param_substs_to_str(tcx, ps))
+}
+
 // Function context.  Every LLVM function we create will have one of
 // these.
 pub struct fn_ctxt_ {
@@ -1367,6 +1379,13 @@ pub fn expr_ty_adjusted(bcx: block, ex: @ast::expr) -> ty::t {
 pub fn node_id_type_params(bcx: block, id: ast::node_id) -> ~[ty::t] {
     let tcx = bcx.tcx();
     let params = ty::node_id_to_type_params(tcx, id);
+
+    if !params.all(|t| !ty::type_needs_infer(*t)) {
+        bcx.sess().bug(
+            fmt!("Type parameters for node %d include inference types: %s",
+                 id, str::connect(params.map(|t| bcx.ty_to_str(*t)), ",")));
+    }
+
     match bcx.fcx.param_substs {
       Some(substs) => {
         do vec::map(params) |t| {
@@ -1423,7 +1442,7 @@ pub fn resolve_vtable_in_fn_ctxt(fcx: fn_ctxt, +vt: typeck::vtable_origin)
 }
 
 pub fn find_vtable(tcx: ty::ctxt, ps: &param_substs,
-               n_param: uint, n_bound: uint)
+                   n_param: uint, n_bound: uint)
     -> typeck::vtable_origin {
     debug!("find_vtable_in_fn_ctxt(n_param=%u, n_bound=%u, ps=%?)",
            n_param, n_bound, param_substs_to_str(tcx, ps));

src/librustc/middle/trans/meth.rs

@@ -175,6 +175,9 @@ pub fn trans_method_callee(bcx: block,
                         -> Callee {
     let _icx = bcx.insn_ctxt("impl::trans_method_callee");
 
+    debug!("trans_method_callee(callee_id=%?, self=%s, mentry=%?)",
+           callee_id, bcx.expr_to_str(self), mentry);
+
     // Replace method_self with method_static here.
     let mut origin = mentry.origin;
     match origin {
@@ -218,6 +221,8 @@ pub fn trans_method_callee(bcx: block,
         typeck::method_trait(*) => {}
     }
 
+    debug!("origin=%?", origin);
+
     match origin {
         typeck::method_static(did) => {
             let callee_fn = callee::trans_fn_ref(bcx, did, callee_id);
@@ -322,6 +327,7 @@ pub fn trans_static_method_callee(bcx: block,
 
     match vtbls[bound_index] {
         typeck::vtable_static(impl_did, ref rcvr_substs, rcvr_origins) => {
+            fail_unless!(rcvr_substs.all(|t| !ty::type_needs_infer(*t)));
 
             let mth_id = method_with_name(bcx.ccx(), impl_did, mname);
             let callee_substs = combine_impl_and_methods_tps(

src/librustc/middle/trans/monomorphize.rs

@@ -47,6 +47,7 @@ pub fn monomorphic_fn(ccx: @CrateContext,
                       impl_did_opt: Option<ast::def_id>,
                       ref_id: Option<ast::node_id>) ->
                       (ValueRef, bool) {
+    fail_unless!(real_substs.all(|t| !ty::type_needs_infer(*t)));
     let _icx = ccx.insn_ctxt("monomorphic_fn");
     let mut must_cast = false;
     let substs = vec::map(real_substs, |t| {
@@ -67,9 +68,11 @@ pub fn monomorphic_fn(ccx: @CrateContext,
         must_cast = true;
     }
 
-    debug!("monomorphic_fn(fn_id=%? (%s), real_substs=%?, substs=%?, \
-           hash_id = %?",
+    debug!("monomorphic_fn(fn_id=%? (%s), vtables=%?, \
+            real_substs=%?, substs=%?, \
+            hash_id = %?",
            fn_id, ty::item_path_str(ccx.tcx, fn_id),
+           vtables,
            real_substs.map(|s| ty_to_str(ccx.tcx, *s)),
            substs.map(|s| ty_to_str(ccx.tcx, *s)), hash_id);
 

src/librustc/middle/typeck/astconv.rs

@@ -60,7 +60,7 @@ use middle::ty::{ty_param_substs_and_ty};
 use middle::ty;
 use middle::typeck::rscope::{in_binding_rscope};
 use middle::typeck::rscope::{region_scope, type_rscope, RegionError};
-use middle::typeck::{CrateCtxt, write_substs_to_tcx, write_ty_to_tcx};
+use middle::typeck::{CrateCtxt};
 
 use core::result;
 use core::vec;
@@ -186,19 +186,15 @@ pub fn ast_path_to_ty<AC:AstConv,RS:region_scope + Copy + Durable>(
         self: &AC,
         rscope: &RS,
         did: ast::def_id,
-        path: @ast::path,
-        path_id: ast::node_id)
-     -> ty_param_substs_and_ty {
+        path: @ast::path)
+     -> ty_param_substs_and_ty
+{
     // Look up the polytype of the item and then substitute the provided types
     // for any type/region parameters.
-    let tcx = self.tcx();
     let ty::ty_param_substs_and_ty {
         substs: substs,
         ty: ty
     } = ast_path_to_substs_and_ty(self, rscope, did, path);
-    write_ty_to_tcx(tcx, path_id, ty);
-    write_substs_to_tcx(tcx, path_id, /*bad*/copy substs.tps);
-
     ty_param_substs_and_ty { substs: substs, ty: ty }
 }
 
@@ -368,7 +364,7 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:region_scope + Copy + Durable>(
         };
         match a_def {
           ast::def_ty(did) | ast::def_struct(did) => {
-            ast_path_to_ty(self, rscope, did, path, id).ty
+            ast_path_to_ty(self, rscope, did, path).ty
           }
           ast::def_prim_ty(nty) => {
             match nty {

src/librustc/middle/typeck/check/mod.rs

@@ -104,6 +104,7 @@ use middle::typeck::rscope::{RegionError};
 use middle::typeck::rscope::{in_binding_rscope, region_scope, type_rscope};
 use middle::typeck::rscope;
 use middle::typeck::{isr_alist, lookup_def_ccx, method_map_entry};
+use middle::typeck::{method_map, vtable_map};
 use middle::typeck::{method_origin, method_self, method_trait, no_params};
 use middle::typeck::{require_same_types};
 use util::common::{block_query, indenter, loop_query};
@@ -160,9 +161,13 @@ pub struct SelfInfo {
 pub struct inherited {
     infcx: @mut infer::InferCtxt,
     locals: HashMap<ast::node_id, ty::t>,
+
+    // Temporary tables:
     node_types: HashMap<ast::node_id, ty::t>,
     node_type_substs: HashMap<ast::node_id, ty::substs>,
-    adjustments: HashMap<ast::node_id, @ty::AutoAdjustment>
+    adjustments: HashMap<ast::node_id, @ty::AutoAdjustment>,
+    method_map: method_map,
+    vtable_map: vtable_map,
 }
 
 pub enum FnKind {
@@ -220,7 +225,9 @@ pub fn blank_inherited(ccx: @mut CrateCtxt) -> @inherited {
         locals: HashMap(),
         node_types: oldmap::HashMap(),
         node_type_substs: oldmap::HashMap(),
-        adjustments: oldmap::HashMap()
+        adjustments: oldmap::HashMap(),
+        method_map: oldmap::HashMap(),
+        vtable_map: oldmap::HashMap(),
     }
 }
 
@@ -1321,13 +1328,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                   sugar: ast::CallSugar) {
         // Index expressions need to be handled separately, to inform them
         // that they appear in call position.
-        match f.node {
-            ast::expr_field(ref base, ref field, ref tys) => {
-                check_field(fcx, f, true, *base, *field, *tys)
-            }
-            _ => check_expr(fcx, f)
-        };
-
+        let mut bot = check_expr(fcx, f);
         check_call_or_method(fcx,
                              sp,
                              call_expr_id,
@@ -1363,7 +1364,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                              CheckTraitsAndInherentMethods,
                              AutoderefReceiver) {
             Some(ref entry) => {
-                let method_map = fcx.ccx.method_map;
+                let method_map = fcx.inh.method_map;
                 method_map.insert(expr.id, (*entry));
             }
             None => {
@@ -1435,7 +1436,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                              deref_args, CheckTraitsOnly, autoderef_receiver) {
             Some(ref origin) => {
                 let method_ty = fcx.node_ty(op_ex.callee_id);
-                let method_map = fcx.ccx.method_map;
+                let method_map = fcx.inh.method_map;
                 method_map.insert(op_ex.id, *origin);
                 check_call_inner(fcx, op_ex.span,
                                  op_ex.id, method_ty,
@@ -1689,7 +1690,6 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
     // Check field access expressions
     fn check_field(fcx: @mut FnCtxt,
                    expr: @ast::expr,
-                   is_callee: bool,
                    base: @ast::expr,
                    field: ast::ident,
                    tys: &[@ast::Ty]) {
@@ -1723,7 +1723,6 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
         }
 
         let tps = vec::map(tys, |ty| fcx.to_ty(*ty));
-
         match method::lookup(fcx,
                              expr,
                              base,
@@ -1734,34 +1733,30 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                              DontDerefArgs,
                              CheckTraitsAndInherentMethods,
                              AutoderefReceiver) {
-            Some(ref entry) => {
-                let method_map = fcx.ccx.method_map;
-                method_map.insert(expr.id, (*entry));
-
-                // If we have resolved to a method but this is not in
-                // a callee position, error
-                if !is_callee {
-                    tcx.sess.span_err(
-                        expr.span,
-                        ~"attempted to take value of method \
-                          (try writing an anonymous function)");
-                    // Add error type for the result
-                    fcx.write_error(expr.id);
-                }
+            Some(_) => {
+                fcx.type_error_message(
+                    expr.span,
+                    |actual| {
+                        fmt!("attempted to take value of method `%s` on type `%s` \
+                              (try writing an anonymous function)",
+                             *tcx.sess.str_of(field), actual)
+                    },
+                    expr_t, None);
             }
+
             None => {
-                fcx.type_error_message(expr.span,
-                  |actual| {
-                      fmt!("attempted access of field `%s` on type `%s`, but \
-                            no field or method with that name was found",
-                           *tcx.sess.str_of(field), actual)
-                  },
-                  expr_t, None);
-                // Add error type for the result
-                fcx.write_error(expr.id);
+                fcx.type_error_message(
+                    expr.span,
+                    |actual| {
+                        fmt!("attempted access of field `%s` on type `%s`, \
+                              but no field with that name was found",
+                             *tcx.sess.str_of(field), actual)
+                    },
+                    expr_t, None);
             }
         }
 
+        fcx.write_error(expr.id);
     }
 
     fn check_struct_or_variant_fields(fcx: @mut FnCtxt,
@@ -2750,15 +2745,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
         }
       }
       ast::expr_field(base, field, ref tys) => {
-          check_field(fcx, expr, false, base, field, * tys);
-          let base_t = fcx.expr_ty(base);
-          if ty::type_is_error(base_t) {
-              fcx.write_error(id);
-          }
-          else if ty::type_is_bot(base_t) {
-              fcx.write_bot(id);
-          }
-          // Otherwise, type already got written
+        check_field(fcx, expr, base, field, *tys);
       }
       ast::expr_index(base, idx) => {
           check_expr(fcx, base);

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

@@ -215,7 +215,7 @@ pub fn visit_expr(expr: @ast::expr, &&rcx: @mut Rcx, v: rvt) {
             // `constrain_auto_ref()` on all exprs.  But that causes a
             // lot of spurious errors because of how the region
             // hierarchy is setup.
-            if rcx.fcx.ccx.method_map.contains_key(&callee.id) {
+            if rcx.fcx.inh.method_map.contains_key(&callee.id) {
                 match callee.node {
                     ast::expr_field(base, _, _) => {
                         constrain_auto_ref(rcx, base);
@@ -713,7 +713,7 @@ pub mod guarantor {
             ast::expr_repeat(*) |
             ast::expr_vec(*) => {
                 fail_unless!(!ty::expr_is_lval(
-                    rcx.fcx.tcx(), rcx.fcx.ccx.method_map, expr));
+                    rcx.fcx.tcx(), rcx.fcx.inh.method_map, expr));
                 None
             }
         }
@@ -765,7 +765,7 @@ pub mod guarantor {
         let _i = ::util::common::indenter();
 
         let guarantor = {
-            if rcx.fcx.ccx.method_map.contains_key(&expr.id) {
+            if rcx.fcx.inh.method_map.contains_key(&expr.id) {
                 None
             } else {
                 guarantor(rcx, expr)