Refactor to create InstanceDef::fn_sig

Author: maurer

compiler/rustc_middle/src/ty/instance.rs

@@ -321,6 +321,27 @@ impl<'tcx> InstanceDef<'tcx> {
             | InstanceDef::VTableShim(..) => true,
         }
     }
+
+    /// Computes the signature of the InstanceDef, possibly with adjustments based on the kind of
+    /// shim.
+    pub fn fn_sig(&self, tcx: TyCtxt<'tcx>) -> EarlyBinder<ty::PolyFnSig<'tcx>> {
+        tcx.fn_sig(self.def_id()).map_bound(|sig| {
+            sig.map_bound(|mut sig| {
+                if let InstanceDef::VTableShim(..) = self {
+                    // Modify fn(self, ...) to fn(self: *mut Self, ...)
+                    let mut inputs_and_output = sig.inputs_and_output.to_vec();
+                    let self_arg = &mut inputs_and_output[0];
+                    debug_assert!(
+                        tcx.generics_of(self.def_id()).has_self
+                            && *self_arg == tcx.types.self_param
+                    );
+                    *self_arg = Ty::new_mut_ptr(tcx, *self_arg);
+                    sig.inputs_and_output = tcx.mk_type_list(&inputs_and_output);
+                }
+                sig
+            })
+        })
+    }
 }
 
 fn fmt_instance_def(f: &mut fmt::Formatter<'_>, instance_def: &InstanceDef<'_>) -> fmt::Result {

compiler/rustc_mir_transform/src/shim.rs

@@ -736,7 +736,7 @@ fn build_call_shim<'tcx>(
     };
 
     let def_id = instance.def_id();
-    let sig = tcx.fn_sig(def_id);
+    let sig = instance.fn_sig(tcx);
     let sig = sig.map_bound(|sig| tcx.instantiate_bound_regions_with_erased(sig));
 
     assert_eq!(sig_args.is_some(), !instance.has_polymorphic_mir_body());
@@ -773,17 +773,6 @@ fn build_call_shim<'tcx>(
         sig.inputs_and_output = tcx.mk_type_list(&inputs_and_output);
     }
 
-    // FIXME(eddyb) avoid having this snippet both here and in
-    // `Instance::fn_sig` (introduce `InstanceDef::fn_sig`?).
-    if let ty::InstanceDef::VTableShim(..) = instance {
-        // Modify fn(self, ...) to fn(self: *mut Self, ...)
-        let mut inputs_and_output = sig.inputs_and_output.to_vec();
-        let self_arg = &mut inputs_and_output[0];
-        debug_assert!(tcx.generics_of(def_id).has_self && *self_arg == tcx.types.self_param);
-        *self_arg = Ty::new_mut_ptr(tcx, *self_arg);
-        sig.inputs_and_output = tcx.mk_type_list(&inputs_and_output);
-    }
-
     let span = tcx.def_span(def_id);
 
     debug!(?sig);

compiler/rustc_ty_utils/src/abi.rs

@@ -43,34 +43,19 @@ fn fn_sig_for_fn_abi<'tcx>(
 
     let ty = instance.ty(tcx, param_env);
     match *ty.kind() {
-        ty::FnDef(..) => {
+        ty::FnDef(def_id, args) => {
             // HACK(davidtwco,eddyb): This is a workaround for polymorphization considering
             // parameters unused if they show up in the signature, but not in the `mir::Body`
             // (i.e. due to being inside a projection that got normalized, see
             // `tests/ui/polymorphization/normalized_sig_types.rs`), and codegen not keeping
             // track of a polymorphization `ParamEnv` to allow normalizing later.
             //
             // We normalize the `fn_sig` again after instantiating at a later point.
-            let mut sig = match *ty.kind() {
-                ty::FnDef(def_id, args) => tcx
-                    .fn_sig(def_id)
-                    .map_bound(|fn_sig| {
-                        tcx.normalize_erasing_regions(tcx.param_env(def_id), fn_sig)
-                    })
-                    .instantiate(tcx, args),
-                _ => unreachable!(),
-            };
-
-            if let ty::InstanceDef::VTableShim(..) = instance.def {
-                // Modify `fn(self, ...)` to `fn(self: *mut Self, ...)`.
-                sig = sig.map_bound(|mut sig| {
-                    let mut inputs_and_output = sig.inputs_and_output.to_vec();
-                    inputs_and_output[0] = Ty::new_mut_ptr(tcx, inputs_and_output[0]);
-                    sig.inputs_and_output = tcx.mk_type_list(&inputs_and_output);
-                    sig
-                });
-            }
-            sig
+            instance
+                .def
+                .fn_sig(tcx)
+                .map_bound(|fn_sig| tcx.normalize_erasing_regions(tcx.param_env(def_id), fn_sig))
+                .instantiate(tcx, args)
         }
         ty::Closure(def_id, args) => {
             let sig = args.as_closure().sig();