typeck: Modify method resolution to use new object adjustments, and

to favor inherent methods over extension methods.

The reason to favor inherent methods is that otherwise an impl
like

    impl Foo for @foo { fn method(&self) { self.method() } }

causes infinite recursion.  The current change to favor inherent methods is
rather hacky; the method resolution code is in need of a refactoring.

Author: nikomatsakis

src/librustc/middle/astencode.rs

@@ -586,8 +586,8 @@ impl tr for method_origin {
                 }
             )
           }
-          typeck::method_trait(did, m, vstore) => {
-              typeck::method_trait(did.tr(xcx), m, vstore)
+          typeck::method_trait(did, m) => {
+              typeck::method_trait(did.tr(xcx), m)
           }
         }
     }

src/librustc/middle/privacy.rs

@@ -290,7 +290,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
                  method_num: method_num,
                  _
             }) |
-            method_trait(trait_id, method_num, _) => {
+            method_trait(trait_id, method_num) => {
                 if trait_id.crate == LOCAL_CRATE {
                     match tcx.items.find(&trait_id.node) {
                         Some(&node_item(item, _)) => {

src/librustc/middle/ty.rs

@@ -3131,7 +3131,7 @@ pub fn method_call_type_param_defs(tcx: ctxt,
           typeck::method_param(typeck::method_param {
               trait_id: trt_id,
               method_num: n_mth, _}) |
-          typeck::method_trait(trt_id, n_mth, _) => {
+          typeck::method_trait(trt_id, n_mth) => {
             // ...trait methods bounds, in contrast, include only the
             // method bounds, so we must preprend the tps from the
             // trait itself.  This ought to be harmonized.

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

@@ -863,7 +863,8 @@ pub mod guarantor {
 
             ty::AutoBorrowVec(r, _) |
             ty::AutoBorrowVecRef(r, _) |
-            ty::AutoBorrowFn(r) => {
+            ty::AutoBorrowFn(r) |
+            ty::AutoBorrowObj(r, _) => {
                 // In each of these cases, what is being borrowed is
                 // not the (autoderef'd) expr itself but rather the
                 // contents of the autoderef'd expression (i.e., what
@@ -1072,7 +1073,8 @@ pub mod guarantor {
                     Some(ty::AutoPtr(r, _)) |
                     Some(ty::AutoBorrowVec(r, _)) |
                     Some(ty::AutoBorrowVecRef(r, _)) |
-                    Some(ty::AutoBorrowFn(r)) => {
+                    Some(ty::AutoBorrowFn(r)) |
+                    Some(ty::AutoBorrowObj(r, _)) => {
                         // If there is an autoref, then the result of this
                         // expression will be some sort of borrowed pointer.
                         expr_ct.cat.guarantor = None;

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

@@ -65,7 +65,7 @@ we may want to adjust precisely when coercions occur.
 */
 
 
-use middle::ty::{AutoPtr, AutoBorrowVec, AutoBorrowFn};
+use middle::ty::{AutoPtr, AutoBorrowVec, AutoBorrowFn, AutoBorrowObj};
 use middle::ty::{AutoDerefRef};
 use middle::ty::{vstore_slice, vstore_box, vstore_uniq};
 use middle::ty::{mt};
@@ -121,6 +121,12 @@ impl Coerce {
                 };
             }
 
+            ty::ty_trait(_, _, ty::RegionTraitStore(*), _, _) => {
+                return do self.unpack_actual_value(a) |sty_a| {
+                    self.coerce_borrowed_object(a, sty_a, b)
+                };
+            }
+
             ty::ty_ptr(mt_b) => {
                 return do self.unpack_actual_value(a) |sty_a| {
                     self.coerce_unsafe_ptr(a, sty_a, b, mt_b)
@@ -265,6 +271,40 @@ impl Coerce {
         })))
     }
 
+    fn coerce_borrowed_object(&self,
+                              a: ty::t,
+                              sty_a: &ty::sty,
+                              b: ty::t) -> CoerceResult
+    {
+        debug!("coerce_borrowed_object(a=%s, sty_a=%?, b=%s)",
+               a.inf_str(self.infcx), sty_a,
+               b.inf_str(self.infcx));
+
+        let tcx = self.infcx.tcx;
+        let r_a = self.infcx.next_region_var(Coercion(self.trace));
+        let trt_mut;
+
+        let a_borrowed = match *sty_a {
+            ty::ty_trait(_, _, ty::RegionTraitStore(_), _, _) => {
+                return self.subtype(a, b);
+            }
+            ty::ty_trait(did, ref substs, _, m, b) => {
+                trt_mut = m;
+                ty::mk_trait(tcx, did, substs.clone(),
+                             ty::RegionTraitStore(r_a), m, b)
+            }
+            _ => {
+                return self.subtype(a, b);
+            }
+        };
+
+        if_ok!(self.tys(a_borrowed, b));
+        Ok(Some(@AutoDerefRef(AutoDerefRef {
+            autoderefs: 0,
+            autoref: Some(AutoBorrowObj(r_a, trt_mut))
+        })))
+    }
+
     pub fn coerce_borrowed_fn(&self,
                               a: ty::t,
                               sty_a: &ty::sty,

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

@@ -88,7 +88,7 @@ pub enum method_origin {
     method_param(method_param),
 
     // method invoked on a trait instance
-    method_trait(ast::def_id, uint, ty::TraitStore),
+    method_trait(ast::def_id, uint),
 
 }
 

src/librustc/middle/typeck/mod.rs

@@ -747,9 +747,8 @@ impl Repr for typeck::method_origin {
             &typeck::method_param(ref p) => {
                 p.repr(tcx)
             }
-            &typeck::method_trait(def_id, n, st) => {
-                fmt!("method_trait(%s, %?, %s)", def_id.repr(tcx), n,
-                     st.repr(tcx))
+            &typeck::method_trait(def_id, n) => {
+                fmt!("method_trait(%s, %?)", def_id.repr(tcx), n)
             }
         }
     }