---

yaml
---
r: 32636
b: refs/heads/dist-snap
c: 527a6f6
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: 48496fc1b62a2b7724117746f352b6b330aa63fb
+refs/heads/dist-snap: 527a6f60f14c6f38b524cfd5119c670aa0f9bef9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/src/rustc/middle/typeck/check/method.rs

@@ -49,7 +49,10 @@ candidates in the same way.
 If find no matching candidate at all, we proceed to auto-deref the
 receiver type and search again.  We keep doing that until we cannot
 auto-deref any longer.  At that point, we will attempt an auto-ref.
-If THAT fails, method lookup fails altogether.
+If THAT fails, method lookup fails altogether.  Autoref itself comes
+in two varieties, autoslice and autoptr.  The former converts `~[]` to
+`&[]` and the latter converts any type `T` to `&mut T`, `&const T`, or
+`&T`.
 
 ## Why two phases?
 
@@ -513,63 +516,100 @@ impl LookupContext {
         }
     }
 
-    fn search_for_appr_autorefd_method(
+    fn search_for_any_autorefd_method(
         &self,
         self_ty: ty::t,
         autoderefs: uint)
         -> Option<method_map_entry>
     {
+        /*!
+         *
+         * Attempts both auto-slice and auto-ptr, as appropriate.
+         */
+
         let tcx = self.tcx();
 
-        // Next, try auto-ref. The precise kind of auto-ref depends on
-        // the fully deref'd receiver type.  In particular, we must
-        // treat dynamically sized types like `str`, `[]` or `fn`
-        // differently than other types because they cannot be fully
-        // deref'd, unlike say @T.
-        match ty::get(self_ty).sty {
-            ty_box(*) | ty_uniq(*) | ty_rptr(*) => {
-                // we should be fully autoderef'd
-                self.bug(fmt!("Receiver type %s should be fully \
-                               autoderef'd by this point",
-                              self.ty_to_str(self_ty)));
-            }
+        match self.search_for_autosliced_method(self_ty, autoderefs) {
+            Some(mme) => { return mme; }
+            None => {}
+        }
 
-            ty_infer(IntVar(_)) | // FIXME(#3211)---should be resolved
-            ty_self | ty_param(*) | ty_nil | ty_bot | ty_bool |
-            ty_int(*) | ty_uint(*) |
-            ty_float(*) | ty_enum(*) | ty_ptr(*) | ty_rec(*) |
-            ty_class(*) | ty_tup(*) => {
-                return self.search_for_autorefd_method(
-                    AutoPtr, autoderefs, [m_const, m_imm, m_mutbl],
-                    |m,r| ty::mk_rptr(tcx, r, {ty:self_ty, mutbl:m}));
-            }
+        match self.search_for_autoptrd_method(self_ty, autoderefs) {
+            Some(mme) => { return mme; }
+            None => {}
+        }
 
-            ty_trait(*) | ty_fn(*) => {
-                // NDM---eventually these should be some variant of autoref
-                return None;
-            }
+        return None;
+    }
 
-            ty_estr(vstore_slice(_)) |
-            ty_evec(_, vstore_slice(_)) => {
-                return None;
-            }
+    fn search_for_autosliced_method(
+        &self,
+        self_ty: ty::t,
+        autoderefs: uint)
+        -> Option<method_map_entry>
+    {
+        /*!
+         *
+         * Searches for a candidate by converting things like
+         * `~[]` to `&[]`. */
 
+        match ty::get(self_ty).sty {
             ty_evec(mt, vstore_box) |
             ty_evec(mt, vstore_uniq) |
             ty_evec(mt, vstore_fixed(_)) => {
-                return self.search_for_autorefd_method(
+                self.search_for_some_kind_of_autorefd_method(
                     AutoSlice, autoderefs, [m_const, m_imm, m_mutbl],
                     |m,r| ty::mk_evec(tcx,
                                       {ty:mt.ty, mutbl:m},
-                                      vstore_slice(r)));
+                                      vstore_slice(r)))
             }
 
             ty_estr(vstore_box) |
             ty_estr(vstore_uniq) |
             ty_estr(vstore_fixed(_)) => {
-                return self.search_for_autorefd_method(
+                self.search_for_some_kind_of_autorefd_method(
                     AutoSlice, autoderefs, [m_imm],
-                    |_m,r| ty::mk_estr(tcx, vstore_slice(r)));
+                    |_m,r| ty::mk_estr(tcx, vstore_slice(r)))
+            }
+
+            ty_trait(*) | ty_fn(*) => {
+                // NDM---eventually these should be some variant of autoref
+                None
+            }
+
+            _ => None
+        }
+    }
+
+    fn search_for_autoptrd_method(
+        &self,
+        self_ty: ty::t,
+        autoderefs: uint)
+        -> Option<method_map_entry>
+    {
+        /*!
+         *
+         * Converts any type `T` to `&M T` where `M` is an
+         * appropriate mutability.
+         */
+
+        match ty::get(self_ty).sty {
+            ty_box(*) | ty_uniq(*) | ty_rptr(*) => {
+                // we should be fully autoderef'd
+                self.bug(fmt!("Receiver type %s should be fully \
+                               autoderef'd by this point",
+                              self.ty_to_str(self_ty)));
+            }
+
+            ty_infer(IntVar(_)) | // FIXME(#3211)---should be resolved
+            ty_self | ty_param(*) | ty_nil | ty_bot | ty_bool |
+            ty_int(*) | ty_uint(*) |
+            ty_float(*) | ty_enum(*) | ty_ptr(*) | ty_rec(*) |
+            ty_class(*) | ty_tup(*) | ty_estr(*) | ty_evec(*) |
+            ty_trait(*) | ty_fn(*) => {
+                self.search_for_some_kind_of_autorefd_method(
+                    AutoPtr, autoderefs, [m_const, m_imm, m_mutbl],
+                    |m,r| ty::mk_rptr(tcx, r, {ty:self_ty, mutbl:m}))
             }
 
             ty_opaque_closure_ptr(_) | ty_unboxed_vec(_) |
@@ -580,7 +620,7 @@ impl LookupContext {
         }
     }
 
-    fn search_for_autorefd_method(
+    fn search_for_some_kind_of_autorefd_method(
         &self,
         kind: AutoRefKind,
         autoderefs: uint,