---

yaml
---
r: 31694
b: refs/heads/dist-snap
c: efea6f0
h: refs/heads/master
v: v3

Author: lkuper

[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: e656261ee7ff7cfd301c0d7c31cdc969e3bdbfeb
+refs/heads/dist-snap: efea6f016eacf258e7b6bdaa960a39b3e7f91fa5
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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

@@ -25,20 +25,20 @@ fn transform_self_type_for_method(fcx: @fn_ctxt,
                                   method_info: MethodInfo)
                                -> ty::t {
     match method_info.self_type {
-        sty_by_ref | sty_value => {
-            impl_ty
-        }
-        sty_region(r, mutability) => {
-            // XXX: dummy_sp is unfortunate here.
-            let region = ast_region_to_region(fcx, fcx, dummy_sp(), r);
-            mk_rptr(fcx.ccx.tcx, region, { ty: impl_ty, mutbl: mutability })
-        }
-        sty_box(mutability) => {
-            mk_box(fcx.ccx.tcx, { ty: impl_ty, mutbl: mutability })
-        }
-        sty_uniq(mutability) => {
-            mk_uniq(fcx.ccx.tcx, { ty: impl_ty, mutbl: mutability })
-        }
+      sty_by_ref | sty_value => {
+        impl_ty
+      }
+      sty_region(r, mutability) => {
+        // XXX: dummy_sp is unfortunate here.
+        let region = ast_region_to_region(fcx, fcx, dummy_sp(), r);
+        mk_rptr(fcx.ccx.tcx, region, { ty: impl_ty, mutbl: mutability })
+      }
+      sty_box(mutability) => {
+        mk_box(fcx.ccx.tcx, { ty: impl_ty, mutbl: mutability })
+      }
+      sty_uniq(mutability) => {
+        mk_uniq(fcx.ccx.tcx, { ty: impl_ty, mutbl: mutability })
+      }
     }
 }
 
@@ -96,21 +96,21 @@ class lookup {
         match get_base_type_def_id(self.fcx.infcx,
                                  self.self_expr.span,
                                  self.self_ty) {
-            none => {
-                optional_inherent_methods = none;
-            }
-            some(base_type_def_id) => {
-                debug!{"(checking method) found base type"};
-                optional_inherent_methods =
-                    self.fcx.ccx.coherence_info.inherent_methods.find
-                        (base_type_def_id);
-
-                if optional_inherent_methods.is_none() {
-                    debug!{"(checking method) ... no inherent methods found"};
-                } else {
-                    debug!{"(checking method) ... inherent methods found"};
-                }
+          none => {
+            optional_inherent_methods = none;
+          }
+          some(base_type_def_id) => {
+            debug!{"(checking method) found base type"};
+            optional_inherent_methods =
+                self.fcx.ccx.coherence_info.inherent_methods.find
+                (base_type_def_id);
+
+            if optional_inherent_methods.is_none() {
+                debug!{"(checking method) ... no inherent methods found"};
+            } else {
+                debug!{"(checking method) ... inherent methods found"};
             }
+          }
         }
 
         loop {
@@ -462,52 +462,52 @@ class lookup {
 
         // Add inherent methods.
         match optional_inherent_methods {
-            none => {
-                // Continue.
-            }
-            some(inherent_methods) => {
-                debug!{"(adding inherent and extension candidates) adding \
-                        inherent candidates"};
-                for inherent_methods.each |implementation| {
-                    debug!{"(adding inherent and extension candidates) \
-                            adding candidates from impl: %s",
-                           node_id_to_str(self.tcx().items,
-                                          implementation.did.node)};
-                    self.add_candidates_from_impl(implementation,
-                                                  use_assignability);
-                }
+          none => {
+            // Continue.
+          }
+          some(inherent_methods) => {
+            debug!{"(adding inherent and extension candidates) adding \
+                    inherent candidates"};
+            for inherent_methods.each |implementation| {
+                debug!{"(adding inherent and extension candidates) \
+                        adding candidates from impl: %s",
+                        node_id_to_str(self.tcx().items,
+                                       implementation.did.node)};
+                self.add_candidates_from_impl(implementation,
+                                              use_assignability);
             }
+          }
         }
 
         // Add trait methods.
         match self.fcx.ccx.trait_map.find(self.expr.id) {
-            none => {
-                // Should only happen for placement new right now.
-            }
-            some(trait_ids) => {
-                for (*trait_ids).each |trait_id| {
-                    debug!{"(adding inherent and extension candidates) \
-                            trying trait: %s",
-                           self.def_id_to_str(trait_id)};
-
-                    let coherence_info = self.fcx.ccx.coherence_info;
-                    match coherence_info.extension_methods.find(trait_id) {
-                        none => {
-                            // Do nothing.
-                        }
-                        some(extension_methods) => {
-                            for extension_methods.each |implementation| {
-                                debug!{"(adding inherent and extension \
-                                         candidates) adding impl %s",
-                                       self.def_id_to_str
-                                        (implementation.did)};
-                                self.add_candidates_from_impl
-                                    (implementation, use_assignability);
-                            }
-                        }
+          none => {
+            // Should only happen for placement new right now.
+          }
+          some(trait_ids) => {
+            for (*trait_ids).each |trait_id| {
+                debug!{"(adding inherent and extension candidates) \
+                        trying trait: %s",
+                        self.def_id_to_str(trait_id)};
+
+                let coherence_info = self.fcx.ccx.coherence_info;
+                match coherence_info.extension_methods.find(trait_id) {
+                  none => {
+                    // Do nothing.
+                  }
+                  some(extension_methods) => {
+                    for extension_methods.each |implementation| {
+                        debug!{"(adding inherent and extension \
+                                candidates) adding impl %s",
+                                self.def_id_to_str
+                                (implementation.did)};
+                        self.add_candidates_from_impl
+                            (implementation, use_assignability);
                     }
+                  }
                 }
             }
+          }
         }
     }
 
@@ -531,7 +531,7 @@ class lookup {
         // required receiver type (cand.rcvr_ty).  If this method is not
         // from an impl, this'll basically be a no-nop.
         match self.fcx.mk_assignty(self.self_expr, self.borrow_lb,
-                                 cand.self_ty, cand.rcvr_ty) {
+                                   cand.self_ty, cand.rcvr_ty) {
           result::ok(_) => (),
           result::err(_) => {
             self.tcx().sess.span_bug(