rustc: more pattern cleanup

24 files changed, 74 insertions, 79 deletions

diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index d0c67f85bb0..47ea2a02b60 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -223,7 +223,7 @@ fn map_item(i: @item, cx: ctx, v: vt) {
         map_struct_def(struct_def, node_item(i, item_path), i.ident, i.id, cx,
                        v);
       }
-      item_trait(tps, traits, methods) => {
+      item_trait(_, traits, methods) => {
         // Map trait refs to their parent classes. This is
         // so we can find the self_ty
         for traits.each |p| {
@@ -318,16 +318,16 @@ fn node_id_to_str(map: map, id: node_id, itr: ident_interner) -> ~str {
         fmt!("foreign item %s with abi %? (id=%?)",
              path_ident_to_str(*path, item.ident, itr), abi, id)
       }
-      Some(node_method(m, impl_did, path)) => {
+      Some(node_method(m, _, path)) => {
         fmt!("method %s in %s (id=%?)",
              *itr.get(m.ident), path_to_str(*path, itr), id)
       }
-      Some(node_trait_method(tm, impl_did, path)) => {
+      Some(node_trait_method(tm, _, path)) => {
         let m = ast_util::trait_method_to_ty_method(*tm);
         fmt!("method %s in %s (id=%?)",
              *itr.get(m.ident), path_to_str(*path, itr), id)
       }
-      Some(node_variant(variant, def_id, path)) => {
+      Some(node_variant(variant, _, path)) => {
         fmt!("variant %s in %s (id=%?)",
              *itr.get(variant.node.name), path_to_str(*path, itr), id)
       }
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 366207ee427..7c1be7b42a7 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -197,7 +197,7 @@ fn expand_item_mac(exts: hashmap<~str, syntax_extension>,
                    cx: ext_ctxt, &&it: @ast::item,
                    fld: ast_fold) -> Option<@ast::item> {
     match it.node {
-      item_mac({node: mac_invoc_tt(pth, tts), span}) => {
+      item_mac({node: mac_invoc_tt(pth, tts), _}) => {
         let extname = cx.parse_sess().interner.get(pth.idents[0]);
         match exts.find(*extname) {
           None => {
diff --git a/src/libsyntax/ext/simplext.rs b/src/libsyntax/ext/simplext.rs
index ee65d81974e..f7cc1a88620 100644
--- a/src/libsyntax/ext/simplext.rs
+++ b/src/libsyntax/ext/simplext.rs
@@ -504,7 +504,7 @@ fn p_t_s_r_path(cx: ext_ctxt, p: @path, s: selector, b: binders) {
       Some(p_id) => {
         fn select(cx: ext_ctxt, m: matchable) -> match_result {
             return match m {
-                  match_expr(e) => Some(leaf(specialize_match(m))),
+                  match_expr(*) => Some(leaf(specialize_match(m))),
                   _ => cx.bug(~"broken traversal in p_t_s_r")
                 }
         }
@@ -646,7 +646,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
             match elts[0u].node {
               expr_mac(mac) => {
                 match mac.node {
-                  mac_invoc(pth, invoc_arg, body) => {
+                  mac_invoc(pth, invoc_arg, _) => {
                     match path_to_ident(pth) {
                       Some(id) => {
                         let id_str = cx.str_of(id);
diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs
index fbca90b5f49..be770281faa 100644
--- a/src/libsyntax/print/pp.rs
+++ b/src/libsyntax/print/pp.rs
@@ -378,7 +378,7 @@ impl printer {
         if !self.scan_stack_empty {
             let x = self.scan_top();
             match copy self.token[x] {
-              BEGIN(b) => {
+              BEGIN(_) => {
                 if k > 0 {
                     self.size[self.scan_pop()] = self.size[x] +
                         self.right_total;
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index d1886908173..bc4dd8dccf3 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -250,7 +250,7 @@ fn visit_pat<E>(p: @pat, e: E, v: vt<E>) {
 
 fn visit_foreign_item<E>(ni: @foreign_item, e: E, v: vt<E>) {
     match ni.node {
-      foreign_item_fn(fd, purity, tps) => {
+      foreign_item_fn(fd, _, tps) => {
         v.visit_ty_params(tps, e, v);
         visit_fn_decl(fd, e, v);
       }
diff --git a/src/rustc/middle/borrowck/gather_loans.rs b/src/rustc/middle/borrowck/gather_loans.rs
index 6041989bd8c..c9e693e47bc 100644
--- a/src/rustc/middle/borrowck/gather_loans.rs
+++ b/src/rustc/middle/borrowck/gather_loans.rs
@@ -410,7 +410,7 @@ impl gather_loan_ctxt {
                   arm_id: ast::node_id, alt_id: ast::node_id) {
         do self.bccx.cat_pattern(discr_cmt, root_pat) |cmt, pat| {
             match pat.node {
-              ast::pat_ident(bm, id, o_pat) if !self.pat_is_variant(pat) => {
+              ast::pat_ident(bm, _, _) if !self.pat_is_variant(pat) => {
                 match bm {
                   ast::bind_by_value | ast::bind_by_move => {
                     // copying does not borrow anything, so no check
diff --git a/src/rustc/middle/borrowck/loan.rs b/src/rustc/middle/borrowck/loan.rs
index 07d1a00d61d..15e307b6a93 100644
--- a/src/rustc/middle/borrowck/loan.rs
+++ b/src/rustc/middle/borrowck/loan.rs
@@ -113,9 +113,9 @@ impl loan_ctxt {
             // then the memory is freed.
             self.loan_unstable_deref(cmt, cmt_base, req_mutbl)
           }
-          cat_deref(cmt1, _, unsafe_ptr) |
-          cat_deref(cmt1, _, gc_ptr) |
-          cat_deref(cmt1, _, region_ptr(_)) => {
+          cat_deref(_, _, unsafe_ptr) |
+          cat_deref(_, _, gc_ptr) |
+          cat_deref(_, _, region_ptr(_)) => {
             // Aliased data is simply not lendable.
             self.bccx.tcx.sess.span_bug(
                 cmt.span,
diff --git a/src/rustc/middle/borrowck/preserve.rs b/src/rustc/middle/borrowck/preserve.rs
index 34bf0eae115..7ce87a31b39 100644
--- a/src/rustc/middle/borrowck/preserve.rs
+++ b/src/rustc/middle/borrowck/preserve.rs
@@ -16,7 +16,7 @@ impl preserve_condition {
     fn combine(pc: preserve_condition) -> preserve_condition {
         match self {
           pc_ok => {pc}
-          pc_if_pure(e) => {self}
+          pc_if_pure(_) => {self}
         }
     }
 }
diff --git a/src/rustc/middle/check_alt.rs b/src/rustc/middle/check_alt.rs
index 0f4aa8167da..e6c990f2ab6 100644
--- a/src/rustc/middle/check_alt.rs
+++ b/src/rustc/middle/check_alt.rs
@@ -351,7 +351,7 @@ fn specialize(tcx: ty::ctxt, r: ~[@pat], ctor_id: ctor, arity: uint,
         // Grab the class data that we care about.
         let class_fields, class_id;
         match ty::get(left_ty).struct {
-            ty::ty_class(cid, substs) => {
+            ty::ty_class(cid, _) => {
                 class_id = cid;
                 class_fields = ty::lookup_class_fields(tcx, class_id);
             }
@@ -414,7 +414,7 @@ fn check_local(tcx: ty::ctxt, loc: @local, &&s: (), v: visit::vt<()>) {
 
 fn is_refutable(tcx: ty::ctxt, pat: @pat) -> bool {
     match tcx.def_map.find(pat.id) {
-      Some(def_variant(enum_id, var_id)) => {
+      Some(def_variant(enum_id, _)) => {
         if vec::len(*ty::enum_variants(tcx, enum_id)) != 1u {
             return true;
         }
diff --git a/src/rustc/middle/check_const.rs b/src/rustc/middle/check_const.rs
index 07bcc66358b..881716f7fb8 100644
--- a/src/rustc/middle/check_const.rs
+++ b/src/rustc/middle/check_const.rs
@@ -179,7 +179,7 @@ fn check_item_recursion(sess: session, ast_map: ast_map::map,
 
     fn visit_expr(e: @expr, &&env: env, v: visit::vt<env>) {
         match e.node {
-          expr_path(path) => {
+          expr_path(*) => {
             match env.def_map.find(e.id) {
               Some(def_const(def_id)) => {
                 match env.ast_map.get(def_id.node) {
diff --git a/src/rustc/middle/lint.rs b/src/rustc/middle/lint.rs
index 329d7b73f76..f5565de7d94 100644
--- a/src/rustc/middle/lint.rs
+++ b/src/rustc/middle/lint.rs
@@ -417,7 +417,7 @@ fn check_item_ctypes(cx: ty::ctxt, it: @ast::item) {
       either::Right(ast::foreign_abi_rust_intrinsic) => {
         for nmod.items.each |ni| {
             match ni.node {
-              ast::foreign_item_fn(decl, _, tps) => {
+              ast::foreign_item_fn(decl, _, _) => {
                 check_foreign_fn(cx, it.id, decl);
               }
               ast::foreign_item_const(*) => {}  // XXX: Not implemented.
@@ -434,7 +434,7 @@ fn check_item_path_statement(cx: ty::ctxt, it: @ast::item) {
             match s.node {
               ast::stmt_semi(@{id: id,
                                callee_id: _,
-                               node: ast::expr_path(@path),
+                               node: ast::expr_path(_),
                                span: _}, _) => {
                 cx.sess.span_lint(
                     path_statement, id, it.id,
diff --git a/src/rustc/middle/liveness.rs b/src/rustc/middle/liveness.rs
index fe89e45769c..bffae2944f7 100644
--- a/src/rustc/middle/liveness.rs
+++ b/src/rustc/middle/liveness.rs
@@ -338,18 +338,13 @@ impl IrMaps {
         let vk = self.var_kinds[*var];
         debug!("Node %d is a last use of variable %?", expr_id, vk);
         match vk {
-          Arg(id, name, by_move) |
-          Arg(id, name, by_copy) |
-          Local(LocalInfo {id:id, ident:name,
-                           kind: FromLetNoInitializer, _}) |
-          Local(LocalInfo {id:id, ident:name,
-                           kind: FromLetWithInitializer, _}) |
-          Local(LocalInfo {id:id, ident:name,
-                           kind: FromMatch(bind_by_value), _}) |
-          Local(LocalInfo {id:id, ident:name,
-                           kind: FromMatch(bind_by_ref(_)), _}) |
-          Local(LocalInfo {id:id, ident:name,
-                           kind: FromMatch(bind_by_move), _}) => {
+          Arg(id, _, by_move) |
+          Arg(id, _, by_copy) |
+          Local(LocalInfo {id: id, kind: FromLetNoInitializer, _}) |
+          Local(LocalInfo {id: id, kind: FromLetWithInitializer, _}) |
+          Local(LocalInfo {id: id, kind: FromMatch(bind_by_value), _}) |
+          Local(LocalInfo {id: id, kind: FromMatch(bind_by_ref(_)), _}) |
+          Local(LocalInfo {id: id, kind: FromMatch(bind_by_move), _}) => {
             let v = match self.last_use_map.find(expr_id) {
               Some(v) => v,
               None => {
@@ -1493,7 +1488,7 @@ fn check_expr(expr: @expr, &&self: @Liveness, vt: vt<@Liveness>) {
         visit::visit_expr(expr, self, vt);
       }
 
-      expr_fn(_, _, _, cap_clause) | expr_fn_block(_, _, cap_clause) => {
+      expr_fn(*) | expr_fn_block(*) => {
         let caps = (*self.ir).captures(expr);
         for (*caps).each |cap| {
             let var = self.variable_from_rdef(cap.rv, expr.span);
diff --git a/src/rustc/middle/mem_categorization.rs b/src/rustc/middle/mem_categorization.rs
index 2264678b46e..d53544c2573 100644
--- a/src/rustc/middle/mem_categorization.rs
+++ b/src/rustc/middle/mem_categorization.rs
@@ -378,7 +378,7 @@ impl &mem_categorization_ctxt {
               mutbl:m_imm, ty:expr_ty}
           }
 
-          ast::def_upvar(upvid, inner, fn_node_id, _) => {
+          ast::def_upvar(_, inner, fn_node_id, _) => {
             let ty = ty::node_id_to_type(self.tcx, fn_node_id);
             let proto = ty::ty_fn_proto(ty);
             match proto {
@@ -856,7 +856,7 @@ fn field_mutbl(tcx: ty::ctxt,
             }
         }
       }
-      ty::ty_class(did, substs) => {
+      ty::ty_class(did, _) => {
         for ty::lookup_class_fields(tcx, did).each |fld| {
             if fld.ident == f_name {
                 let m = match fld.mutability {
diff --git a/src/rustc/middle/resolve3.rs b/src/rustc/middle/resolve3.rs
index adb50e8b13a..d83fc7a244c 100644
--- a/src/rustc/middle/resolve3.rs
+++ b/src/rustc/middle/resolve3.rs
@@ -529,7 +529,7 @@ struct NameBindings {
 
     fn span_for_namespace(namespace: Namespace) -> Option<span> {
         match self.def_for_namespace(namespace) {
-          Some(d) => {
+          Some(_) => {
             match namespace {
               TypeNS   => self.type_span,
               ValueNS  => self.value_span,
@@ -866,7 +866,7 @@ struct Resolver {
 
                 visit_mod(module_, sp, item.id, new_parent, visitor);
             }
-            item_foreign_mod(foreign_module) => {
+            item_foreign_mod(*) => {
               let (name_bindings, new_parent) = self.add_child(atom, parent,
                                                            ~[ModuleNS], sp);
 
@@ -891,7 +891,7 @@ struct Resolver {
                      def_const(local_def(item.id)),
                      sp);
             }
-            item_fn(decl, purity, _, _) => {
+            item_fn(_, purity, _, _) => {
               let (name_bindings, new_parent) = self.add_child(atom, parent,
                                                         ~[ValueNS], sp);
 
@@ -1217,7 +1217,7 @@ struct Resolver {
             self.add_child(name, parent, ~[ValueNS], foreign_item.span);
 
         match foreign_item.node {
-            foreign_item_fn(fn_decl, purity, type_parameters) => {
+            foreign_item_fn(_, purity, type_parameters) => {
                 let def = def_fn(local_def(foreign_item.id), purity);
                 (*name_bindings).define_value(Public, def, foreign_item.span);
 
@@ -1227,7 +1227,7 @@ struct Resolver {
                     visit_foreign_item(foreign_item, new_parent, visitor);
                 }
             }
-            foreign_item_const(item_type) => {
+            foreign_item_const(*) => {
                 let def = def_const(local_def(foreign_item.id));
                 (*name_bindings).define_value(Public, def, foreign_item.span);
 
@@ -1319,8 +1319,8 @@ struct Resolver {
               }
             }
           }
-          def_fn(def_id, _) | def_static_method(def_id, _) |
-          def_const(def_id) | def_variant(_, def_id) => {
+          def_fn(*) | def_static_method(*) | def_const(*) |
+          def_variant(*) => {
             debug!("(building reduced graph for external \
                     crate) building value %s", final_ident);
             (*child_name_bindings).define_value(Public, def, dummy_sp());
@@ -2710,7 +2710,7 @@ struct Resolver {
                                         body_id);
                     }
                 }
-                MethodRibKind(item_id, method_id) => {
+                MethodRibKind(item_id, _) => {
                   // If the def is a ty param, and came from the parent
                   // item, it's ok
                   match def {
@@ -2954,7 +2954,7 @@ struct Resolver {
                                                        visitor);
                                 }
                             }
-                            foreign_item_const(item_type) => {
+                            foreign_item_const(_) => {
                                 visit_foreign_item(foreign_item, (),
                                                    visitor);
                             }
@@ -3033,7 +3033,7 @@ struct Resolver {
         f();
 
         match type_parameters {
-            HasTypeParameters(type_parameters, _, _, _) => {
+            HasTypeParameters(*) => {
                 (*self.type_ribs).pop();
             }
 
@@ -4228,7 +4228,7 @@ struct Resolver {
                                               fmt!("use of undeclared label \
                                                    `%s`", self.session.str_of(
                                                   label))),
-                    Some(dl_def(def @ def_label(id))) =>
+                    Some(dl_def(def @ def_label(_))) =>
                         self.record_def(expr.id, def),
                     Some(_) =>
                         self.session.span_bug(expr.span,
@@ -4514,7 +4514,7 @@ struct Resolver {
                     atoms.push(name);
                     current_module = module_;
                 }
-                BlockParentLink(module_, node_id) => {
+                BlockParentLink(module_, _) => {
                     atoms.push(syntax::parse::token::special_idents::opaque);
                     current_module = module_;
                 }
@@ -4555,7 +4555,7 @@ struct Resolver {
             let mut module_repr;
             match (*import_resolution).target_for_namespace(ModuleNS) {
                 None => { module_repr = ~""; }
-                Some(target) => {
+                Some(_) => {
                     module_repr = ~" module:?";
                     // XXX
                 }
@@ -4564,7 +4564,7 @@ struct Resolver {
             let mut value_repr;
             match (*import_resolution).target_for_namespace(ValueNS) {
                 None => { value_repr = ~""; }
-                Some(target) => {
+                Some(_) => {
                     value_repr = ~" value:?";
                     // XXX
                 }
@@ -4573,7 +4573,7 @@ struct Resolver {
             let mut type_repr;
             match (*import_resolution).target_for_namespace(TypeNS) {
                 None => { type_repr = ~""; }
-                Some(target) => {
+                Some(_) => {
                     type_repr = ~" type:?";
                     // XXX
                 }
diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs
index e180ed95c25..a3d388d10fa 100644
--- a/src/rustc/middle/ty.rs
+++ b/src/rustc/middle/ty.rs
@@ -2621,7 +2621,7 @@ fn unify_mode(cx: ctxt, modes: expected_found<ast::mode>)
       (m1, m2) if (m1 == m2) => {
         result::ok(m1)
       }
-      (ast::infer(id1), ast::infer(id2)) => {
+      (ast::infer(_), ast::infer(id2)) => {
         cx.inferred_modes.insert(id2, m1);
         result::ok(m1)
       }
@@ -2629,7 +2629,7 @@ fn unify_mode(cx: ctxt, modes: expected_found<ast::mode>)
         cx.inferred_modes.insert(id, m);
         result::ok(m1)
       }
-      (m1, m2) => {
+      (_, _) => {
         result::err(terr_mode_mismatch(modes))
       }
     }
@@ -3325,7 +3325,7 @@ fn normalize_ty(cx: ctxt, t: t) -> t {
             // This type has a vstore. Get rid of it
             mk_estr(cx, normalize_vstore(vstore)),
 
-        ty_rptr(region, mt) =>
+        ty_rptr(_, mt) =>
             // This type has a region. Get rid of it
             mk_rptr(cx, re_static, normalize_mt(cx, mt)),
 
diff --git a/src/rustc/middle/typeck.rs b/src/rustc/middle/typeck.rs
index 8163e367d61..de6f578666f 100644
--- a/src/rustc/middle/typeck.rs
+++ b/src/rustc/middle/typeck.rs
@@ -254,8 +254,8 @@ fn check_main_fn_ty(ccx: @crate_ctxt,
     let tcx = ccx.tcx;
     let main_t = ty::node_id_to_type(tcx, main_id);
     match ty::get(main_t).struct {
-      ty::ty_fn({purity: ast::impure_fn, proto: ty::proto_bare, bounds,
-                 inputs, output, ret_style: ast::return_val}) => {
+      ty::ty_fn({purity: ast::impure_fn, proto: ty::proto_bare,
+                 inputs, output, ret_style: ast::return_val, _}) => {
         match tcx.items.find(main_id) {
          Some(ast_map::node_item(it,_)) => {
              match it.node {
diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs
index f3036c0a5ae..012e384edb1 100644
--- a/src/rustc/middle/typeck/check.rs
+++ b/src/rustc/middle/typeck/check.rs
@@ -478,10 +478,10 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) {
       ast::item_enum(enum_definition, _) => {
         check_enum_variants(ccx, it.span, enum_definition.variants, it.id);
       }
-      ast::item_fn(decl, _, tps, body) => {
+      ast::item_fn(decl, _, _, body) => {
         check_bare_fn(ccx, decl, body, it.id, None);
       }
-      ast::item_impl(tps, _, ty, ms) => {
+      ast::item_impl(_, _, ty, ms) => {
         let rp = ccx.tcx.region_paramd_items.find(it.id);
         debug!("item_impl %s with id %d rp %?",
                ccx.tcx.sess.str_of(it.ident), it.id, rp);
@@ -493,7 +493,7 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) {
       ast::item_trait(_, _, trait_methods) => {
         for trait_methods.each |trait_method| {
             match trait_method {
-              required(ty_m) => {
+              required(*) => {
                 // Nothing to do, since required methods don't have
                 // bodies to check.
               }
@@ -734,7 +734,7 @@ fn do_autoderef(fcx: @fn_ctxt, sp: span, t: ty::t) -> ty::t {
               _ => ()
             }
           }
-          ty::ty_enum(did, substs) => {
+          ty::ty_enum(did, _) => {
             // Watch out for a type like `enum t = @t`.  Such a type would
             // otherwise infinitely auto-deref.  This is the only autoderef
             // loop that needs to be concerned with this, as an error will be
@@ -761,7 +761,7 @@ fn check_lit(fcx: @fn_ctxt, lit: @ast::lit) -> ty::t {
     let tcx = fcx.ccx.tcx;
 
     match lit.node {
-      ast::lit_str(s) => ty::mk_estr(tcx, ty::vstore_slice(ty::re_static)),
+      ast::lit_str(*) => ty::mk_estr(tcx, ty::vstore_slice(ty::re_static)),
       ast::lit_int(_, t) => ty::mk_mach_int(tcx, t),
       ast::lit_uint(_, t) => ty::mk_mach_uint(tcx, t),
       ast::lit_int_unsuffixed(_) => {
@@ -898,7 +898,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
                     |_br| fcx.infcx.next_region_var(sp,
                                                     call_expr_id)).fn_ty
               }
-              sty => {
+              _ => {
                 // I would like to make this span_err, but it's
                 // really hard due to the way that expr_bind() is
                 // written.
@@ -1146,7 +1146,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
         // supply the do keyword.  Let's be more helpful in that situation.
         if op == ast::or {
           match ty::get(lhs_resolved_t).struct {
-            ty::ty_fn(f) => {
+            ty::ty_fn(_) => {
               tcx.sess.span_note(
                   ex.span, ~"did you forget the 'do' keyword for the call?");
             }
@@ -1627,7 +1627,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
             match fcx.mk_subty(false, expr.span,
                                fty.output, ty::mk_bool(tcx)) {
               result::ok(_) => (),
-              result::err(err) => {
+              result::err(_) => {
                 tcx.sess.span_fatal(
                     expr.span, fmt!("a `loop` function's last argument \
                                      should return `bool`, not `%s`",
@@ -2221,7 +2221,7 @@ fn check_enum_variants(ccx: @crate_ctxt,
                 ast::tuple_variant_kind(_) | ast::struct_variant_kind(_) => {
                     arg_tys = Some(~[]);
                 }
-                ast::enum_variant_kind(subvariants) => {
+                ast::enum_variant_kind(_) => {
                     arg_tys = None;
                     do_check(ccx, sp, vs, id, disr_vals, disr_val, variants);
                 }
@@ -2306,7 +2306,7 @@ fn ty_param_bounds_and_ty_for_def(fcx: @fn_ctxt, sp: span, defn: ast::def) ->
         let typ = ty::mk_var(fcx.ccx.tcx, lookup_local(fcx, sp, nid));
         return no_params(typ);
       }
-      ast::def_fn(id, ast::extern_fn) => {
+      ast::def_fn(_, ast::extern_fn) => {
         // extern functions are just u8 pointers
         return {
             bounds: @~[],
@@ -2458,7 +2458,7 @@ fn ast_expr_vstore_to_vstore(fcx: @fn_ctxt, e: @ast::expr, n: uint,
       }
       ast::vstore_uniq => ty::vstore_uniq,
       ast::vstore_box => ty::vstore_box,
-      ast::vstore_slice(a_r) => {
+      ast::vstore_slice(_) => {
         let r = fcx.infcx.next_region_var(e.span, e.id);
         ty::vstore_slice(r)
       }
diff --git a/src/rustc/middle/typeck/check/alt.rs b/src/rustc/middle/typeck/check/alt.rs
index bad7ff85ca7..764c9d3d297 100644
--- a/src/rustc/middle/typeck/check/alt.rs
+++ b/src/rustc/middle/typeck/check/alt.rs
@@ -228,7 +228,7 @@ fn check_pat(pcx: pat_ctxt, pat: @ast::pat, expected: ty::t) {
           _ => ()
         }
       }
-      ast::pat_ident(_, path, c) => {
+      ast::pat_ident(_, path, _) => {
         check_pat_variant(pcx, pat, path, Some(~[]), expected);
       }
       ast::pat_enum(path, subpats) => {
diff --git a/src/rustc/middle/typeck/check/regionck.rs b/src/rustc/middle/typeck/check/regionck.rs
index 14fc3098367..1b720e3386f 100644
--- a/src/rustc/middle/typeck/check/regionck.rs
+++ b/src/rustc/middle/typeck/check/regionck.rs
@@ -38,7 +38,7 @@ fn encl_region_of_def(fcx: @fn_ctxt, def: ast::def) -> ty::region {
         def_local(node_id, _) | def_arg(node_id, _) | def_self(node_id) |
         def_binding(node_id, _) =>
             return encl_region(tcx, node_id),
-        def_upvar(local_id, subdef, closure_id, body_id) => {
+        def_upvar(_, subdef, closure_id, body_id) => {
             match ty_fn_proto(fcx.node_ty(closure_id)) {
                 proto_bare =>
                     tcx.sess.bug(~"proto_bare in encl_region_of_def?!"),
@@ -205,7 +205,7 @@ fn visit_expr(e: @ast::expr, &&rcx: @rcx, v: rvt) {
         };
       }
 
-      ast::expr_addr_of(_, operand) => {
+      ast::expr_addr_of(*) => {
         // FIXME(#3148) -- in some cases, we need to capture a dependency
         // between the regions found in operand the resulting region type.
         // See #3148 for more details.
diff --git a/src/rustc/middle/typeck/check/vtable.rs b/src/rustc/middle/typeck/check/vtable.rs
index 43301d5f738..f14931cb874 100644
--- a/src/rustc/middle/typeck/check/vtable.rs
+++ b/src/rustc/middle/typeck/check/vtable.rs
@@ -117,7 +117,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
               }
               ty::bound_trait(ity) => {
                 match ty::get(ity).struct {
-                  ty::ty_trait(idid, substs, _) => {
+                  ty::ty_trait(idid, _, _) => {
                     if trait_id == idid {
                         debug!("(checking vtable) @0 relating ty to trait ty
                                 with did %?", idid);
@@ -268,7 +268,7 @@ fn fixup_ty(fcx: @fn_ctxt,
                   for this bounded type parameter: %s",
                  fixup_err_to_str(e)))
       }
-      result::err(e) => {
+      result::err(_) => {
         None
       }
     }
diff --git a/src/rustc/middle/typeck/coherence.rs b/src/rustc/middle/typeck/coherence.rs
index f0b674e350a..63587cf4e3b 100644
--- a/src/rustc/middle/typeck/coherence.rs
+++ b/src/rustc/middle/typeck/coherence.rs
@@ -597,7 +597,7 @@ struct CoherenceChecker {
         }
 
         match item.node {
-            item_impl(ty_params, trait_refs, _, ast_methods) => {
+            item_impl(_, trait_refs, _, ast_methods) => {
                 let mut methods = ~[];
 
                 for ast_methods.each |ast_method| {
diff --git a/src/rustc/middle/typeck/collect.rs b/src/rustc/middle/typeck/collect.rs
index b3d70c0af4a..72faac19aba 100644
--- a/src/rustc/middle/typeck/collect.rs
+++ b/src/rustc/middle/typeck/collect.rs
@@ -331,7 +331,7 @@ fn check_methods_against_trait(ccx: @crate_ctxt,
     }
     for vec::each(*ty::trait_methods(tcx, did)) |trait_m| {
         match vec::find(impl_ms, |impl_m| trait_m.ident == impl_m.mty.ident) {
-          Some({mty: impl_m, id, span}) => {
+          Some({mty: impl_m, span, _}) => {
             compare_impl_method(
                 ccx.tcx, span, impl_m, vec::len(tps),
                 trait_m, tpt.substs, selfty);
@@ -350,7 +350,7 @@ fn check_methods_against_trait(ccx: @crate_ctxt,
 
                   match vec::find(provided_methods, |provided_method|
                                 provided_method.ident == trait_m.ident) {
-                    Some(m) => {
+                    Some(_) => {
                       // If there's a provided method with the name we
                       // want, then we're fine; nothing else to do.
                     }
@@ -660,7 +660,7 @@ fn ty_of_item(ccx: @crate_ctxt, it: @ast::item)
         tcx.tcache.insert(local_def(it.id), tpt);
         return tpt;
       }
-      ast::item_trait(tps, _, ms) => {
+      ast::item_trait(tps, _, _) => {
         let {bounds, substs} = mk_substs(ccx, tps, rp);
         let t = ty::mk_trait(tcx, local_def(it.id), substs, ty::vstore_box);
         let tpt = {bounds: bounds,
diff --git a/src/rustc/middle/typeck/infer/assignment.rs b/src/rustc/middle/typeck/infer/assignment.rs
index c33f4e4cfa8..b27cac57262 100644
--- a/src/rustc/middle/typeck/infer/assignment.rs
+++ b/src/rustc/middle/typeck/infer/assignment.rs
@@ -125,12 +125,12 @@ impl infer_ctxt {
         match (a_bnd, b_bnd) {
           (Some(a_bnd), Some(b_bnd)) => {
             match (ty::get(a_bnd).struct, ty::get(b_bnd).struct) {
-              (ty::ty_box(mt_a), ty::ty_rptr(r_b, mt_b)) => {
+              (ty::ty_box(*), ty::ty_rptr(r_b, mt_b)) => {
                 let nr_b = ty::mk_box(self.tcx, {ty: mt_b.ty,
                                                  mutbl: m_const});
                 self.crosspollinate(anmnt, a, nr_b, mt_b.mutbl, r_b)
               }
-              (ty::ty_uniq(mt_a), ty::ty_rptr(r_b, mt_b)) => {
+              (ty::ty_uniq(*), ty::ty_rptr(r_b, mt_b)) => {
                 let nr_b = ty::mk_uniq(self.tcx, {ty: mt_b.ty,
                                                   mutbl: m_const});
                 self.crosspollinate(anmnt, a, nr_b, mt_b.mutbl, r_b)
@@ -142,7 +142,7 @@ impl infer_ctxt {
                 self.crosspollinate(anmnt, a, nr_b, m_imm, r_b)
               }
 
-              (ty::ty_evec(mt_a, vs_a),
+              (ty::ty_evec(_, vs_a),
                ty::ty_evec(mt_b, ty::vstore_slice(r_b)))
               if is_borrowable(vs_a) => {
                 let nr_b = ty::mk_evec(self.tcx, {ty: mt_b.ty,
diff --git a/src/rustc/middle/typeck/infer/region_var_bindings.rs b/src/rustc/middle/typeck/infer/region_var_bindings.rs
index 8a7beaf95c9..cae41b23882 100644
--- a/src/rustc/middle/typeck/infer/region_var_bindings.rs
+++ b/src/rustc/middle/typeck/infer/region_var_bindings.rs
@@ -508,7 +508,7 @@ impl RegionVarBindings {
             ok(ty::re_static) // nothing lives longer than static
           }
 
-          (ty::re_var(v_id), _) | (_, ty::re_var(v_id)) => {
+          (ty::re_var(*), _) | (_, ty::re_var(*)) => {
             self.combine_vars(
                 self.lubs, a, b, span,
                 |old_r, new_r| self.make_subregion(span, old_r, new_r))
@@ -531,7 +531,7 @@ impl RegionVarBindings {
             ok(r)
           }
 
-          (ty::re_var(v_id), _) | (_, ty::re_var(v_id)) => {
+          (ty::re_var(*), _) | (_, ty::re_var(*)) => {
             self.combine_vars(
                 self.glbs, a, b, span,
                 |old_r, new_r| self.make_subregion(span, new_r, old_r))