Apply comments from tjc

src/librustc/middle/subst.rs

@@ -28,33 +28,37 @@ pub trait Subst {
 // Substitution over types
 //
 // Because this is so common, we make a special optimization to avoid
-// doing anything is `substs` is a no-op.  I tried to generalize these
+// doing anything if `substs` is a no-op.  I tried to generalize these
 // to all subst methods but ran into trouble due to the limitations of
 // our current method/trait matching algorithm. - Niko
 
-trait Subst1 {
-    fn subst1(&self, tcx: ty::ctxt, substs: &ty::substs) -> Self;
+trait EffectfulSubst {
+    fn effectfulSubst(&self, tcx: ty::ctxt, substs: &ty::substs) -> Self;
 }
 
 impl Subst for ty::t {
     fn subst(&self, tcx: ty::ctxt, substs: &ty::substs) -> ty::t {
         if ty::substs_is_noop(substs) {
             return *self;
         } else {
-            return self.subst1(tcx, substs);
+            return self.effectfulSubst(tcx, substs);
         }
     }
 }
 
-impl Subst1 for ty::t {
-    fn subst1(&self, tcx: ty::ctxt, substs: &ty::substs) -> ty::t {
+impl EffectfulSubst for ty::t {
+    fn effectfulSubst(&self, tcx: ty::ctxt, substs: &ty::substs) -> ty::t {
         if !ty::type_needs_subst(*self) {
             return *self;
         }
 
         match ty::get(*self).sty {
-            ty::ty_param(p) => substs.tps[p.idx],
-            ty::ty_self(_) => substs.self_ty.get(),
+            ty::ty_param(p) => {
+                substs.tps[p.idx]
+            }
+            ty::ty_self(_) => {
+                substs.self_ty.expect("ty_self not found in substs")
+            }
             _ => {
                 ty::fold_regions_and_ty(
                     tcx, *self,
@@ -74,8 +78,8 @@ impl Subst1 for ty::t {
                         }
                         _ => r
                     },
-                    |t| t.subst1(tcx, substs),
-                    |t| t.subst1(tcx, substs))
+                    |t| t.effectfulSubst(tcx, substs),
+                    |t| t.effectfulSubst(tcx, substs))
             }
         }
     }

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

@@ -376,7 +376,14 @@ pub impl<'self> LookupContext<'self> {
 
         let tcx = self.tcx();
         let mut next_bound_idx = 0; // count only trait bounds
-        let type_param_def = tcx.ty_param_defs.get(&param_ty.def_id.node);
+        let type_param_def = match tcx.ty_param_defs.find(&param_ty.def_id.node) {
+            Some(t) => t,
+            None => {
+                tcx.sess.span_bug(
+                    self.expr.span,
+                    fmt!("No param def for %?", param_ty));
+            }
+        };
 
         for ty::each_bound_trait_and_supertraits(tcx, type_param_def.bounds)
             |bound_trait_ref|

src/librustc/middle/typeck/collect.rs

@@ -335,7 +335,7 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt,
                            ty::mk_bare_fn(tcx, copy m.fty));
 
         // create the type parameter definitions for `foo`, applying
-        // the substutition to any traits that appear in their bounds.
+        // the substitution to any traits that appear in their bounds.
 
         // add in the type parameters from the trait
         let mut new_type_param_defs = ~[];