---

yaml
---
r: 24521
b: refs/heads/try2
c: d52f0f7
h: refs/heads/master
i:
  24519: 48786d8
v: v3

Author: msullivan

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: c854d6ebdb582116e2be0cb2a4a3a4004bc6dce2
+refs/heads/try2: d52f0f79bcfd86b689d88a2edfcdb4aafac2e8af
 refs/heads/incoming: 05543fd04dfb3f63b453a331e239ceb1a9a219f9
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try2/src/rustc/middle/typeck/check/vtable.rs

@@ -115,67 +115,67 @@ fn lookup_vtable(fcx: @fn_ctxt, isc: resolve::iscopes, sp: span,
         for list::each(isc) |impls| {
             /* For each impl in scope... */
             for vec::each(*impls) |im| {
-                    // im = one specific impl
-                    // find the iface that im implements (if any)
-                    let of_ty = alt ty::impl_iface(tcx, im.did) {
-                      some(of_ty) { of_ty }
-                      _ { cont; }
-                    };
+                // im = one specific impl
+                // find the iface that im implements (if any)
+                let of_ty = alt ty::impl_iface(tcx, im.did) {
+                  some(of_ty) { of_ty }
+                  _ { cont; }
+                };
 
-                    // it must have the same id as the expected one
-                    alt ty::get(of_ty).struct {
-                      ty::ty_iface(id, _) if id != iface_id { cont; }
-                      _ { /* ok */ }
-                    }
+                // it must have the same id as the expected one
+                alt ty::get(of_ty).struct {
+                  ty::ty_iface(id, _) if id != iface_id { cont; }
+                  _ { /* ok */ }
+                }
 
-                    // check whether the type unifies with the type
-                    // that the impl is for, and continue if not
-                    let {substs: substs, ty: for_ty} =
-                        impl_self_ty(fcx, im.did);
-                    let im_bs = ty::lookup_item_type(tcx, im.did).bounds;
-                    alt fcx.mk_subty(ty, for_ty) {
-                      result::err(_) { cont; }
-                      result::ok(()) { }
-                    }
+                // check whether the type unifies with the type
+                // that the impl is for, and continue if not
+                let {substs: substs, ty: for_ty} =
+                    impl_self_ty(fcx, im.did);
+                let im_bs = ty::lookup_item_type(tcx, im.did).bounds;
+                alt fcx.mk_subty(ty, for_ty) {
+                  result::err(_) { cont; }
+                  result::ok(()) { }
+                }
 
-                    // check that desired iface type unifies
-                    #debug("(checking vtable) @2 relating iface ty %s to \
-                            of_ty %s",
-                            fcx.infcx.ty_to_str(iface_ty),
-                            fcx.infcx.ty_to_str(of_ty));
-                    let of_ty = ty::subst(tcx, substs, of_ty);
-                    relate_iface_tys(fcx, sp, iface_ty, of_ty);
+                // check that desired iface type unifies
+                #debug("(checking vtable) @2 relating iface ty %s to \
+                        of_ty %s",
+                       fcx.infcx.ty_to_str(iface_ty),
+                       fcx.infcx.ty_to_str(of_ty));
+                let of_ty = ty::subst(tcx, substs, of_ty);
+                relate_iface_tys(fcx, sp, iface_ty, of_ty);
 
-                    // recursively process the bounds
-                    let iface_tps = iface_substs.tps;
-                    let substs_f = fixup_substs(fcx, sp, iface_id, substs);
-                    connect_iface_tps(fcx, sp, substs_f.tps,
-                                      iface_tps, im.did);
-                    let subres = lookup_vtables(fcx, isc, sp,
-                                                im_bs, substs_f, false);
-                    vec::push(found,
-                              vtable_static(im.did, substs_f.tps, subres));
-                }
+                // recursively process the bounds
+                let iface_tps = iface_substs.tps;
+                let substs_f = fixup_substs(fcx, sp, iface_id, substs);
+                connect_iface_tps(fcx, sp, substs_f.tps,
+                                  iface_tps, im.did);
+                let subres = lookup_vtables(fcx, isc, sp,
+                                            im_bs, substs_f, false);
+                vec::push(found,
+                          vtable_static(im.did, substs_f.tps, subres));
+            }
 
-                alt found.len() {
-                  0u { /* fallthrough */ }
-                  1u { ret found[0]; }
-                  _ {
-                    fcx.ccx.tcx.sess.span_err(
-                        sp, "multiple applicable methods in scope");
-                    ret found[0];
-                  }
-                }
+            alt found.len() {
+              0u { /* fallthrough */ }
+              1u { ret found[0]; }
+              _ {
+                fcx.ccx.tcx.sess.span_err(
+                    sp, "multiple applicable methods in scope");
+                ret found[0];
+              }
             }
-          }
         }
-
-        tcx.sess.span_fatal(
-            sp, "failed to find an implementation of interface " +
-            ty_to_str(tcx, iface_ty) + " for " +
-            ty_to_str(tcx, ty));
+      }
     }
 
+    tcx.sess.span_fatal(
+        sp, "failed to find an implementation of interface " +
+        ty_to_str(tcx, iface_ty) + " for " +
+        ty_to_str(tcx, ty));
+}
+
 fn fixup_ty(fcx: @fn_ctxt, sp: span, ty: ty::t) -> ty::t {
     let tcx = fcx.ccx.tcx;
     alt infer::resolve_deep(fcx.infcx, ty, force_all) {