Reifying callers of Instance::resolve use resolve_for_fn_ptr.

Author: anp

src/librustc/ty/instance.rs

@@ -1,3 +1,4 @@
+// use crate::hir::CodegenFnAttrFlags;
 use crate::hir::Unsafety;
 use crate::hir::def::Namespace;
 use crate::hir::def_id::DefId;
@@ -304,12 +305,8 @@ impl<'tcx> Instance<'tcx> {
         substs: SubstsRef<'tcx>,
     ) -> Option<Instance<'tcx>> {
         debug!("resolve(def_id={:?}, substs={:?})", def_id, substs);
-        let fn_sig = tcx.fn_sig(def_id);
-        // let is_reify_shim = fn_sig.inputs().skip_binder().len() > 0
-        //     && fn_sig.input(0).skip_binder().is_param(0)
-        //     && tcx.generics_of(def_id).has_self;
-        if is_reify_shim {
-            debug!(" => fn ptr with implicit caller location");
+        if false {
+            debug!(" => fn pointer created for function with #[track_caller]");
             Some(Instance {
                 def: InstanceDef::ReifyShim(def_id),
                 substs,

src/librustc_codegen_ssa/callee.rs

@@ -18,6 +18,23 @@ pub fn resolve_and_get_fn<'tcx, Cx: CodegenMethods<'tcx>>(
     )
 }
 
+pub fn resolve_and_get_fn_for_ptr<'tcx,
+    Cx: Backend<'tcx> + MiscMethods<'tcx> + TypeMethods<'tcx>
+>(
+    cx: &Cx,
+    def_id: DefId,
+    substs: SubstsRef<'tcx>,
+) -> Cx::Value {
+    cx.get_fn(
+        ty::Instance::resolve_for_fn_ptr(
+            cx.tcx(),
+            ty::ParamEnv::reveal_all(),
+            def_id,
+            substs
+        ).unwrap()
+    )
+}
+
 pub fn resolve_and_get_fn_for_vtable<'tcx,
     Cx: Backend<'tcx> + MiscMethods<'tcx> + TypeMethods<'tcx>
 >(

src/librustc_codegen_ssa/mir/rvalue.rs

@@ -190,7 +190,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                                     bug!("reifying a fn ptr that requires const arguments");
                                 }
                                 OperandValue::Immediate(
-                                    callee::resolve_and_get_fn(bx.cx(), def_id, substs))
+                                    callee::resolve_and_get_fn_for_ptr(bx.cx(), def_id, substs))
                             }
                             _ => {
                                 bug!("{} cannot be reified to a fn ptr", operand.layout.ty)

src/librustc_mir/monomorphize/collector.rs

@@ -721,10 +721,12 @@ fn visit_fn_use<'tcx>(
     output: &mut Vec<MonoItem<'tcx>>,
 ) {
     if let ty::FnDef(def_id, substs) = ty.kind {
-        let instance = ty::Instance::resolve(tcx,
-                                             ty::ParamEnv::reveal_all(),
-                                             def_id,
-                                             substs).unwrap();
+        let resolver = if is_direct_call {
+            ty::Instance::resolve
+        } else {
+            ty::Instance::resolve_for_fn_ptr
+        };
+        let instance = resolver(tcx, ty::ParamEnv::reveal_all(), def_id, substs).unwrap();
         visit_instance_use(tcx, instance, is_direct_call, output);
     }
 }

src/librustc_mir/shim.rs

@@ -45,7 +45,7 @@ fn make_shim<'tcx>(tcx: TyCtxt<'tcx>, instance: ty::InstanceDef<'tcx>) -> &'tcx
             build_call_shim(
                 tcx,
                 def_id,
-                Adjustment::DerefMove,
+                Adjustment::Identity, // TODO(anp) is this the right kind of adjustment?
                 CallKind::Direct(def_id),
                 None,
             )