diff --git a/src/librustc/middle/subst.rs b/src/librustc/middle/subst.rs
index c581dda3164..c4121d830db 100644
--- a/src/librustc/middle/subst.rs
+++ b/src/librustc/middle/subst.rs
@@ -63,6 +63,14 @@ impl Substs {
         }
     }
 
+    pub fn trans_empty() -> Substs {
+        Substs {
+            self_ty: None,
+            tps: Vec::new(),
+            regions: ErasedRegions
+        }
+    }
+
     pub fn is_noop(&self) -> bool {
         let regions_is_noop = match self.regions {
             ErasedRegions => false, // may be used to canonicalize
diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs
index 23156882c7c..96d059c2f84 100644
--- a/src/librustc/middle/trans/base.rs
+++ b/src/librustc/middle/trans/base.rs
@@ -1098,11 +1098,11 @@ pub fn new_fn_ctxt<'a>(ccx: &'a CrateContext,
                        id: ast::NodeId,
                        has_env: bool,
                        output_type: ty::t,
-                       param_substs: Option<&'a param_substs>,
+                       param_substs: &'a param_substs,
                        sp: Option<Span>,
                        block_arena: &'a TypedArena<Block<'a>>)
                        -> FunctionContext<'a> {
-    for p in param_substs.iter() { p.validate(); }
+    param_substs.validate();
 
     debug!("new_fn_ctxt(path={}, id={}, param_substs={})",
            if id == -1 {
@@ -1110,7 +1110,7 @@ pub fn new_fn_ctxt<'a>(ccx: &'a CrateContext,
            } else {
                ccx.tcx.map.path_to_str(id).to_string()
            },
-           id, param_substs.map(|s| s.repr(ccx.tcx())));
+           id, param_substs.repr(ccx.tcx()));
 
     let substd_output_type = output_type.substp(ccx.tcx(), param_substs);
     let uses_outptr = type_of::return_uses_outptr(ccx, substd_output_type);
@@ -1303,7 +1303,7 @@ pub fn trans_closure(ccx: &CrateContext,
                      decl: &ast::FnDecl,
                      body: &ast::Block,
                      llfndecl: ValueRef,
-                     param_substs: Option<&param_substs>,
+                     param_substs: &param_substs,
                      id: ast::NodeId,
                      _attributes: &[ast::Attribute],
                      output_type: ty::t,
@@ -1314,7 +1314,7 @@ pub fn trans_closure(ccx: &CrateContext,
     set_uwtable(llfndecl);
 
     debug!("trans_closure(..., param_substs={})",
-           param_substs.map(|s| s.repr(ccx.tcx())));
+           param_substs.repr(ccx.tcx()));
 
     let has_env = match ty::get(ty::node_id_to_type(ccx.tcx(), id)).sty {
         ty::ty_closure(_) => true,
@@ -1327,7 +1327,7 @@ pub fn trans_closure(ccx: &CrateContext,
                           id,
                           has_env,
                           output_type,
-                          param_substs.map(|s| &*s),
+                          param_substs,
                           Some(body.span),
                           &arena);
     init_function(&fcx, false, output_type);
@@ -1403,11 +1403,11 @@ pub fn trans_fn(ccx: &CrateContext,
                 decl: &ast::FnDecl,
                 body: &ast::Block,
                 llfndecl: ValueRef,
-                param_substs: Option<&param_substs>,
+                param_substs: &param_substs,
                 id: ast::NodeId,
                 attrs: &[ast::Attribute]) {
     let _s = StatRecorder::new(ccx, ccx.tcx.map.path_to_str(id).to_string());
-    debug!("trans_fn(param_substs={})", param_substs.map(|s| s.repr(ccx.tcx())));
+    debug!("trans_fn(param_substs={})", param_substs.repr(ccx.tcx()));
     let _icx = push_ctxt("trans_fn");
     let output_type = ty::ty_fn_ret(ty::node_id_to_type(ccx.tcx(), id));
     trans_closure(ccx, decl, body, llfndecl,
@@ -1419,7 +1419,7 @@ pub fn trans_enum_variant(ccx: &CrateContext,
                           variant: &ast::Variant,
                           _args: &[ast::VariantArg],
                           disr: ty::Disr,
-                          param_substs: Option<&param_substs>,
+                          param_substs: &param_substs,
                           llfndecl: ValueRef) {
     let _icx = push_ctxt("trans_enum_variant");
 
@@ -1434,7 +1434,7 @@ pub fn trans_enum_variant(ccx: &CrateContext,
 pub fn trans_tuple_struct(ccx: &CrateContext,
                           _fields: &[ast::StructField],
                           ctor_id: ast::NodeId,
-                          param_substs: Option<&param_substs>,
+                          param_substs: &param_substs,
                           llfndecl: ValueRef) {
     let _icx = push_ctxt("trans_tuple_struct");
 
@@ -1449,7 +1449,7 @@ pub fn trans_tuple_struct(ccx: &CrateContext,
 fn trans_enum_variant_or_tuple_like_struct(ccx: &CrateContext,
                                            ctor_id: ast::NodeId,
                                            disr: ty::Disr,
-                                           param_substs: Option<&param_substs>,
+                                           param_substs: &param_substs,
                                            llfndecl: ValueRef) {
     let ctor_ty = ty::node_id_to_type(ccx.tcx(), ctor_id);
     let ctor_ty = ctor_ty.substp(ccx.tcx(), param_substs);
@@ -1464,7 +1464,7 @@ fn trans_enum_variant_or_tuple_like_struct(ccx: &CrateContext,
 
     let arena = TypedArena::new();
     let fcx = new_fn_ctxt(ccx, llfndecl, ctor_id, false, result_ty,
-                          param_substs.map(|s| &*s), None, &arena);
+                          param_substs, None, &arena);
     init_function(&fcx, false, result_ty);
 
     let arg_tys = ty::ty_fn_args(ctor_ty);
@@ -1500,7 +1500,7 @@ fn trans_enum_def(ccx: &CrateContext, enum_definition: &ast::EnumDef,
             ast::TupleVariantKind(ref args) if args.len() > 0 => {
                 let llfn = get_item_val(ccx, variant.node.id);
                 trans_enum_variant(ccx, id, variant, args.as_slice(),
-                                   disr_val, None, llfn);
+                                   disr_val, &param_substs::empty(), llfn);
             }
             ast::TupleVariantKind(_) => {
                 // Nothing to do.
@@ -1587,7 +1587,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) {
                      decl,
                      body,
                      llfn,
-                     None,
+                     &param_substs::empty(),
                      item.id,
                      item.attrs.as_slice());
         } else {
@@ -1660,7 +1660,7 @@ pub fn trans_struct_def(ccx: &CrateContext, struct_def: @ast::StructDef) {
         Some(ctor_id) if struct_def.fields.len() > 0 => {
             let llfndecl = get_item_val(ccx, ctor_id);
             trans_tuple_struct(ccx, struct_def.fields.as_slice(),
-                               ctor_id, None, llfndecl);
+                               ctor_id, &param_substs::empty(), llfndecl);
         }
         Some(_) | None => {}
     }
diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs
index 005fc446888..8ee777278fe 100644
--- a/src/librustc/middle/trans/callee.rs
+++ b/src/librustc/middle/trans/callee.rs
@@ -187,7 +187,7 @@ fn trans_fn_ref_with_vtables_to_callee<'a>(bcx: &'a Block<'a>,
                                            def_id: ast::DefId,
                                            ref_id: ast::NodeId,
                                            substs: subst::Substs,
-                                           vtables: Option<typeck::vtable_res>)
+                                           vtables: typeck::vtable_res)
                                            -> Callee<'a> {
     Callee {bcx: bcx,
             data: Fn(trans_fn_ref_with_vtables(bcx, def_id, ExprId(ref_id),
@@ -198,8 +198,9 @@ fn resolve_default_method_vtables(bcx: &Block,
                                   impl_id: ast::DefId,
                                   method: &ty::Method,
                                   substs: &subst::Substs,
-                                  impl_vtables: Option<typeck::vtable_res>)
-                          -> (typeck::vtable_res, typeck::vtable_param_res) {
+                                  impl_vtables: typeck::vtable_res)
+                          -> (typeck::vtable_res, typeck::vtable_param_res)
+{
 
     // Get the vtables that the impl implements the trait at
     let impl_res = ty::lookup_impl_vtables(bcx.tcx(), impl_id);
@@ -213,27 +214,15 @@ fn resolve_default_method_vtables(bcx: &Block,
     };
 
     let mut param_vtables = resolve_vtables_under_param_substs(
-        bcx.tcx(), Some(&param_substs), impl_res.trait_vtables.as_slice());
+        bcx.tcx(), &param_substs, impl_res.trait_vtables.as_slice());
 
     // Now we pull any vtables for parameters on the actual method.
     let num_method_vtables = method.generics.type_param_defs().len();
-    match impl_vtables {
-        Some(ref vtables) => {
-            let num_impl_type_parameters =
-                vtables.len() - num_method_vtables;
-            param_vtables.push_all(vtables.tailn(num_impl_type_parameters))
-        },
-        None => {
-            param_vtables.extend(range(0, num_method_vtables).map(
-                |_| -> typeck::vtable_param_res {
-                    Vec::new()
-                }
-            ))
-        }
-    }
+    let num_impl_type_parameters = impl_vtables.len() - num_method_vtables;
+    param_vtables.push_all(impl_vtables.tailn(num_impl_type_parameters));
 
     let self_vtables = resolve_param_vtables_under_param_substs(
-        bcx.tcx(), Some(&param_substs), impl_res.self_vtables.as_slice());
+        bcx.tcx(), &param_substs, impl_res.self_vtables.as_slice());
 
     (param_vtables, self_vtables)
 }
@@ -244,7 +233,7 @@ pub fn trans_fn_ref_with_vtables(
         def_id: ast::DefId,   // def id of fn
         node: ExprOrMethodCall,  // node id of use of fn; may be zero if N/A
         substs: subst::Substs, // values for fn's ty params
-        vtables: Option<typeck::vtable_res>) // vtables for the call
+        vtables: typeck::vtable_res) // vtables for the call
      -> ValueRef {
     /*!
      * Translates a reference to a fn/method item, monomorphizing and
@@ -336,7 +325,7 @@ pub fn trans_fn_ref_with_vtables(
                    self_vtables.repr(tcx), param_vtables.repr(tcx));
 
             (true, source_id,
-             new_substs, Some(self_vtables), Some(param_vtables))
+             new_substs, Some(self_vtables), param_vtables)
         }
     };
 
@@ -507,7 +496,7 @@ pub fn trans_lang_call<'a>(
                                                                     did,
                                                                     0,
                                                                     subst::Substs::empty(),
-                                                                    None)
+                                                                    Vec::new())
                              },
                              ArgVals(args),
                              dest)
diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs
index b5fd37d815f..f956b58031c 100644
--- a/src/librustc/middle/trans/closure.rs
+++ b/src/librustc/middle/trans/closure.rs
@@ -421,7 +421,9 @@ pub fn get_wrapper_for_bare_fn(ccx: &CrateContext,
     let _icx = push_ctxt("closure::get_wrapper_for_bare_fn");
 
     let arena = TypedArena::new();
-    let fcx = new_fn_ctxt(ccx, llfn, -1, true, f.sig.output, None, None, &arena);
+    let empty_param_substs = param_substs::empty();
+    let fcx = new_fn_ctxt(ccx, llfn, -1, true, f.sig.output,
+                          &empty_param_substs, None, &arena);
     init_function(&fcx, true, f.sig.output);
     let bcx = fcx.entry_bcx.borrow().clone().unwrap();
 
diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs
index dbb6f3fe1cf..1bcf47531dd 100644
--- a/src/librustc/middle/trans/common.rs
+++ b/src/librustc/middle/trans/common.rs
@@ -180,11 +180,19 @@ pub type ExternMap = HashMap<String, ValueRef>;
 // will only be set in the case of default methods.
 pub struct param_substs {
     pub substs: subst::Substs,
-    pub vtables: Option<typeck::vtable_res>,
+    pub vtables: typeck::vtable_res,
     pub self_vtables: Option<typeck::vtable_param_res>
 }
 
 impl param_substs {
+    pub fn empty() -> param_substs {
+        param_substs {
+            substs: subst::Substs::trans_empty(),
+            vtables: Vec::new(),
+            self_vtables: None
+        }
+    }
+
     pub fn validate(&self) {
         for t in self.substs.tps.iter() {
             assert!(!ty::type_needs_infer(*t));
@@ -206,21 +214,13 @@ impl Repr for param_substs {
 }
 
 pub trait SubstP {
-    fn substp(&self, tcx: &ty::ctxt, param_substs: Option<&param_substs>)
+    fn substp(&self, tcx: &ty::ctxt, param_substs: &param_substs)
               -> Self;
 }
 
 impl<T:Subst+Clone> SubstP for T {
-    fn substp(&self, tcx: &ty::ctxt, param_substs: Option<&param_substs>)
-              -> T {
-        match param_substs {
-            Some(substs) => {
-                self.subst(tcx, &substs.substs)
-            }
-            None => {
-                (*self).clone()
-            }
-        }
+    fn substp(&self, tcx: &ty::ctxt, substs: &param_substs) -> T {
+        self.subst(tcx, &substs.substs)
     }
 }
 
@@ -281,7 +281,7 @@ pub struct FunctionContext<'a> {
 
     // If this function is being monomorphized, this contains the type
     // substitutions used.
-    pub param_substs: Option<&'a param_substs>,
+    pub param_substs: &'a param_substs,
 
     // The source span and nesting context where this function comes from, for
     // error reporting and symbol generation.
@@ -697,16 +697,7 @@ pub fn is_null(val: ValueRef) -> bool {
 }
 
 pub fn monomorphize_type(bcx: &Block, t: ty::t) -> ty::t {
-    match bcx.fcx.param_substs {
-        Some(ref substs) => {
-            t.subst(bcx.tcx(), &substs.substs)
-        }
-        _ => {
-            assert!(!ty::type_has_params(t));
-            assert!(!ty::type_has_self(t));
-            t
-        }
-    }
+    t.subst(bcx.tcx(), &bcx.fcx.param_substs.substs)
 }
 
 pub fn node_id_type(bcx: &Block, id: ast::NodeId) -> ty::t {
@@ -759,10 +750,10 @@ pub fn node_id_substs(bcx: &Block,
 }
 
 pub fn node_vtables(bcx: &Block, id: typeck::MethodCall)
-                 -> Option<typeck::vtable_res> {
+                 -> typeck::vtable_res {
     bcx.tcx().vtable_map.borrow().find(&id).map(|vts| {
         resolve_vtables_in_fn_ctxt(bcx.fcx, vts.as_slice())
-    })
+    }).unwrap_or_else(|| Vec::new())
 }
 
 // Apply the typaram substitutions in the FunctionContext to some
@@ -776,7 +767,7 @@ pub fn resolve_vtables_in_fn_ctxt(fcx: &FunctionContext,
 }
 
 pub fn resolve_vtables_under_param_substs(tcx: &ty::ctxt,
-                                          param_substs: Option<&param_substs>,
+                                          param_substs: &param_substs,
                                           vts: &[typeck::vtable_param_res])
                                           -> typeck::vtable_res {
     vts.iter().map(|ds| {
@@ -788,7 +779,7 @@ pub fn resolve_vtables_under_param_substs(tcx: &ty::ctxt,
 
 pub fn resolve_param_vtables_under_param_substs(
     tcx: &ty::ctxt,
-    param_substs: Option<&param_substs>,
+    param_substs: &param_substs,
     ds: &[typeck::vtable_origin])
     -> typeck::vtable_param_res {
     ds.iter().map(|d| {
@@ -801,7 +792,7 @@ pub fn resolve_param_vtables_under_param_substs(
 
 
 pub fn resolve_vtable_under_param_substs(tcx: &ty::ctxt,
-                                         param_substs: Option<&param_substs>,
+                                         param_substs: &param_substs,
                                          vt: &typeck::vtable_origin)
                                          -> typeck::vtable_origin {
     match *vt {
@@ -812,16 +803,7 @@ pub fn resolve_vtable_under_param_substs(tcx: &ty::ctxt,
                 resolve_vtables_under_param_substs(tcx, param_substs, sub.as_slice()))
         }
         typeck::vtable_param(n_param, n_bound) => {
-            match param_substs {
-                Some(substs) => {
-                    find_vtable(tcx, substs, n_param, n_bound)
-                }
-                _ => {
-                    tcx.sess.bug(format!(
-                        "resolve_vtable_under_param_substs: asked to lookup \
-                         but no vtables in the fn_ctxt!").as_slice())
-                }
-            }
+            find_vtable(tcx, param_substs, n_param, n_bound)
         }
     }
 }
@@ -837,9 +819,7 @@ pub fn find_vtable(tcx: &ty::ctxt,
     let param_bounds = match n_param {
         typeck::param_self => ps.self_vtables.as_ref().expect("self vtables missing"),
         typeck::param_numbered(n) => {
-            let tables = ps.vtables.as_ref()
-                .expect("vtables missing where they are needed");
-            tables.get(n)
+            ps.vtables.get(n)
         }
     };
     param_bounds.get(n_bound).clone()
diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs
index e21c8f63d09..b709fa52cf7 100644
--- a/src/librustc/middle/trans/debuginfo.rs
+++ b/src/librustc/middle/trans/debuginfo.rs
@@ -621,7 +621,7 @@ pub fn start_emitting_source_locations(fcx: &FunctionContext) {
 /// indicates why no debuginfo should be created for the function.
 pub fn create_function_debug_context(cx: &CrateContext,
                                      fn_ast_id: ast::NodeId,
-                                     param_substs: Option<&param_substs>,
+                                     param_substs: &param_substs,
                                      llfn: ValueRef) -> FunctionDebugContext {
     if cx.sess().opts.debuginfo == NoDebugInfo {
         return FunctionDebugContext { repr: DebugInfoDisabled };
@@ -788,7 +788,7 @@ pub fn create_function_debug_context(cx: &CrateContext,
     fn get_function_signature(cx: &CrateContext,
                               fn_ast_id: ast::NodeId,
                               fn_decl: &ast::FnDecl,
-                              param_substs: Option<&param_substs>,
+                              param_substs: &param_substs,
                               error_span: Span) -> DIArray {
         if cx.sess().opts.debuginfo == LimitedDebugInfo {
             return create_DIArray(DIB(cx), []);
@@ -823,14 +823,11 @@ pub fn create_function_debug_context(cx: &CrateContext,
 
     fn get_template_parameters(cx: &CrateContext,
                                generics: &ast::Generics,
-                               param_substs: Option<&param_substs>,
+                               param_substs: &param_substs,
                                file_metadata: DIFile,
                                name_to_append_suffix_to: &mut String)
                                -> DIArray {
-        let self_type = match param_substs {
-            Some(param_substs) => param_substs.substs.self_ty,
-            _ => None
-        };
+        let self_type = param_substs.substs.self_ty;
 
         // Only true for static default methods:
         let has_self_type = self_type.is_some();
@@ -884,13 +881,7 @@ pub fn create_function_debug_context(cx: &CrateContext,
         }
 
         // Handle other generic parameters
-        let actual_types = match param_substs {
-            Some(param_substs) => &param_substs.substs.tps,
-            None => {
-                return create_DIArray(DIB(cx), template_params.as_slice());
-            }
-        };
-
+        let actual_types = &param_substs.substs.tps;
         for (index, &ast::TyParam{ ident: ident, .. }) in generics.ty_params.iter().enumerate() {
             let actual_type = *actual_types.get(index);
             // Add actual type name to <...> clause of function name
diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs
index 96fb8ac0e98..6f217d83a62 100644
--- a/src/librustc/middle/trans/foreign.rs
+++ b/src/librustc/middle/trans/foreign.rs
@@ -570,7 +570,7 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext,
 
         let llfn = base::decl_internal_rust_fn(ccx, t, ps.as_slice());
         base::set_llvm_fn_attrs(attrs, llfn);
-        base::trans_fn(ccx, decl, body, llfn, None, id, []);
+        base::trans_fn(ccx, decl, body, llfn, &param_substs::empty(), id, []);
         llfn
     }
 
diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs
index 7d05b352807..96aa7267d23 100644
--- a/src/librustc/middle/trans/glue.rs
+++ b/src/librustc/middle/trans/glue.rs
@@ -479,7 +479,9 @@ fn make_generic_glue(ccx: &CrateContext,
     let _s = StatRecorder::new(ccx, glue_name);
 
     let arena = TypedArena::new();
-    let fcx = new_fn_ctxt(ccx, llfn, -1, false, ty::mk_nil(), None, None, &arena);
+    let empty_param_substs = param_substs::empty();
+    let fcx = new_fn_ctxt(ccx, llfn, -1, false, ty::mk_nil(),
+                          &empty_param_substs, None, &arena);
 
     init_function(&fcx, false, ty::mk_nil());
 
diff --git a/src/librustc/middle/trans/inline.rs b/src/librustc/middle/trans/inline.rs
index fa4a62319db..c14ff7a49ea 100644
--- a/src/librustc/middle/trans/inline.rs
+++ b/src/librustc/middle/trans/inline.rs
@@ -131,7 +131,8 @@ pub fn maybe_instantiate_inline(ccx: &CrateContext, fn_id: ast::DefId)
 
           if num_type_params == 0 {
               let llfn = get_item_val(ccx, mth.id);
-              trans_fn(ccx, mth.decl, mth.body, llfn, None, mth.id, []);
+              trans_fn(ccx, mth.decl, mth.body, llfn,
+                       &param_substs::empty(), mth.id, []);
           }
           local_def(mth.id)
         }
diff --git a/src/librustc/middle/trans/intrinsic.rs b/src/librustc/middle/trans/intrinsic.rs
index eea8ce44a9d..0719288bb02 100644
--- a/src/librustc/middle/trans/intrinsic.rs
+++ b/src/librustc/middle/trans/intrinsic.rs
@@ -192,7 +192,7 @@ pub fn trans_intrinsic(ccx: &CrateContext,
 
     let arena = TypedArena::new();
     let fcx = new_fn_ctxt(ccx, decl, item.id, false, output_type,
-                          Some(&*substs), Some(item.span), &arena);
+                          substs, Some(item.span), &arena);
     init_function(&fcx, true, output_type);
 
     set_always_inline(fcx.llfn);
diff --git a/src/librustc/middle/trans/meth.rs b/src/librustc/middle/trans/meth.rs
index fe251ad88b0..2beb3be3d27 100644
--- a/src/librustc/middle/trans/meth.rs
+++ b/src/librustc/middle/trans/meth.rs
@@ -68,7 +68,7 @@ pub fn trans_impl(ccx: &CrateContext,
         if method.generics.ty_params.len() == 0u {
             let llfn = get_item_val(ccx, method.id);
             trans_fn(ccx, method.decl, method.body,
-                     llfn, None, method.id, []);
+                     llfn, &param_substs::empty(), method.id, []);
         } else {
             let mut v = TransItemVisitor{ ccx: ccx };
             visit::walk_method_helper(&mut v, *method, ());
@@ -110,19 +110,13 @@ pub fn trans_method_callee<'a>(
             param_num: p,
             bound_num: b
         }) => {
-            match bcx.fcx.param_substs {
-                Some(substs) => {
-                    ty::populate_implementations_for_trait_if_necessary(
-                        bcx.tcx(),
-                        trait_id);
+            ty::populate_implementations_for_trait_if_necessary(
+                bcx.tcx(),
+                trait_id);
 
-                    let vtbl = find_vtable(bcx.tcx(), substs, p, b);
-                    trans_monomorphized_callee(bcx, method_call,
-                                               trait_id, off, vtbl)
-                }
-                // how to get rid of this?
-                None => fail!("trans_method_callee: missing param_substs")
-            }
+            let vtbl = find_vtable(bcx.tcx(), bcx.fcx.param_substs, p, b);
+            trans_monomorphized_callee(bcx, method_call,
+                                       trait_id, off, vtbl)
         }
 
         typeck::MethodObject(ref mt) => {
@@ -209,7 +203,7 @@ pub fn trans_static_method_callee(bcx: &Block,
 
             let llfn = trans_fn_ref_with_vtables(bcx, mth_id, ExprId(expr_id),
                                                  callee_substs,
-                                                 Some(callee_origins));
+                                                 callee_origins);
 
             let callee_ty = node_id_type(bcx, expr_id);
             let llty = type_of_fn_from_ty(ccx, callee_ty).ptr_to();
@@ -265,7 +259,7 @@ fn trans_monomorphized_callee<'a>(bcx: &'a Block<'a>,
                                                mth_id,
                                                MethodCall(method_call),
                                                callee_substs,
-                                               Some(callee_origins));
+                                               callee_origins);
 
           Callee { bcx: bcx, data: Fn(llfn) }
       }
@@ -322,19 +316,9 @@ fn combine_impl_and_methods_tps(bcx: &Block,
         MethodCall(method_call) => method_call
     };
     let mut vtables = rcvr_origins;
-    match node_vtables(bcx, vtable_key) {
-        Some(vt) => {
-            let start = vt.len() - n_m_tps;
-            vtables.extend(vt.move_iter().skip(start));
-        }
-        None => {
-            vtables.extend(range(0, n_m_tps).map(
-                |_| -> typeck::vtable_param_res {
-                    Vec::new()
-                }
-            ));
-        }
-    }
+    let vt = node_vtables(bcx, vtable_key);
+    let start = vt.len() - n_m_tps;
+    vtables.extend(vt.move_iter().skip(start));
 
     let ty_substs = subst::Substs {
         tps: tps,
@@ -525,7 +509,7 @@ fn emit_vtable_methods(bcx: &Block,
             C_null(Type::nil(ccx).ptr_to())
         } else {
             trans_fn_ref_with_vtables(bcx, m_id, ExprId(0),
-                                      substs.clone(), Some(vtables.clone()))
+                                      substs.clone(), vtables.clone())
         }
     }).collect()
 }
diff --git a/src/librustc/middle/trans/monomorphize.rs b/src/librustc/middle/trans/monomorphize.rs
index 0b26612cb38..9559c0909a6 100644
--- a/src/librustc/middle/trans/monomorphize.rs
+++ b/src/librustc/middle/trans/monomorphize.rs
@@ -32,7 +32,7 @@ use std::hash::{sip, Hash};
 pub fn monomorphic_fn(ccx: &CrateContext,
                       fn_id: ast::DefId,
                       real_substs: &subst::Substs,
-                      vtables: Option<typeck::vtable_res>,
+                      vtables: typeck::vtable_res,
                       self_vtables: Option<typeck::vtable_param_res>,
                       ref_id: Option<ast::NodeId>)
     -> (ValueRef, bool) {
@@ -206,7 +206,7 @@ pub fn monomorphic_fn(ccx: &CrateContext,
               } => {
                   let d = mk_lldecl();
                   set_llvm_fn_attrs(i.attrs.as_slice(), d);
-                  trans_fn(ccx, decl, body, d, Some(&psubsts), fn_id.node, []);
+                  trans_fn(ccx, decl, body, d, &psubsts, fn_id.node, []);
                   d
               }
               _ => {
@@ -238,7 +238,7 @@ pub fn monomorphic_fn(ccx: &CrateContext,
                                        v,
                                        args.as_slice(),
                                        this_tv.disr_val,
-                                       Some(&psubsts),
+                                       &psubsts,
                                        d);
                 }
                 ast::StructVariantKind(_) =>
@@ -249,7 +249,7 @@ pub fn monomorphic_fn(ccx: &CrateContext,
         ast_map::NodeMethod(mth) => {
             let d = mk_lldecl();
             set_llvm_fn_attrs(mth.attrs.as_slice(), d);
-            trans_fn(ccx, mth.decl, mth.body, d, Some(&psubsts), mth.id, []);
+            trans_fn(ccx, mth.decl, mth.body, d, &psubsts, mth.id, []);
             d
         }
         ast_map::NodeTraitMethod(method) => {
@@ -257,7 +257,7 @@ pub fn monomorphic_fn(ccx: &CrateContext,
                 ast::Provided(mth) => {
                     let d = mk_lldecl();
                     set_llvm_fn_attrs(mth.attrs.as_slice(), d);
-                    trans_fn(ccx, mth.decl, mth.body, d, Some(&psubsts), mth.id, []);
+                    trans_fn(ccx, mth.decl, mth.body, d, &psubsts, mth.id, []);
                     d
                 }
                 _ => {
@@ -273,7 +273,7 @@ pub fn monomorphic_fn(ccx: &CrateContext,
                                      struct_def.fields.as_slice(),
                                      struct_def.ctor_id.expect("ast-mapped tuple struct \
                                                                 didn't have a ctor id"),
-                                     Some(&psubsts),
+                                     &psubsts,
                                      d);
             d
         }
diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs
index a4f583cdb82..3b469a1d110 100644
--- a/src/librustc/middle/trans/reflect.rs
+++ b/src/librustc/middle/trans/reflect.rs
@@ -297,8 +297,10 @@ impl<'a, 'b> Reflector<'a, 'b> {
                                                     fn_ty,
                                                     sym.as_slice());
                 let arena = TypedArena::new();
+                let empty_param_substs = param_substs::empty();
                 let fcx = new_fn_ctxt(ccx, llfdecl, -1, false,
-                                      ty::mk_u64(), None, None, &arena);
+                                      ty::mk_u64(), &empty_param_substs,
+                                      None, &arena);
                 init_function(&fcx, false, ty::mk_u64());
 
                 let arg = unsafe {
diff --git a/src/librustc/middle/typeck/check/vtable.rs b/src/librustc/middle/typeck/check/vtable.rs
index 2bbbf3102ea..0665ae651f0 100644
--- a/src/librustc/middle/typeck/check/vtable.rs
+++ b/src/librustc/middle/typeck/check/vtable.rs
@@ -74,11 +74,6 @@ impl<'a> VtableContext<'a> {
     pub fn tcx(&self) -> &'a ty::ctxt { self.infcx.tcx }
 }
 
-fn has_trait_bounds(type_param_defs: &[ty::TypeParameterDef]) -> bool {
-    type_param_defs.iter().any(
-        |type_param_def| !type_param_def.bounds.trait_bounds.is_empty())
-}
-
 fn lookup_vtables(vcx: &VtableContext,
                   span: Span,
                   type_param_defs: &[ty::TypeParameterDef],
@@ -636,16 +631,14 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: &FnCtxt, is_early: bool) {
             let item_ty = ty::lookup_item_type(cx.tcx, did);
             debug!("early resolve expr: def {:?} {:?}, {:?}, {}", ex.id, did, def,
                    fcx.infcx().ty_to_str(item_ty.ty));
-            if has_trait_bounds(item_ty.generics.type_param_defs()) {
-                debug!("early_resolve_expr: looking up vtables for type params {}",
-                       item_ty.generics.type_param_defs().repr(fcx.tcx()));
-                let vcx = fcx.vtable_context();
-                let vtbls = lookup_vtables(&vcx, ex.span,
-                                           item_ty.generics.type_param_defs(),
-                                           &item_substs.substs, is_early);
-                if !is_early {
-                    insert_vtables(fcx, MethodCall::expr(ex.id), vtbls);
-                }
+            debug!("early_resolve_expr: looking up vtables for type params {}",
+                   item_ty.generics.type_param_defs().repr(fcx.tcx()));
+            let vcx = fcx.vtable_context();
+            let vtbls = lookup_vtables(&vcx, ex.span,
+                                       item_ty.generics.type_param_defs(),
+                                       &item_substs.substs, is_early);
+            if !is_early {
+                insert_vtables(fcx, MethodCall::expr(ex.id), vtbls);
             }
         });
       }
@@ -658,19 +651,17 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: &FnCtxt, is_early: bool) {
       ast::ExprMethodCall(_, _, _) => {
         match fcx.inh.method_map.borrow().find(&MethodCall::expr(ex.id)) {
           Some(method) => {
-            debug!("vtable resolution on parameter bounds for method call {}",
-                   ex.repr(fcx.tcx()));
-            let type_param_defs = ty::method_call_type_param_defs(cx.tcx, method.origin);
-            if has_trait_bounds(type_param_defs.as_slice()) {
-                let substs = fcx.method_ty_substs(ex.id);
-                let vcx = fcx.vtable_context();
-                let vtbls = lookup_vtables(&vcx, ex.span,
-                                           type_param_defs.as_slice(),
-                                           &substs, is_early);
-                if !is_early {
-                    insert_vtables(fcx, MethodCall::expr(ex.id), vtbls);
-                }
-            }
+              debug!("vtable resolution on parameter bounds for method call {}",
+                     ex.repr(fcx.tcx()));
+              let type_param_defs = ty::method_call_type_param_defs(cx.tcx, method.origin);
+              let substs = fcx.method_ty_substs(ex.id);
+              let vcx = fcx.vtable_context();
+              let vtbls = lookup_vtables(&vcx, ex.span,
+                                         type_param_defs.as_slice(),
+                                         &substs, is_early);
+              if !is_early {
+                  insert_vtables(fcx, MethodCall::expr(ex.id), vtbls);
+              }
           }
           None => {}
         }
@@ -696,15 +687,13 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: &FnCtxt, is_early: bool) {
                                        ex.repr(fcx.tcx()));
                                 let type_param_defs =
                                     ty::method_call_type_param_defs(cx.tcx, method.origin);
-                                if has_trait_bounds(type_param_defs.deref().as_slice()) {
-                                    let vcx = fcx.vtable_context();
-                                    let vtbls = lookup_vtables(&vcx, ex.span,
-                                                               type_param_defs.deref()
-                                                               .as_slice(),
-                                                               &method.substs, is_early);
-                                    if !is_early {
-                                        insert_vtables(fcx, method_call, vtbls);
-                                    }
+                                let vcx = fcx.vtable_context();
+                                let vtbls = lookup_vtables(&vcx, ex.span,
+                                                           type_param_defs.deref()
+                                                           .as_slice(),
+                                                           &method.substs, is_early);
+                                if !is_early {
+                                    insert_vtables(fcx, method_call, vtbls);
                                 }
                             }
                             None => {}
@@ -800,23 +789,19 @@ pub fn resolve_impl(tcx: &ty::ctxt,
 /// Resolve vtables for a method call after typeck has finished.
 /// Used by trans to monomorphize artificial method callees (e.g. drop).
 pub fn trans_resolve_method(tcx: &ty::ctxt, id: ast::NodeId,
-                            substs: &subst::Substs) -> Option<vtable_res> {
+                            substs: &subst::Substs) -> vtable_res {
     let generics = ty::lookup_item_type(tcx, ast_util::local_def(id)).generics;
     let type_param_defs = &*generics.type_param_defs;
-    if has_trait_bounds(type_param_defs.as_slice()) {
-        let vcx = VtableContext {
-            infcx: &infer::new_infer_ctxt(tcx),
-            param_env: &ty::construct_parameter_environment(tcx, None, [], [], [], [], id)
-        };
+    let vcx = VtableContext {
+        infcx: &infer::new_infer_ctxt(tcx),
+        param_env: &ty::construct_parameter_environment(tcx, None, [], [], [], [], id)
+    };
 
-        Some(lookup_vtables(&vcx,
-                            tcx.map.span(id),
-                            type_param_defs.as_slice(),
-                            substs,
-                            false))
-    } else {
-        None
-    }
+    lookup_vtables(&vcx,
+                   tcx.map.span(id),
+                   type_param_defs.as_slice(),
+                   substs,
+                   false)
 }
 
 impl<'a, 'b> visit::Visitor<()> for &'a FnCtxt<'b> {