Initial implementation of FnPtr trait

carbotaniuman · carbotaniuman · commit e4faa20d7714 · 2026-05-07T07:15:54.000-05:00
This commit is an initial implementation of the `FnPtr` trait as
described in the `fn_static` tracking issue, which consists of moving
the internally unstable `core::marker::FnPtr` to `core::ops::FnPtr`, as
well as changing the API. Because `NonNull` is used in the new `as_ptr`
signature, it was also turned into a proper lang item.
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
@@ -556,6 +556,8 @@ declare_features! (
     (unstable, fn_align, "1.53.0", Some(82232)),
     /// Support delegating implementation of functions to other already implemented functions.
     (incomplete, fn_delegation, "1.76.0", Some(118212)),
+    /// Traits for function pointers and items
+    (unstable, fn_static, "CURRENT_RUSTC_VERSION", Some(148768)),
     /// Allows impls for the Freeze trait.
     (internal, freeze_impls, "1.78.0", Some(121675)),
     /// Frontmatter `---` blocks for use by external tools.
diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs
@@ -175,11 +175,13 @@ language_item_table! {
     Metadata,                sym::metadata_type,       metadata_type,              Target::AssocTy,        GenericRequirement::None;
     DynMetadata,             sym::dyn_metadata,        dyn_metadata,               Target::Struct,         GenericRequirement::None;
 
+    NonNull,                 sym::non_null,            non_null_trait,             Target::Struct,         GenericRequirement::Exact(1);
+
     Freeze,                  sym::freeze,              freeze_trait,               Target::Trait,          GenericRequirement::Exact(0);
     UnsafeUnpin,             sym::unsafe_unpin,        unsafe_unpin_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;
+    FnPtrAsPtr,              sym::fn_ptr_as_ptr,       fn_ptr_as_ptr,              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;
@@ -235,6 +237,7 @@ language_item_table! {
     Fn,                      kw::Fn,                   fn_trait,                   Target::Trait,          GenericRequirement::Exact(1);
     FnMut,                   sym::fn_mut,              fn_mut_trait,               Target::Trait,          GenericRequirement::Exact(1);
     FnOnce,                  sym::fn_once,             fn_once_trait,              Target::Trait,          GenericRequirement::Exact(1);
+    FnStatic,                sym::fn_static,           fn_static_trait,            Target::Trait,          GenericRequirement::Exact(1);
 
     AsyncFn,                 sym::async_fn,            async_fn_trait,             Target::Trait,          GenericRequirement::Exact(1);
     AsyncFnMut,              sym::async_fn_mut,        async_fn_mut_trait,         Target::Trait,          GenericRequirement::Exact(1);
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -1894,14 +1894,22 @@ fn check_method_receiver<'tcx>(
             {
                 match receiver_validity_err {
                     ReceiverValidityError::DoesNotDeref if arbitrary_self_types_level.is_some() => {
-                        let hint = match receiver_ty
-                            .builtin_deref(false)
-                            .unwrap_or(receiver_ty)
-                            .ty_adt_def()
-                            .and_then(|adt_def| tcx.get_diagnostic_name(adt_def.did()))
-                        {
-                            Some(sym::RcWeak | sym::ArcWeak) => Some(InvalidReceiverTyHint::Weak),
-                            Some(sym::NonNull) => Some(InvalidReceiverTyHint::NonNull),
+                        let adt_def =
+                            receiver_ty.builtin_deref(false).unwrap_or(receiver_ty).ty_adt_def();
+
+                        let hint = match adt_def {
+                            Some(adt) => {
+                                if tcx.is_lang_item(adt.did(), LangItem::NonNull) {
+                                    Some(InvalidReceiverTyHint::NonNull)
+                                } else {
+                                    match tcx.get_diagnostic_name(adt.did()) {
+                                        Some(sym::RcWeak | sym::ArcWeak) => {
+                                            Some(InvalidReceiverTyHint::Weak)
+                                        }
+                                        _ => None,
+                                    }
+                                }
+                            }
                             _ => None,
                         };
 
diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
@@ -312,7 +312,7 @@ fn lint_wide_pointer<'tcx>(
         let mut modifiers = String::new();
         ty = match ty.kind() {
             ty::RawPtr(ty, _) => *ty,
-            ty::Adt(def, args) if cx.tcx.is_diagnostic_item(sym::NonNull, def.did()) => {
+            ty::Adt(def, args) if cx.tcx.is_lang_item(def.did(), LangItem::NonNull) => {
                 modifiers.push_str(".as_ptr()");
                 args.type_at(0)
             }
diff --git a/compiler/rustc_mir_transform/src/shim.rs b/compiler/rustc_mir_transform/src/shim.rs
@@ -1077,27 +1077,42 @@ pub(super) fn build_adt_ctor(tcx: TyCtxt<'_>, ctor_id: DefId) -> Body<'_> {
 /// ```
 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 nonnull_did = tcx.require_lang_item(LangItem::NonNull, span);
+    let nonnull_ty = tcx
+        .type_of(nonnull_did)
+        .instantiate(tcx, &[ty::GenericArg::from(tcx.types.unit)])
+        .skip_norm_wip();
+
     let Some(sig) =
         tcx.fn_sig(def_id).instantiate(tcx, &[self_ty.into()]).skip_norm_wip().no_bound_vars()
     else {
         span_bug!(span, "FnPtr::addr with bound vars for `{self_ty}`");
     };
-    let locals = local_decls_for_sig(&sig, span);
+    let mut locals = local_decls_for_sig(&sig, span);
 
     let source_info = SourceInfo::outermost(span);
+
+    let mut statements = vec![];
     // FIXME: use `expose_provenance` once we figure out whether function pointers have meaningful
     // provenance.
-    let rvalue = Rvalue::Cast(
-        CastKind::FnPtrToPtr,
-        Operand::Move(Place::from(Local::arg(0))),
-        Ty::new_imm_ptr(tcx, tcx.types.unit),
-    );
-    let stmt = Statement::new(
+    let raw_unit_ptr = Ty::new_imm_ptr(tcx, tcx.types.unit);
+    let cast_to_raw_rvalue =
+        Rvalue::Cast(CastKind::FnPtrToPtr, Operand::Move(Place::from(Local::arg(0))), raw_unit_ptr);
+    let raw_ptr = locals.push(LocalDecl::with_source_info(raw_unit_ptr, source_info)).into();
+    statements.push(Statement::new(
         source_info,
-        StatementKind::Assign(Box::new((Place::return_place(), rvalue))),
-    );
-    let statements = vec![stmt];
+        StatementKind::Assign(Box::new((raw_ptr, cast_to_raw_rvalue))),
+    ));
+
+    let transmute_to_nonnull =
+        Rvalue::Cast(CastKind::Transmute, Operand::Move(Place::from(raw_ptr)), nonnull_ty);
+    statements.push(Statement::new(
+        source_info,
+        StatementKind::Assign(Box::new((Place::return_place(), transmute_to_nonnull))),
+    ));
+
     let start_block = BasicBlockData::new_stmts(
         statements,
         Some(Terminator { source_info, kind: TerminatorKind::Return }),
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -252,7 +252,6 @@ symbols! {
         Mutex,
         MutexGuard,
         Named,
-        NonNull,
         NonZero,
         None,
         Normal,
@@ -975,8 +974,9 @@ symbols! {
         fn_mut,
         fn_once,
         fn_once_output,
-        fn_ptr_addr,
+        fn_ptr_as_ptr,
         fn_ptr_trait,
+        fn_static,
         forbid,
         force_target_feature,
         forget,
@@ -1398,6 +1398,7 @@ symbols! {
         non_exhaustive_omitted_patterns_lint,
         non_lifetime_binders,
         non_modrs_mods,
+        non_null,
         nonblocking,
         none,
         nontemporal_store,
diff --git a/compiler/rustc_ty_utils/src/errors.rs b/compiler/rustc_ty_utils/src/errors.rs
@@ -71,13 +71,6 @@ pub(crate) enum GenericConstantTooComplexSub {
     OperationNotSupported(#[primary_span] Span),
 }
 
-#[derive(Diagnostic)]
-#[diag("`FnPtr` trait with unexpected associated item")]
-pub(crate) struct UnexpectedFnPtrAssociatedItem {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(
     "monomorphising SIMD type `{$ty}` with a non-primitive-scalar (integer/float/pointer) element type `{$e_ty}`"
diff --git a/compiler/rustc_ty_utils/src/instance.rs b/compiler/rustc_ty_utils/src/instance.rs
@@ -14,8 +14,6 @@ use rustc_trait_selection::traits;
 use tracing::debug;
 use traits::translate_args;
 
-use crate::errors::UnexpectedFnPtrAssociatedItem;
-
 fn resolve_instance_raw<'tcx>(
     tcx: TyCtxt<'tcx>,
     key: ty::PseudoCanonicalInput<'tcx, (DefId, GenericArgsRef<'tcx>)>,
@@ -288,7 +286,7 @@ fn resolve_associated_item<'tcx>(
                     Some(ty::Instance::new_raw(trait_item_id, args))
                 }
             } else if tcx.is_lang_item(trait_ref.def_id, LangItem::FnPtrTrait) {
-                if tcx.is_lang_item(trait_item_id, LangItem::FnPtrAddr) {
+                if tcx.is_lang_item(trait_item_id, LangItem::FnPtrAsPtr) {
                     let self_ty = trait_ref.self_ty();
                     if !matches!(self_ty.kind(), ty::FnPtr(..)) {
                         return Ok(None);
@@ -298,9 +296,9 @@ fn resolve_associated_item<'tcx>(
                         args: rcvr_args,
                     })
                 } else {
-                    tcx.dcx().emit_fatal(UnexpectedFnPtrAssociatedItem {
-                        span: tcx.def_span(trait_item_id),
-                    })
+                    Some(Instance { def: ty::InstanceKind::Item(trait_item_id), args: rcvr_args })
+                    // debug_assert!(tcx.defaultness(trait_item_id).has_value());
+                    // Some(Instance::new(trait_item_id, rcvr_args))
                 }
             } else if let Some(target_kind) = tcx.fn_trait_kind_from_def_id(trait_ref.def_id) {
                 // FIXME: This doesn't check for malformed libcore that defines, e.g.,
diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
@@ -1120,24 +1120,6 @@ marker_impls! {
         {T: ConstParamTy_ + ?Sized} &T,
 }
 
-/// A common trait implemented by all function pointers.
-//
-// Note that while the trait is internal and unstable it is nevertheless
-// exposed as a public bound of the stable `core::ptr::fn_addr_eq` function.
-#[unstable(
-    feature = "fn_ptr_trait",
-    issue = "none",
-    reason = "internal trait for implementing various traits for all function pointers"
-)]
-#[lang = "fn_ptr_trait"]
-#[rustc_deny_explicit_impl]
-#[rustc_dyn_incompatible_trait]
-pub trait FnPtr: Copy + Clone {
-    /// Returns the address of the function pointer.
-    #[lang = "fn_ptr_addr"]
-    fn addr(self) -> *const ();
-}
-
 /// Derive macro that makes a smart pointer usable with trait objects.
 ///
 /// # What this macro does
diff --git a/library/core/src/ops/function.rs b/library/core/src/ops/function.rs
@@ -1,5 +1,5 @@
 use crate::marker::Tuple;
-
+use crate::ptr::NonNull;
 /// The version of the call operator that takes an immutable receiver.
 ///
 /// Instances of `Fn` can be called repeatedly without mutating state.
@@ -311,3 +311,39 @@ mod impls {
         }
     }
 }
+
+/// A type representing a pointer to a function pointer.
+// FIXME: Make this a proper extern type.
+#[unstable(feature = "fn_static", issue = "148768")]
+pub type Code = ();
+
+/// A common trait implemented by all function pointers.
+#[unstable(feature = "fn_static", issue = "148768")]
+#[lang = "fn_ptr_trait"]
+#[rustc_deny_explicit_impl]
+#[rustc_dyn_incompatible_trait]
+pub trait FnPtr: Copy + Clone {
+    /// Returns the address of the function pointer.
+    #[unstable(feature = "fn_static", issue = "148768")]
+    fn addr(self) -> usize {
+        self.as_ptr().addr().get()
+    }
+
+    /// Returns the function pointer as a [`NonNull<Code>`].
+    #[unstable(feature = "fn_static", issue = "148768")]
+    #[lang = "fn_ptr_as_ptr"]
+    fn as_ptr(self) -> NonNull<Code>;
+
+    /// Constructs a function pointer from a `NonNull` pointer.
+    ///
+    /// # Safety
+    ///
+    /// The function pointer must have been obtained
+    /// from an [`FnPtr::as_ptr`] call from a function
+    /// pointer type that is ABI compatible.
+    #[unstable(feature = "fn_static", issue = "148768")]
+    unsafe fn from_ptr(ptr: NonNull<Code>) -> Self {
+        // SAFETY: The pointer is valid and points to an ABI-compatible function.
+        unsafe { crate::mem::transmute(ptr.as_ptr()) }
+    }
+}
diff --git a/library/core/src/ops/mod.rs b/library/core/src/ops/mod.rs
@@ -177,6 +177,8 @@ pub use self::deref::Receiver;
 pub use self::deref::{Deref, DerefMut};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::drop::Drop;
+#[unstable(feature = "fn_static", issue = "148768")]
+pub use self::function::{Code, FnPtr};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::function::{Fn, FnMut, FnOnce};
 #[stable(feature = "rust1", since = "1.0.0")]
diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
@@ -406,9 +406,10 @@
 
 use crate::cmp::Ordering;
 use crate::intrinsics::const_eval_select;
-use crate::marker::{Destruct, FnPtr, PointeeSized};
+use crate::marker::{Destruct, PointeeSized};
 use crate::mem::{self, MaybeUninit, SizedTypeProperties};
 use crate::num::NonZero;
+use crate::ops::FnPtr;
 use crate::{fmt, hash, intrinsics, ub_checks};
 
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
@@ -2497,7 +2498,7 @@ pub fn addr_eq<T: PointeeSized, U: PointeeSized>(p: *const T, q: *const U) -> bo
 #[inline(always)]
 #[must_use = "function pointer comparison produces a value"]
 pub fn fn_addr_eq<T: FnPtr, U: FnPtr>(f: T, g: U) -> bool {
-    f.addr() == g.addr()
+    f.as_ptr() == g.as_ptr()
 }
 
 /// Hash a raw pointer.
diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs
@@ -70,7 +70,7 @@ use crate::{fmt, hash, intrinsics, mem, ptr};
 #[stable(feature = "nonnull", since = "1.25.0")]
 #[repr(transparent)]
 #[rustc_nonnull_optimization_guaranteed]
-#[rustc_diagnostic_item = "NonNull"]
+#[lang = "non_null"]
 pub struct NonNull<T: PointeeSized> {
     pointer: crate::pattern_type!(*const T is !null),
 }
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
@@ -337,7 +337,7 @@
 #![feature(float_gamma)]
 #![feature(float_minimum_maximum)]
 #![feature(fmt_internals)]
-#![feature(fn_ptr_trait)]
+#![feature(fn_static)]
 #![feature(formatting_options)]
 #![feature(funnel_shifts)]
 #![feature(generic_atomic)]
diff --git a/library/std/src/sys/pal/unix/weak/dlsym.rs b/library/std/src/sys/pal/unix/weak/dlsym.rs
@@ -1,5 +1,6 @@
 use crate::ffi::{CStr, c_char, c_void};
-use crate::marker::{FnPtr, PhantomData};
+use crate::marker::PhantomData;
+use crate::ops::FnPtr;
 use crate::sync::atomic::{Atomic, AtomicPtr, Ordering};
 use crate::{mem, ptr};
 
diff --git a/src/tools/clippy/clippy_lints/src/methods/zst_offset.rs b/src/tools/clippy/clippy_lints/src/methods/zst_offset.rs
@@ -11,7 +11,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
     let recv_ty = cx.typeck_results().expr_ty(recv);
     let pointee_ty = match recv_ty.kind() {
         ty::RawPtr(ty, _) => *ty,
-        ty::Adt(_, args) if recv_ty.is_diag_item(cx, sym::NonNull) => args.type_at(0),
+        ty::Adt(_, args) if recv_ty.is_lang_item(cx, LangItem::NonNull) => args.type_at(0),
         _ => return,
     };
     if let Ok(layout) = cx.tcx.layout_of(cx.typing_env().as_query_input(pointee_ty))
diff --git a/src/tools/clippy/clippy_lints/src/non_send_fields_in_send_ty.rs b/src/tools/clippy/clippy_lints/src/non_send_fields_in_send_ty.rs
@@ -227,7 +227,7 @@ fn contains_pointer_like<'tcx>(cx: &LateContext<'tcx>, target_ty: Ty<'tcx>) -> b
                 ty::RawPtr(_, _) => {
                     return true;
                 },
-                ty::Adt(adt_def, _) if cx.tcx.is_diagnostic_item(sym::NonNull, adt_def.did()) => {
+                ty::Adt(adt_def, _) if cx.tcx.is_lang_item(adt_def.did(), LangItem::NonNull) => {
                     return true;
                 },
                 _ => (),
diff --git a/src/tools/clippy/clippy_lints/src/volatile_composites.rs b/src/tools/clippy/clippy_lints/src/volatile_composites.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::res::MaybeDef;
 use clippy_utils::sym;
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{Expr, ExprKind, LangItem};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, Ty, TypeVisitableExt};
@@ -155,7 +155,7 @@ impl<'tcx> LateLintPass<'tcx> for VolatileComposites {
                     // Raw pointers
                     ty::RawPtr(innerty, _) => report_volatile_safe(cx, expr, *innerty),
                     // std::ptr::NonNull
-                    ty::Adt(_, args) if self_ty.is_diag_item(cx, sym::NonNull) => {
+                    ty::Adt(_, args) if self_ty.is_lang_item(cx, LangItem::NonNull) => {
                         report_volatile_safe(cx, expr, args.type_at(0));
                     },
                     _ => (),
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs b/src/tools/rust-analyzer/crates/hir-def/src/lang_item.rs
@@ -320,8 +320,10 @@ language_item_table! { LangItems =>
 
     Freeze,                  sym::freeze,              TraitId;
 
+    NonNull,                 sym::non_null,            StructId;
+
     FnPtrTrait,              sym::fn_ptr_trait,        TraitId;
-    FnPtrAddr,               sym::fn_ptr_addr,         FunctionId;
+    FnPtrAsPtr,              sym::fn_ptr_as_ptr,       FunctionId;
 
     Drop,                    sym::drop,                TraitId;
     Destruct,                sym::destruct,            TraitId;
diff --git a/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs b/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
@@ -239,7 +239,7 @@ define_symbols! {
     async_fn_kind_upvars,
     call_ref_future,
     call_once_future,
-    fn_ptr_addr,
+    fn_ptr_as_ptr,
     fn_ptr_trait,
     format_alignment,
     format_args_nl,
diff --git a/tests/ui/feature-gates/feature-gate-fn_static.rs b/tests/ui/feature-gates/feature-gate-fn_static.rs
@@ -0,0 +1,7 @@
+use std::ops::FnPtr;
+//~^ ERROR: use of unstable library feature `fn_static` [E0658]
+
+use std::ops::FnStatic;
+//~^ ERROR: use of unstable library feature `fn_static` [E0658]
+
+fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-fn_static.stderr b/tests/ui/feature-gates/feature-gate-fn_static.stderr
diff --git a/tests/ui/fn/fn-ptr-trait-run.rs b/tests/ui/fn/fn-ptr-trait-run.rs
diff --git a/tests/ui/fn/fn-ptr-trait.rs b/tests/ui/fn/fn-ptr-trait.rs
diff --git a/tests/ui/traits/next-solver/diagnostics/dont-pick-fnptr-bound-as-leaf.rs b/tests/ui/traits/next-solver/diagnostics/dont-pick-fnptr-bound-as-leaf.rs

Original file line number	Diff line number	Diff line change
`@@ -312,7 +312,7 @@ fn lint_wide_pointer<'tcx>(`
`312`	`312`	`let mut modifiers = String::new();`
`313`	`313`	`ty = match ty.kind() {`
`314`	`314`	`ty::RawPtr(ty, _) => *ty,`
`315`		`- ty::Adt(def, args) if cx.tcx.is_diagnostic_item(sym::NonNull, def.did()) => {`
	`315`	`+ ty::Adt(def, args) if cx.tcx.is_lang_item(def.did(), LangItem::NonNull) => {`
`316`	`316`	`modifiers.push_str(".as_ptr()");`
`317`	`317`	`args.type_at(0)`
`318`	`318`	`}`