Rewrite the coercion code to be more readable, more sound, and to reborrow when

needed.

Regarding soundness: there was a subtle bug in how it was done before; see the
compile-fail test for an example.

Regarding reborrowing: reborrowing allows mut and const
slices/borrowed-pointers to be used with pure fns that expect immutable data.

r=brson

Author: nikomatsakis

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

@@ -15,7 +15,7 @@ use middle::pat_util::{pat_is_variant_or_struct};
 use middle::ty;
 use middle::typeck::check::demand;
 use middle::typeck::check::{check_block, check_expr_has_type, fn_ctxt};
-use middle::typeck::check::{instantiate_path, lookup_def, lookup_local};
+use middle::typeck::check::{instantiate_path, lookup_def};
 use middle::typeck::check::{structure_of, valid_range_bounds};
 use middle::typeck::require_same_types;
 
@@ -365,8 +365,7 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) {
         fcx.write_ty(pat.id, const_tpt.ty);
       }
       ast::pat_ident(bm, name, sub) if pat_is_binding(tcx.def_map, pat) => {
-        let vid = lookup_local(fcx, pat.span, pat.id);
-        let mut typ = ty::mk_var(tcx, vid);
+        let typ = fcx.local_ty(pat.span, pat.id);
 
         match bm {
           ast::bind_by_ref(mutbl) => {
@@ -389,8 +388,7 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) {
 
         let canon_id = pcx.map.get(ast_util::path_to_ident(name));
         if canon_id != pat.id {
-            let tv_id = lookup_local(fcx, pat.span, canon_id);
-            let ct = ty::mk_var(tcx, tv_id);
+            let ct = fcx.local_ty(pat.span, canon_id);
             demand::eqtype(fcx, pat.span, ct, typ);
         }
         fcx.write_ty(pat.id, typ);

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

@@ -50,7 +50,10 @@ fn eqtype(fcx: @fn_ctxt, sp: span, expected: ty::t, actual: ty::t) {
 }
 
 // Checks that the type `actual` can be coerced to `expected`.
-fn coerce(fcx: @fn_ctxt, sp: span, expected: ty::t, expr: @ast::expr) {
+fn coerce(fcx: @fn_ctxt,
+          sp: span,
+          expected: ty::t,
+          expr: @ast::expr) {
     let expr_ty = fcx.expr_ty(expr);
     match fcx.mk_assignty(expr, expr_ty, expected) {
       result::Ok(()) => { /* ok */ }

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

@@ -700,20 +700,91 @@ impl LookupContext {
         autoderefs: uint)
         -> Option<method_map_entry>
     {
+        let (self_ty, autoadjust) =
+            self.consider_reborrow(self_ty, autoderefs);
         match self.search_for_method(self_ty) {
             None => None,
             Some(move mme) => {
                 debug!("(searching for autoderef'd method) writing \
                        adjustment (%u) to %d",
                        autoderefs,
                        self.self_expr.id);
-                self.fcx.write_autoderef_adjustment(
-                    self.self_expr.id, autoderefs);
+                self.fcx.write_adjustment(self.self_expr.id, @autoadjust);
                 Some(mme)
             }
         }
     }
 
+    fn consider_reborrow(&self,
+                         self_ty: ty::t,
+                         autoderefs: uint) -> (ty::t, ty::AutoAdjustment)
+    {
+        /*!
+         *
+         * In the event that we are invoking a method with a receiver
+         * of a linear borrowed type like `&mut T` or `&[mut T]`,
+         * we will "reborrow" the receiver implicitly.  For example, if
+         * you have a call `r.inc()` and where `r` has type `&mut T`,
+         * then we treat that like `(&mut *r).inc()`.  This avoids
+         * consuming the original pointer.
+         *
+         * You might think that this would be a natural byproduct of
+         * the auto-deref/auto-ref process.  This is true for `@mut T`
+         * but not for an `&mut T` receiver.  With `@mut T`, we would
+         * begin by testing for methods with a self type `@mut T`,
+         * then autoderef to `T`, then autoref to `&mut T`.  But with
+         * an `&mut T` receiver the process begins with `&mut T`, only
+         * without any autoadjustments.
+         */
+
+        let tcx = self.tcx();
+        return match ty::get(self_ty).sty {
+            ty::ty_rptr(self_r, self_mt) if self_mt.mutbl == m_mutbl => {
+                let region = fresh_region(self, self_r);
+                (ty::mk_rptr(tcx, region, self_mt),
+                 ty::AutoAdjustment {
+                     autoderefs: autoderefs+1,
+                     autoref: Some(ty::AutoRef {kind: AutoPtr,
+                                                region: region,
+                                                mutbl: self_mt.mutbl})})
+            }
+            ty::ty_evec(self_mt, vstore_slice(self_r))
+            if self_mt.mutbl == m_mutbl => {
+                let region = fresh_region(self, self_r);
+                (ty::mk_evec(tcx, self_mt, vstore_slice(region)),
+                 ty::AutoAdjustment {
+                    autoderefs: autoderefs,
+                    autoref: Some(ty::AutoRef {kind: AutoBorrowVec,
+                                               region: region,
+                                               mutbl: self_mt.mutbl})})
+            }
+            _ => {
+                (self_ty, ty::AutoAdjustment {autoderefs: autoderefs,
+                                              autoref: None})
+            }
+        };
+
+        fn fresh_region(self: &LookupContext,
+                        self_r: ty::Region) -> ty::Region {
+            let region = self.infcx().next_region_var(self.expr.span,
+                                                      self.expr.id);
+
+            // FIXME(#3148)---in principle this dependency should
+            // be done more generally as part of regionck
+            match infer::mk_subr(self.infcx(), true, self.expr.span,
+                                 region, self_r) {
+                Ok(_) => {}
+                Err(e) => {
+                    self.tcx().sess.span_bug(
+                        self.expr.span,
+                        fmt!("Failed with error: %?", e));
+                }
+            }
+
+            return region;
+        }
+    }
+
     fn search_for_autosliced_method(
         &self,
         self_ty: ty::t,
@@ -729,6 +800,7 @@ impl LookupContext {
         match ty::get(self_ty).sty {
             ty_evec(mt, vstore_box) |
             ty_evec(mt, vstore_uniq) |
+            ty_evec(mt, vstore_slice(_)) | // NDM(#3148)
             ty_evec(mt, vstore_fixed(_)) => {
                 // First try to borrow to a slice
                 let entry = self.search_for_some_kind_of_autorefd_method(

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

@@ -139,7 +139,6 @@ export regionck;
 export demand;
 export method;
 export fn_ctxt;
-export lookup_local;
 export impl_self_ty;
 export DerefArgs;
 export DontDerefArgs;
@@ -189,7 +188,7 @@ type self_info = {
 /// share the inherited fields.
 struct inherited {
     infcx: @infer::InferCtxt,
-    locals: HashMap<ast::node_id, TyVid>,
+    locals: HashMap<ast::node_id, ty::t>,
     node_types: HashMap<ast::node_id, ty::t>,
     node_type_substs: HashMap<ast::node_id, ty::substs>,
     adjustments: HashMap<ast::node_id, @ty::AutoAdjustment>
@@ -376,8 +375,7 @@ fn check_fn(ccx: @crate_ctxt,
         }
     };
 
-    // XXX: Bad copy.
-    gather_locals(fcx, decl, body, copy arg_tys, self_info);
+    gather_locals(fcx, decl, body, arg_tys, self_info);
     check_block(fcx, body);
 
     // We unify the tail expr's type with the
@@ -414,38 +412,39 @@ fn check_fn(ccx: @crate_ctxt,
     fn gather_locals(fcx: @fn_ctxt,
                      decl: &ast::fn_decl,
                      body: ast::blk,
-                     arg_tys: ~[ty::t],
+                     arg_tys: &[ty::t],
                      self_info: Option<self_info>) {
         let tcx = fcx.ccx.tcx;
 
-        let assign = fn@(span: span, nid: ast::node_id,
-                         ty_opt: Option<ty::t>) {
-            let var_id = fcx.infcx().next_ty_var_id();
-            fcx.inh.locals.insert(nid, var_id);
+        let assign = fn@(nid: ast::node_id, ty_opt: Option<ty::t>) {
             match ty_opt {
-                None => {/* nothing to do */ }
+                None => {
+                    // infer the variable's type
+                    let var_id = fcx.infcx().next_ty_var_id();
+                    let var_ty = ty::mk_var(fcx.tcx(), var_id);
+                    fcx.inh.locals.insert(nid, var_ty);
+                }
                 Some(typ) => {
-                    infer::mk_eqty(fcx.infcx(), false, span,
-                                   ty::mk_var(tcx, var_id), typ);
+                    // take type that the user specified
+                    fcx.inh.locals.insert(nid, typ);
                 }
             }
         };
 
         // Add the self parameter
         for self_info.each |self_info| {
-            assign(self_info.explicit_self.span,
-                   self_info.self_id,
-                   Some(self_info.self_ty));
+            assign(self_info.self_id, Some(self_info.self_ty));
             debug!("self is assigned to %s",
-                   fcx.inh.locals.get(self_info.self_id).to_str());
+                   fcx.infcx().ty_to_str(
+                       fcx.inh.locals.get(self_info.self_id)));
         }
 
         // Add formal parameters.
         for vec::each2(arg_tys, decl.inputs) |arg_ty, input| {
             // Create type variables for each argument.
             do pat_util::pat_bindings(tcx.def_map, input.pat)
                     |_bm, pat_id, _sp, _path| {
-                assign(input.ty.span, pat_id, None);
+                assign(pat_id, None);
             }
 
             // Check the pattern.
@@ -466,10 +465,11 @@ fn check_fn(ccx: @crate_ctxt,
               ast::ty_infer => None,
               _ => Some(fcx.to_ty(local.node.ty))
             };
-            assign(local.span, local.node.id, o_ty);
-            debug!("Local variable %s is assigned to %s",
+            assign(local.node.id, o_ty);
+            debug!("Local variable %s is assigned type %s",
                    fcx.pat_to_str(local.node.pat),
-                   fcx.inh.locals.get(local.node.id).to_str());
+                   fcx.infcx().ty_to_str(
+                       fcx.inh.locals.get(local.node.id)));
             visit::visit_local(local, e, v);
         };
 
@@ -478,10 +478,11 @@ fn check_fn(ccx: @crate_ctxt,
             match p.node {
               ast::pat_ident(_, path, _)
                   if pat_util::pat_is_binding(fcx.ccx.tcx.def_map, p) => {
-                assign(p.span, p.id, None);
+                assign(p.id, None);
                 debug!("Pattern binding %s is assigned to %s",
                        tcx.sess.str_of(path.idents[0]),
-                       fcx.inh.locals.get(p.id).to_str());
+                       fcx.infcx().ty_to_str(
+                           fcx.inh.locals.get(p.id)));
               }
               _ => {}
             }
@@ -694,6 +695,17 @@ impl @fn_ctxt: region_scope {
 impl @fn_ctxt {
     fn tag() -> ~str { fmt!("%x", ptr::addr_of(&(*self)) as uint) }
 
+    fn local_ty(span: span, nid: ast::node_id) -> ty::t {
+        match self.inh.locals.find(nid) {
+            Some(t) => t,
+            None => {
+                self.tcx().sess.span_bug(
+                    span,
+                    fmt!("No type for local variable %?", nid));
+            }
+        }
+    }
+
     fn expr_to_str(expr: @ast::expr) -> ~str {
         fmt!("expr(%?:%s)", expr.id,
              pprust::expr_to_str(expr, self.tcx().sess.intr()))
@@ -1359,10 +1371,8 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
     fn check_for(fcx: @fn_ctxt, local: @ast::local,
                  element_ty: ty::t, body: ast::blk,
                  node_id: ast::node_id) -> bool {
-        let locid = lookup_local(fcx, local.span, local.node.id);
-        demand::suptype(fcx, local.span,
-                       ty::mk_var(fcx.ccx.tcx, locid),
-                       element_ty);
+        let local_ty = fcx.local_ty(local.span, local.node.id);
+        demand::suptype(fcx, local.span, local_ty, element_ty);
         let bot = check_decl_local(fcx, local);
         check_block_no_value(fcx, body);
         fcx.write_nil(node_id);
@@ -2551,15 +2561,15 @@ fn require_integral(fcx: @fn_ctxt, sp: span, t: ty::t) {
 
 fn check_decl_initializer(fcx: @fn_ctxt, nid: ast::node_id,
                           init: @ast::expr) -> bool {
-    let lty = ty::mk_var(fcx.ccx.tcx, lookup_local(fcx, init.span, nid));
-    return check_expr_coercable_to_type(fcx, init, lty);
+    let local_ty = fcx.local_ty(init.span, nid);
+    return check_expr_coercable_to_type(fcx, init, local_ty);
 }
 
 fn check_decl_local(fcx: @fn_ctxt, local: @ast::local) -> bool {
     let mut bot = false;
     let tcx = fcx.ccx.tcx;
 
-    let t = ty::mk_var(tcx, fcx.inh.locals.get(local.node.id));
+    let t = fcx.local_ty(local.span, local.node.id);
     fcx.write_ty(local.node.id, t);
 
     match local.node.init {
@@ -2819,17 +2829,6 @@ fn check_enum_variants(ccx: @crate_ctxt,
     check_instantiable(ccx.tcx, sp, id);
 }
 
-pub fn lookup_local(fcx: @fn_ctxt, sp: span, id: ast::node_id) -> TyVid {
-    match fcx.inh.locals.find(id) {
-        Some(x) => x,
-        _ => {
-            fcx.ccx.tcx.sess.span_fatal(
-                sp,
-                ~"internal error looking up a local var")
-        }
-    }
-}
-
 fn lookup_def(fcx: @fn_ctxt, sp: span, id: ast::node_id) -> ast::def {
     lookup_def_ccx(fcx.ccx, sp, id)
 }
@@ -2841,9 +2840,8 @@ fn ty_param_bounds_and_ty_for_def(fcx: @fn_ctxt, sp: span, defn: ast::def) ->
     match defn {
       ast::def_arg(nid, _, _) | ast::def_local(nid, _) |
       ast::def_self(nid, _) | ast::def_binding(nid, _) => {
-        assert (fcx.inh.locals.contains_key(nid));
-        let typ = ty::mk_var(fcx.ccx.tcx, lookup_local(fcx, sp, nid));
-        return no_params(typ);
+          let typ = fcx.local_ty(sp, nid);
+          return no_params(typ);
       }
       ast::def_fn(_, ast::extern_fn) => {
         // extern functions are just u8 pointers

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

@@ -16,7 +16,7 @@ use core::prelude::*;
 
 use middle::pat_util;
 use middle::ty;
-use middle::typeck::check::{fn_ctxt, lookup_local, self_info};
+use middle::typeck::check::{fn_ctxt, self_info};
 use middle::typeck::infer::{force_all, resolve_all, resolve_region};
 use middle::typeck::infer::{resolve_type};
 use middle::typeck::infer;
@@ -216,8 +216,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 { return; }
-    let var_id = lookup_local(wbcx.fcx, l.span, l.node.id);
-    let var_ty = ty::mk_var(wbcx.fcx.tcx(), var_id);
+    let var_ty = wbcx.fcx.local_ty(l.span, l.node.id);
     match resolve_type(wbcx.fcx.infcx(), var_ty, resolve_all | force_all) {
         Ok(lty) => {
             debug!("Type for local %s (id %d) resolved to %s",