Move code from all callers of vtable_methods into the function body

Author: oli-obk

src/librustc/traits/mod.rs

@@ -896,7 +896,7 @@ fn substitute_normalize_and_test_predicates<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx
 fn vtable_methods<'a, 'tcx>(
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
     trait_ref: ty::PolyTraitRef<'tcx>)
-    -> Lrc<Vec<Option<(DefId, &'tcx Substs<'tcx>)>>>
+    -> Lrc<Vec<Option<ty::Instance<'tcx>>>>
 {
     debug!("vtable_methods({:?})", trait_ref);
 
@@ -947,8 +947,12 @@ fn vtable_methods<'a, 'tcx>(
                     debug!("vtable_methods: predicates do not hold");
                     return None;
                 }
-
-                Some((def_id, substs))
+                Some(ty::Instance::resolve(
+                    tcx,
+                    ty::ParamEnv::reveal_all(),
+                    def_id,
+                    substs,
+                ).unwrap())
             })
         }).collect()
     )

src/librustc/ty/query/mod.rs

@@ -354,8 +354,10 @@ define_queries! { <'tcx>
     },
 
     Other {
+        /// List of methods on a vtable. The final vtable won't have holes where `None`, but will
+        /// simply skip methods that aren't object safe
         [] fn vtable_methods: vtable_methods_node(ty::PolyTraitRef<'tcx>)
-                            -> Lrc<Vec<Option<(DefId, &'tcx Substs<'tcx>)>>>,
+                            -> Lrc<Vec<Option<ty::Instance<'tcx>>>>,
     },
 
     Codegen {

src/librustc_codegen_llvm/meth.rs

@@ -97,8 +97,8 @@ pub fn get_vtable(
         let trait_ref = trait_ref.with_self_ty(tcx, ty);
         let methods = tcx.vtable_methods(trait_ref);
         let methods = methods.iter().cloned().map(|opt_mth| {
-            opt_mth.map_or(nullptr, |(def_id, substs)| {
-                callee::resolve_and_get_fn(cx, def_id, substs)
+            opt_mth.map_or(nullptr, |instance| {
+                callee::get_fn(cx, instance)
             })
         });
         components.extend(methods);

src/librustc_mir/interpret/traits.rs

@@ -66,8 +66,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
 
         if let Some(methods) = methods {
             for (i, method) in methods.iter().enumerate() {
-                if let Some((def_id, substs)) = *method {
-                    let instance = self.resolve(def_id, substs)?;
+                if let Some(instance) = *method {
                     let fn_ptr = self.memory.create_fn_alloc(instance);
                     let method_ptr = vtable.offset(ptr_size * (3 + i as u64), &self)?;
                     self.memory.write_ptr_sized(method_ptr, ptr_align, Scalar::Ptr(fn_ptr).into())?;

src/librustc_mir/monomorphize/collector.rs

@@ -914,11 +914,6 @@ fn create_mono_items_for_vtable_methods<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             // Walk all methods of the trait, including those of its supertraits
             let methods = tcx.vtable_methods(poly_trait_ref);
             let methods = methods.iter().cloned().filter_map(|method| method)
-                .map(|(def_id, substs)| ty::Instance::resolve(
-                        tcx,
-                        ty::ParamEnv::reveal_all(),
-                        def_id,
-                        substs).unwrap())
                 .filter(|&instance| should_monomorphize_locally(tcx, &instance))
                 .map(|instance| create_fn_mono_item(instance));
             output.extend(methods);