add a builtin FnPtr trait

lcnr · lcnr · commit 04accf14959c · 2022-07-25T15:56:49.000+02:00
diff --git a/compiler/rustc_const_eval/src/interpret/terminator.rs b/compiler/rustc_const_eval/src/interpret/terminator.rs
@@ -370,6 +370,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             | ty::InstanceDef::FnPtrShim(..)
             | ty::InstanceDef::DropGlue(..)
             | ty::InstanceDef::CloneShim(..)
+            | ty::InstanceDef::FnPtrAddrShim(..)
             | ty::InstanceDef::Item(_) => {
                 // We need MIR for this fn
                 let Some((body, instance)) =
diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs
@@ -185,6 +185,9 @@ language_item_table! {
 
     Freeze,                  sym::freeze,              freeze_trait,               Target::Trait,          GenericRequirement::Exact(0);
 
+    FnPtrTrait,              sym::fn_ptr_trait,        fn_ptr_trait,               Target::Trait,          GenericRequirement::Exact(0);
+    FnPtrAddr,               sym::fn_ptr_addr,         fn_ptr_addr,                Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
+
     Drop,                    sym::drop,                drop_trait,                 Target::Trait,          GenericRequirement::None;
     Destruct,                sym::destruct,            destruct_trait,             Target::Trait,          GenericRequirement::None;
 
diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs
@@ -369,7 +369,8 @@ impl<'tcx> CodegenUnit<'tcx> {
                             | InstanceDef::Virtual(..)
                             | InstanceDef::ClosureOnceShim { .. }
                             | InstanceDef::DropGlue(..)
-                            | InstanceDef::CloneShim(..) => None,
+                            | InstanceDef::CloneShim(..)
+                            | InstanceDef::FnPtrAddrShim(..) => None,
                         }
                     }
                     MonoItem::Static(def_id) => def_id.as_local().map(Idx::index),
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
@@ -402,7 +402,8 @@ macro_rules! make_mir_visitor {
 
                         ty::InstanceDef::FnPtrShim(_def_id, ty) |
                         ty::InstanceDef::DropGlue(_def_id, Some(ty)) |
-                        ty::InstanceDef::CloneShim(_def_id, ty) => {
+                        ty::InstanceDef::CloneShim(_def_id, ty) |
+                        ty::InstanceDef::FnPtrAddrShim(_def_id, ty) => {
                             // FIXME(eddyb) use a better `TyContext` here.
                             self.visit_ty($(& $mutability)? *ty, TyContext::Location(location));
                         }
diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs
@@ -97,6 +97,13 @@ pub enum InstanceDef<'tcx> {
     ///
     /// The `DefId` is for `Clone::clone`, the `Ty` is the type `T` with the builtin `Clone` impl.
     CloneShim(DefId, Ty<'tcx>),
+
+    /// Compiler-generated `<T as FnPtr>::addr` implementation.
+    ///
+    /// Automatically generated for all potentially higher-ranked `fn(I) -> R` types.
+    ///
+    /// The `DefId` is for `FnPtr::Addr`, the `Ty` is the type `T`.
+    FnPtrAddrShim(DefId, Ty<'tcx>),
 }
 
 impl<'tcx> Instance<'tcx> {
@@ -152,7 +159,8 @@ impl<'tcx> InstanceDef<'tcx> {
             | InstanceDef::Intrinsic(def_id)
             | InstanceDef::ClosureOnceShim { call_once: def_id, track_caller: _ }
             | InstanceDef::DropGlue(def_id, _)
-            | InstanceDef::CloneShim(def_id, _) => def_id,
+            | InstanceDef::CloneShim(def_id, _)
+            | InstanceDef::FnPtrAddrShim(def_id, _) => def_id,
         }
     }
 
@@ -168,7 +176,8 @@ impl<'tcx> InstanceDef<'tcx> {
             | InstanceDef::Intrinsic(..)
             | InstanceDef::ClosureOnceShim { .. }
             | InstanceDef::DropGlue(..)
-            | InstanceDef::CloneShim(..) => None,
+            | InstanceDef::CloneShim(..)
+            | InstanceDef::FnPtrAddrShim(..) => None,
         }
     }
 
@@ -183,7 +192,8 @@ impl<'tcx> InstanceDef<'tcx> {
             | InstanceDef::Intrinsic(def_id)
             | InstanceDef::ClosureOnceShim { call_once: def_id, track_caller: _ }
             | InstanceDef::DropGlue(def_id, _)
-            | InstanceDef::CloneShim(def_id, _) => ty::WithOptConstParam::unknown(def_id),
+            | InstanceDef::CloneShim(def_id, _)
+            | InstanceDef::FnPtrAddrShim(def_id, _) => ty::WithOptConstParam::unknown(def_id),
         }
     }
 
@@ -265,6 +275,7 @@ impl<'tcx> InstanceDef<'tcx> {
     pub fn has_polymorphic_mir_body(&self) -> bool {
         match *self {
             InstanceDef::CloneShim(..)
+            | InstanceDef::FnPtrAddrShim(..)
             | InstanceDef::FnPtrShim(..)
             | InstanceDef::DropGlue(_, Some(_)) => false,
             InstanceDef::ClosureOnceShim { .. }
@@ -299,6 +310,7 @@ impl<'tcx> fmt::Display for Instance<'tcx> {
             InstanceDef::DropGlue(_, None) => write!(f, " - shim(None)"),
             InstanceDef::DropGlue(_, Some(ty)) => write!(f, " - shim(Some({}))", ty),
             InstanceDef::CloneShim(_, ty) => write!(f, " - shim({})", ty),
+            InstanceDef::FnPtrAddrShim(_, ty) => write!(f, " - shim({})", ty),
         }
     }
 }
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -2148,7 +2148,8 @@ impl<'tcx> TyCtxt<'tcx> {
             | ty::InstanceDef::Virtual(..)
             | ty::InstanceDef::ClosureOnceShim { .. }
             | ty::InstanceDef::DropGlue(..)
-            | ty::InstanceDef::CloneShim(..) => self.mir_shims(instance),
+            | ty::InstanceDef::CloneShim(..)
+            | ty::InstanceDef::FnPtrAddrShim(..) => self.mir_shims(instance),
         }
     }
 
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -640,6 +640,9 @@ impl<'a, 'tcx> Lift<'tcx> for ty::InstanceDef<'a> {
             ty::InstanceDef::CloneShim(def_id, ty) => {
                 Some(ty::InstanceDef::CloneShim(def_id, tcx.lift(ty)?))
             }
+            ty::InstanceDef::FnPtrAddrShim(def_id, ty) => {
+                Some(ty::InstanceDef::FnPtrAddrShim(def_id, tcx.lift(ty)?))
+            }
         }
     }
 }
@@ -943,6 +946,9 @@ impl<'tcx> TypeFoldable<'tcx> for ty::instance::Instance<'tcx> {
                 CloneShim(did, ty) => {
                     CloneShim(did.try_fold_with(folder)?, ty.try_fold_with(folder)?)
                 }
+                FnPtrAddrShim(did, ty) => {
+                    FnPtrAddrShim(did.try_fold_with(folder)?, ty.try_fold_with(folder)?)
+                }
             },
         })
     }
@@ -957,7 +963,7 @@ impl<'tcx> TypeVisitable<'tcx> for ty::instance::Instance<'tcx> {
             VTableShim(did) | ReifyShim(did) | Intrinsic(did) | Virtual(did, _) => {
                 did.visit_with(visitor)
             }
-            FnPtrShim(did, ty) | CloneShim(did, ty) => {
+            FnPtrShim(did, ty) | CloneShim(did, ty) | FnPtrAddrShim(did, ty) => {
                 did.visit_with(visitor)?;
                 ty.visit_with(visitor)
             }
diff --git a/compiler/rustc_mir_transform/src/inline.rs b/compiler/rustc_mir_transform/src/inline.rs
@@ -251,7 +251,8 @@ impl<'tcx> Inliner<'tcx> {
             | InstanceDef::FnPtrShim(..)
             | InstanceDef::ClosureOnceShim { .. }
             | InstanceDef::DropGlue(..)
-            | InstanceDef::CloneShim(..) => return Ok(()),
+            | InstanceDef::CloneShim(..)
+            | InstanceDef::FnPtrAddrShim(..) => return Ok(()),
         }
 
         if self.tcx.is_constructor(callee_def_id) {
diff --git a/compiler/rustc_mir_transform/src/inline/cycle.rs b/compiler/rustc_mir_transform/src/inline/cycle.rs
@@ -79,11 +79,14 @@ pub(crate) fn mir_callgraph_reachable<'tcx>(
                 // These have MIR and if that MIR is inlined, substituted and then inlining is run
                 // again, a function item can end up getting inlined. Thus we'll be able to cause
                 // a cycle that way
+                //
+                // FIXME: `FnPtrAddrShim` should not be able to cause recursion.
                 InstanceDef::VTableShim(_)
                 | InstanceDef::ReifyShim(_)
                 | InstanceDef::FnPtrShim(..)
                 | InstanceDef::ClosureOnceShim { .. }
-                | InstanceDef::CloneShim(..) => {}
+                | InstanceDef::CloneShim(..)
+                | InstanceDef::FnPtrAddrShim(..) => {}
                 InstanceDef::DropGlue(..) => {
                     // FIXME: A not fully substituted drop shim can cause ICEs if one attempts to
                     // have its MIR built. Likely oli-obk just screwed up the `ParamEnv`s, so this
diff --git a/compiler/rustc_mir_transform/src/shim.rs b/compiler/rustc_mir_transform/src/shim.rs
@@ -78,6 +78,7 @@ fn make_shim<'tcx>(tcx: TyCtxt<'tcx>, instance: ty::InstanceDef<'tcx>) -> Body<'
             build_drop_shim(tcx, def_id, ty)
         }
         ty::InstanceDef::CloneShim(def_id, ty) => build_clone_shim(tcx, def_id, ty),
+        ty::InstanceDef::FnPtrAddrShim(def_id, ty) => build_fn_ptr_addr_shim(tcx, def_id, ty),
         ty::InstanceDef::Virtual(..) => {
             bug!("InstanceDef::Virtual ({:?}) is for direct calls only", instance)
         }
@@ -788,3 +789,38 @@ pub fn build_adt_ctor(tcx: TyCtxt<'_>, ctor_id: DefId) -> Body<'_> {
 
     body
 }
+
+/// ```ignore (pseudo-impl)
+/// impl FnPtr for fn(u32) {
+///     fn addr(self) -> usize {
+///         self as usize
+///     }
+/// }
+/// ```
+fn build_fn_ptr_addr_shim<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, self_ty: Ty<'tcx>) -> Body<'tcx> {
+    assert!(matches!(self_ty.kind(), ty::FnPtr(..)), "expected fn ptr, found {self_ty}");
+    let span = tcx.def_span(def_id);
+    let Some(sig) = tcx.bound_fn_sig(def_id).subst(tcx, &[self_ty.into()]).no_bound_vars() else {
+        span_bug!(span, "FnPtr::addr with bound vars for `{self_ty}`");
+    };
+    let locals = local_decls_for_sig(&sig, span);
+
+    let source_info = SourceInfo::outermost(span);
+    let rvalue = Rvalue::Cast(
+        CastKind::PointerExposeAddress,
+        Operand::Move(Place::from(Local::new(1))),
+        tcx.types.usize,
+    );
+    let stmt = Statement {
+        source_info,
+        kind: StatementKind::Assign(Box::new((Place::return_place(), rvalue))),
+    };
+    let statements = vec![stmt];
+    let start_block = BasicBlockData {
+        statements,
+        terminator: Some(Terminator { source_info, kind: TerminatorKind::Return }),
+        is_cleanup: false,
+    };
+    let source = MirSource::from_instance(ty::InstanceDef::FnPtrAddrShim(def_id, self_ty));
+    new_body(source, IndexVec::from_elem_n(start_block, 1), locals, sig.inputs().len(), span)
+}
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
@@ -997,7 +997,8 @@ fn visit_instance_use<'tcx>(
         | ty::InstanceDef::ClosureOnceShim { .. }
         | ty::InstanceDef::Item(..)
         | ty::InstanceDef::FnPtrShim(..)
-        | ty::InstanceDef::CloneShim(..) => {
+        | ty::InstanceDef::CloneShim(..)
+        | ty::InstanceDef::FnPtrAddrShim(..) => {
             output.push(create_fn_mono_item(tcx, instance, source));
         }
     }
diff --git a/compiler/rustc_monomorphize/src/partitioning/default.rs b/compiler/rustc_monomorphize/src/partitioning/default.rs
@@ -278,7 +278,8 @@ fn characteristic_def_id_of_mono_item<'tcx>(
                 | ty::InstanceDef::Intrinsic(..)
                 | ty::InstanceDef::DropGlue(..)
                 | ty::InstanceDef::Virtual(..)
-                | ty::InstanceDef::CloneShim(..) => return None,
+                | ty::InstanceDef::CloneShim(..)
+                | ty::InstanceDef::FnPtrAddrShim(..) => return None,
             };
 
             // If this is a method, we want to put it into the same module as
@@ -432,7 +433,8 @@ fn mono_item_visibility<'tcx>(
         | InstanceDef::Intrinsic(..)
         | InstanceDef::ClosureOnceShim { .. }
         | InstanceDef::DropGlue(..)
-        | InstanceDef::CloneShim(..) => return Visibility::Hidden,
+        | InstanceDef::CloneShim(..)
+        | InstanceDef::FnPtrAddrShim(..) => return Visibility::Hidden,
     };
 
     // The `start_fn` lang item is actually a monomorphized instance of a
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -728,6 +728,8 @@ symbols! {
         fn_mut,
         fn_once,
         fn_once_output,
+        fn_ptr_addr,
+        fn_ptr_trait,
         forbid,
         forget,
         format,
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -323,6 +323,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 self.assemble_candidates_for_unsizing(obligation, &mut candidates);
             } else if lang_items.destruct_trait() == Some(def_id) {
                 self.assemble_const_destruct_candidates(obligation, &mut candidates);
+            } else if lang_items.fn_ptr_trait() == Some(def_id) {
+                self.assemble_candidates_for_fn_ptr_trait(obligation, &mut candidates);
             } else {
                 if lang_items.clone_trait() == Some(def_id) {
                     // Same builtin conditions as `Copy`, i.e., every type which has builtin support
@@ -1002,4 +1004,43 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             }
         }
     }
+
+    fn assemble_candidates_for_fn_ptr_trait(
+        &mut self,
+        obligation: &TraitObligation<'tcx>,
+        candidates: &mut SelectionCandidateSet<'tcx>,
+    ) {
+        let self_ty = self.infcx().shallow_resolve(obligation.self_ty());
+        match self_ty.skip_binder().kind() {
+            ty::FnPtr(_) => candidates.vec.push(BuiltinCandidate { has_nested: false }),
+            ty::Bool
+            | ty::Char
+            | ty::Int(_)
+            | ty::Uint(_)
+            | ty::Float(_)
+            | ty::Adt(..)
+            | ty::Foreign(..)
+            | ty::Str
+            | ty::Array(..)
+            | ty::Slice(_)
+            | ty::RawPtr(_)
+            | ty::Ref(..)
+            | ty::FnDef(..)
+            | ty::Placeholder(..)
+            | ty::Dynamic(..)
+            | ty::Closure(..)
+            | ty::Generator(..)
+            | ty::GeneratorWitness(..)
+            | ty::Never
+            | ty::Tuple(..)
+            | ty::Projection(..)
+            | ty::Opaque(..)
+            | ty::Param(..)
+            | ty::Bound(..)
+            | ty::Error(_) => {}
+            ty::Infer(_) => {
+                candidates.ambiguous = true;
+            }
+        }
+    }
 }
diff --git a/compiler/rustc_ty_utils/src/instance.rs b/compiler/rustc_ty_utils/src/instance.rs
@@ -363,7 +363,8 @@ fn resolve_associated_item<'tcx>(
             }
         }
         traits::ImplSource::Builtin(..) => {
-            if Some(trait_ref.def_id) == tcx.lang_items().clone_trait() {
+            let lang_items = tcx.lang_items();
+            if Some(trait_ref.def_id) == lang_items.clone_trait() {
                 // FIXME(eddyb) use lang items for methods instead of names.
                 let name = tcx.item_name(trait_item_id);
                 if name == sym::clone {
@@ -387,6 +388,22 @@ fn resolve_associated_item<'tcx>(
                     let substs = tcx.erase_regions(rcvr_substs);
                     Some(ty::Instance::new(trait_item_id, substs))
                 }
+            } else if Some(trait_ref.def_id) == lang_items.fn_ptr_trait() {
+                if lang_items.fn_ptr_addr() == Some(trait_item_id) {
+                    let self_ty = trait_ref.self_ty();
+                    if !matches!(self_ty.kind(), ty::FnPtr(..)) {
+                        return Ok(None);
+                    }
+                    Some(Instance {
+                        def: ty::InstanceDef::FnPtrAddrShim(trait_item_id, self_ty),
+                        substs: rcvr_substs,
+                    })
+                } else {
+                    tcx.sess.span_fatal(
+                        tcx.def_span(trait_item_id),
+                        "`FnPtrAddr` trait with unexpected assoc item",
+                    )
+                }
             } else {
                 None
             }
diff --git a/compiler/rustc_typeck/src/coherence/mod.rs b/compiler/rustc_typeck/src/coherence/mod.rs
@@ -68,6 +68,18 @@ fn enforce_trait_manually_implementable(
         return;
     }
 
+    if did == li.fn_ptr_trait() {
+        struct_span_err!(
+            tcx.sess,
+            impl_header_span,
+            E0322,
+            "explicit impls for the `FnPtr` trait are not permitted"
+        )
+        .span_label(impl_header_span, "impl of `FnPtr` not allowed")
+        .emit();
+        return;
+    }
+
     if did == li.sized_trait() {
         struct_span_err!(
             tcx.sess,
diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
@@ -838,3 +838,13 @@ mod copy_impls {
     #[stable(feature = "rust1", since = "1.0.0")]
     impl<T: ?Sized> Copy for &T {}
 }
+
+/// A common trait implemented by all function pointers.
+#[unstable(feature = "fn_ptr_trait", issue = "none", reason = "recently added")]
+#[lang = "fn_ptr_trait"]
+#[cfg(not(bootstrap))]
+pub trait FnPtr {
+    /// Returns the adress of the function pointer.
+    #[lang = "fn_ptr_addr"]
+    fn addr(self) -> usize;
+}

Original file line number	Diff line number	Diff line change
`@@ -369,7 +369,8 @@ impl<'tcx> CodegenUnit<'tcx> {`
`369`	`369`	`\| InstanceDef::Virtual(..)`
`370`	`370`	`\| InstanceDef::ClosureOnceShim { .. }`
`371`	`371`	`\| InstanceDef::DropGlue(..)`
`372`		`- \| InstanceDef::CloneShim(..) => None,`
	`372`	`+ \| InstanceDef::CloneShim(..)`
	`373`	`+ \| InstanceDef::FnPtrAddrShim(..) => None,`
`373`	`374`	`}`
`374`	`375`	`}`
`375`	`376`	`MonoItem::Static(def_id) => def_id.as_local().map(Idx::index),`
Original file line number	Diff line number	Diff line change
`@@ -402,7 +402,8 @@ macro_rules! make_mir_visitor {`
`402`	`402`
`403`	`403`	`ty::InstanceDef::FnPtrShim(_def_id, ty) \|`
`404`	`404`	`ty::InstanceDef::DropGlue(_def_id, Some(ty)) \|`
`405`		`- ty::InstanceDef::CloneShim(_def_id, ty) => {`
	`405`	`+ ty::InstanceDef::CloneShim(_def_id, ty) \|`
	`406`	`+ ty::InstanceDef::FnPtrAddrShim(_def_id, ty) => {`
`406`	`407`	// FIXME(eddyb) use a better `TyContext` here.
`407`	`408`	`self.visit_ty($(& $mutability)? *ty, TyContext::Location(location));`
`408`	`409`	`}`
Original file line number	Diff line number	Diff line change
`@@ -97,6 +97,13 @@ pub enum InstanceDef<'tcx> {`
`97`	`97`	`///`
`98`	`98`	/// The `DefId` is for `Clone::clone`, the `Ty` is the type `T` with the builtin `Clone` impl.
`99`	`99`	`CloneShim(DefId, Ty<'tcx>),`
	`100`	`+`
	`101`	+ /// Compiler-generated `<T as FnPtr>::addr` implementation.
	`102`	`+ ///`
	`103`	+ /// Automatically generated for all potentially higher-ranked `fn(I) -> R` types.
	`104`	`+ ///`
	`105`	+ /// The `DefId` is for `FnPtr::Addr`, the `Ty` is the type `T`.
	`106`	`+ FnPtrAddrShim(DefId, Ty<'tcx>),`
`100`	`107`	`}`
`101`	`108`
`102`	`109`	`impl<'tcx> Instance<'tcx> {`
`@@ -152,7 +159,8 @@ impl<'tcx> InstanceDef<'tcx> {`
`152`	`159`	`\| InstanceDef::Intrinsic(def_id)`
`153`	`160`	`\| InstanceDef::ClosureOnceShim { call_once: def_id, track_caller: _ }`
`154`	`161`	`\| InstanceDef::DropGlue(def_id, _)`
`155`		`- \| InstanceDef::CloneShim(def_id, _) => def_id,`
	`162`	`+ \| InstanceDef::CloneShim(def_id, _)`
	`163`	`+ \| InstanceDef::FnPtrAddrShim(def_id, _) => def_id,`
`156`	`164`	`}`
`157`	`165`	`}`
`158`	`166`
`@@ -168,7 +176,8 @@ impl<'tcx> InstanceDef<'tcx> {`
`168`	`176`	`\| InstanceDef::Intrinsic(..)`
`169`	`177`	`\| InstanceDef::ClosureOnceShim { .. }`
`170`	`178`	`\| InstanceDef::DropGlue(..)`
`171`		`- \| InstanceDef::CloneShim(..) => None,`
	`179`	`+ \| InstanceDef::CloneShim(..)`
	`180`	`+ \| InstanceDef::FnPtrAddrShim(..) => None,`
`172`	`181`	`}`
`173`	`182`	`}`
`174`	`183`
`@@ -183,7 +192,8 @@ impl<'tcx> InstanceDef<'tcx> {`
`183`	`192`	`\| InstanceDef::Intrinsic(def_id)`
`184`	`193`	`\| InstanceDef::ClosureOnceShim { call_once: def_id, track_caller: _ }`
`185`	`194`	`\| InstanceDef::DropGlue(def_id, _)`
`186`		`- \| InstanceDef::CloneShim(def_id, _) => ty::WithOptConstParam::unknown(def_id),`
	`195`	`+ \| InstanceDef::CloneShim(def_id, _)`
	`196`	`+ \| InstanceDef::FnPtrAddrShim(def_id, _) => ty::WithOptConstParam::unknown(def_id),`
`187`	`197`	`}`
`188`	`198`	`}`
`189`	`199`
`@@ -265,6 +275,7 @@ impl<'tcx> InstanceDef<'tcx> {`
`265`	`275`	`pub fn has_polymorphic_mir_body(&self) -> bool {`
`266`	`276`	`match *self {`
`267`	`277`	`InstanceDef::CloneShim(..)`
	`278`	`+ \| InstanceDef::FnPtrAddrShim(..)`
`268`	`279`	`\| InstanceDef::FnPtrShim(..)`
`269`	`280`	`\| InstanceDef::DropGlue(_, Some(_)) => false,`
`270`	`281`	`InstanceDef::ClosureOnceShim { .. }`
`@@ -299,6 +310,7 @@ impl<'tcx> fmt::Display for Instance<'tcx> {`
`299`	`310`	`InstanceDef::DropGlue(_, None) => write!(f, " - shim(None)"),`
`300`	`311`	`InstanceDef::DropGlue(_, Some(ty)) => write!(f, " - shim(Some({}))", ty),`
`301`	`312`	`InstanceDef::CloneShim(_, ty) => write!(f, " - shim({})", ty),`
	`313`	`+ InstanceDef::FnPtrAddrShim(_, ty) => write!(f, " - shim({})", ty),`
`302`	`314`	`}`
`303`	`315`	`}`
`304`	`316`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2148,7 +2148,8 @@ impl<'tcx> TyCtxt<'tcx> {`
`2148`	`2148`	`\| ty::InstanceDef::Virtual(..)`
`2149`	`2149`	`\| ty::InstanceDef::ClosureOnceShim { .. }`
`2150`	`2150`	`\| ty::InstanceDef::DropGlue(..)`
`2151`		`- \| ty::InstanceDef::CloneShim(..) => self.mir_shims(instance),`
	`2151`	`+ \| ty::InstanceDef::CloneShim(..)`
	`2152`	`+ \| ty::InstanceDef::FnPtrAddrShim(..) => self.mir_shims(instance),`
`2152`	`2153`	`}`
`2153`	`2154`	`}`
`2154`	`2155`
Original file line number	Diff line number	Diff line change
`@@ -640,6 +640,9 @@ impl<'a, 'tcx> Lift<'tcx> for ty::InstanceDef<'a> {`
`640`	`640`	`ty::InstanceDef::CloneShim(def_id, ty) => {`
`641`	`641`	`Some(ty::InstanceDef::CloneShim(def_id, tcx.lift(ty)?))`
`642`	`642`	`}`
	`643`	`+ ty::InstanceDef::FnPtrAddrShim(def_id, ty) => {`
	`644`	`+ Some(ty::InstanceDef::FnPtrAddrShim(def_id, tcx.lift(ty)?))`
	`645`	`+ }`
`643`	`646`	`}`
`644`	`647`	`}`
`645`	`648`	`}`
`@@ -943,6 +946,9 @@ impl<'tcx> TypeFoldable<'tcx> for ty::instance::Instance<'tcx> {`
`943`	`946`	`CloneShim(did, ty) => {`
`944`	`947`	`CloneShim(did.try_fold_with(folder)?, ty.try_fold_with(folder)?)`
`945`	`948`	`}`
	`949`	`+ FnPtrAddrShim(did, ty) => {`
	`950`	`+ FnPtrAddrShim(did.try_fold_with(folder)?, ty.try_fold_with(folder)?)`
	`951`	`+ }`
`946`	`952`	`},`
`947`	`953`	`})`
`948`	`954`	`}`
`@@ -957,7 +963,7 @@ impl<'tcx> TypeVisitable<'tcx> for ty::instance::Instance<'tcx> {`
`957`	`963`	`VTableShim(did) \| ReifyShim(did) \| Intrinsic(did) \| Virtual(did, _) => {`
`958`	`964`	`did.visit_with(visitor)`
`959`	`965`	`}`
`960`		`- FnPtrShim(did, ty) \| CloneShim(did, ty) => {`
	`966`	`+ FnPtrShim(did, ty) \| CloneShim(did, ty) \| FnPtrAddrShim(did, ty) => {`
`961`	`967`	`did.visit_with(visitor)?;`
`962`	`968`	`ty.visit_with(visitor)`
`963`	`969`	`}`
Original file line number	Diff line number	Diff line change
`@@ -251,7 +251,8 @@ impl<'tcx> Inliner<'tcx> {`
`251`	`251`	`\| InstanceDef::FnPtrShim(..)`
`252`	`252`	`\| InstanceDef::ClosureOnceShim { .. }`
`253`	`253`	`\| InstanceDef::DropGlue(..)`
`254`		`- \| InstanceDef::CloneShim(..) => return Ok(()),`
	`254`	`+ \| InstanceDef::CloneShim(..)`
	`255`	`+ \| InstanceDef::FnPtrAddrShim(..) => return Ok(()),`
`255`	`256`	`}`
`256`	`257`
`257`	`258`	`if self.tcx.is_constructor(callee_def_id) {`