Use fn-ptr instead of impl_fn macro

OpenByteDev · OpenByteDev · commit 09de65859dae · 2025-11-27T22:16:35.000+01:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -18,9 +18,9 @@ derive_more = { version = "2.0", features = ["deref", "from", "display"], defaul
 hostfxr-sys = { version = "0.12", features = ["enum-map", "undocumented", "wrapper", "optional-apis"], default-features = false }
 coreclr-hosting-shared = { version = "0.1", default-features = false }
 destruct-drop = { version = "0.2", default-features = false }
-ffi-opaque = { version = "2.0", default-features = false }
 enum-map = { version = "2.7", default-features = false }
 once_cell = { version = "1.21", default-features = false }
+fn-ptr = { version = "0.4", default-features = false }
 nethost-sys = { version = "0.7", optional = true, default-features = false }
 
 [target.'cfg(windows)'.dependencies]
diff --git a/src/hostfxr/context.rs b/src/hostfxr/context.rs
@@ -5,7 +5,7 @@ use crate::{
     error::{HostingError, HostingResult, HostingSuccess},
     hostfxr::{
         AppOrHostingResult, AssemblyDelegateLoader, DelegateLoader, Hostfxr, HostfxrLibrary,
-        RawFunctionPtr, SharedHostfxrLibrary,
+        RawFnPtr, SharedHostfxrLibrary,
     },
     pdcstring::PdCString,
 };
@@ -83,7 +83,7 @@ pub struct HostfxrContext<I> {
     handle: HostfxrHandle,
     hostfxr: SharedHostfxrLibrary,
     is_primary: bool,
-    runtime_delegates: EnumMap<hostfxr_delegate_type, OnceCell<RawFunctionPtr>>,
+    runtime_delegates: EnumMap<hostfxr_delegate_type, OnceCell<RawFnPtr>>,
     context_type: PhantomData<I>,
     not_sync: PhantomData<Cell<HostfxrLibrary>>,
 }
@@ -171,15 +171,15 @@ impl<I> HostfxrContext<I> {
     pub fn get_runtime_delegate(
         &self,
         r#type: hostfxr_delegate_type,
-    ) -> Result<RawFunctionPtr, HostingError> {
+    ) -> Result<RawFnPtr, HostingError> {
         self.runtime_delegates[r#type]
             .get_or_try_init(|| self.get_runtime_delegate_uncached(r#type))
             .copied()
     }
     fn get_runtime_delegate_uncached(
         &self,
         r#type: hostfxr_delegate_type,
-    ) -> Result<RawFunctionPtr, HostingError> {
+    ) -> Result<RawFnPtr, HostingError> {
         let mut delegate = MaybeUninit::uninit();
         let result = unsafe {
             self.hostfxr.hostfxr_get_runtime_delegate(
diff --git a/src/hostfxr/delegate_loader.rs b/src/hostfxr/delegate_loader.rs
@@ -10,15 +10,15 @@ use num_enum::TryFromPrimitive;
 use std::{convert::TryFrom, mem::MaybeUninit, path::Path, ptr};
 use thiserror::Error;
 
-use super::{FunctionPtr, ManagedFunction, RawFunctionPtr, SharedHostfxrLibrary};
+use super::{as_managed, FnPtr, ManagedFunction, RawFnPtr, SharedHostfxrLibrary};
 
 #[cfg(feature = "net5_0")]
 use crate::bindings::hostfxr::{get_function_pointer_fn, UNMANAGED_CALLERS_ONLY_METHOD};
 
 /// A pointer to a function with the default signature.
 pub type ManagedFunctionWithDefaultSignature = ManagedFunction<component_entry_point_fn>;
 /// A pointer to a function with an unknown signature.
-pub type ManagedFunctionWithUnknownSignature = ManagedFunction<RawFunctionPtr>;
+pub type ManagedFunctionWithUnknownSignature = ManagedFunction<RawFnPtr>;
 
 /// A struct for loading pointers to managed functions for a given [`HostfxrContext`].
 ///
@@ -52,7 +52,7 @@ impl DelegateLoader {
         type_name: *const char_t,
         method_name: *const char_t,
         delegate_type_name: *const char_t,
-    ) -> Result<RawFunctionPtr, GetManagedFunctionError> {
+    ) -> Result<RawFnPtr, GetManagedFunctionError> {
         let mut delegate = MaybeUninit::uninit();
 
         let result = unsafe {
@@ -94,7 +94,7 @@ impl DelegateLoader {
         type_name: *const char_t,
         method_name: *const char_t,
         delegate_type_name: *const char_t,
-    ) -> Result<RawFunctionPtr, GetManagedFunctionError> {
+    ) -> Result<RawFnPtr, GetManagedFunctionError> {
         let mut delegate = MaybeUninit::uninit();
 
         let result = unsafe {
@@ -128,13 +128,13 @@ impl DelegateLoader {
     ///    Name of the method on the `type_name` to find. The method must be static and must match the signature of `delegate_type_name`.
     ///  * `delegate_type_name`:
     ///    Assembly qualified delegate type name for the method signature.
-    pub fn load_assembly_and_get_function<F: FunctionPtr>(
+    pub fn load_assembly_and_get_function<F: FnPtr>(
         &self,
         assembly_path: &PdCStr,
         type_name: &PdCStr,
         method_name: &PdCStr,
         delegate_type_name: &PdCStr,
-    ) -> Result<ManagedFunction<F::Managed>, GetManagedFunctionError> {
+    ) -> Result<ManagedFunction<as_managed!(F)>, GetManagedFunctionError> {
         Self::validate_assembly_path(assembly_path)?;
         let function = unsafe {
             self.load_assembly_and_get_function_pointer_raw(
@@ -144,7 +144,9 @@ impl DelegateLoader {
                 delegate_type_name.as_ptr(),
             )
         }?;
-        Ok(ManagedFunction(unsafe { F::Managed::from_ptr(function) }))
+        Ok(ManagedFunction(unsafe {
+            <as_managed!(F)>::from_ptr(function)
+        }))
     }
 
     /// Calling this function will load the specified assembly in isolation (into its own `AssemblyLoadContext`)
@@ -177,7 +179,7 @@ impl DelegateLoader {
                 ptr::null(),
             )
         }?;
-        Ok(ManagedFunction(unsafe { FunctionPtr::from_ptr(function) }))
+        Ok(ManagedFunction(unsafe { FnPtr::from_ptr(function) }))
     }
 
     /// Calling this function will load the specified assembly in isolation (into its own `AssemblyLoadContext`)
@@ -199,12 +201,12 @@ impl DelegateLoader {
     /// [UnmanagedCallersOnly]: <https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.unmanagedcallersonlyattribute>
     #[cfg(feature = "net5_0")]
     #[cfg_attr(feature = "doc-cfg", doc(cfg(feature = "net5_0")))]
-    pub fn load_assembly_and_get_function_with_unmanaged_callers_only<F: FunctionPtr>(
+    pub fn load_assembly_and_get_function_with_unmanaged_callers_only<F: FnPtr>(
         &self,
         assembly_path: &PdCStr,
         type_name: &PdCStr,
         method_name: &PdCStr,
-    ) -> Result<ManagedFunction<F::Managed>, GetManagedFunctionError> {
+    ) -> Result<ManagedFunction<as_managed!(F)>, GetManagedFunctionError> {
         Self::validate_assembly_path(assembly_path)?;
         let function = unsafe {
             self.load_assembly_and_get_function_pointer_raw(
@@ -214,7 +216,9 @@ impl DelegateLoader {
                 UNMANAGED_CALLERS_ONLY_METHOD,
             )
         }?;
-        Ok(ManagedFunction(unsafe { F::Managed::from_ptr(function) }))
+        Ok(ManagedFunction(unsafe {
+            <as_managed!(F)>::from_ptr(function)
+        }))
     }
 
     /// Calling this function will find the specified type and method and return a native function pointer to that method.
@@ -229,20 +233,22 @@ impl DelegateLoader {
     ///    Assembly qualified delegate type name for the method signature.
     #[cfg(feature = "net5_0")]
     #[cfg_attr(feature = "doc-cfg", doc(cfg(feature = "net5_0")))]
-    pub fn get_function<F: FunctionPtr>(
+    pub fn get_function<F: FnPtr>(
         &self,
         type_name: &PdCStr,
         method_name: &PdCStr,
         delegate_type_name: &PdCStr,
-    ) -> Result<ManagedFunction<F::Managed>, GetManagedFunctionError> {
+    ) -> Result<ManagedFunction<as_managed!(F)>, GetManagedFunctionError> {
         let function = unsafe {
             self.get_function_pointer_raw(
                 type_name.as_ptr(),
                 method_name.as_ptr(),
                 delegate_type_name.as_ptr(),
             )
         }?;
-        Ok(ManagedFunction(unsafe { F::Managed::from_ptr(function) }))
+        Ok(ManagedFunction(unsafe {
+            <as_managed!(F)>::from_ptr(function)
+        }))
     }
 
     /// Calling this function will find the specified type and method and return a native function pointer to that method.
@@ -263,7 +269,7 @@ impl DelegateLoader {
         let function = unsafe {
             self.get_function_pointer_raw(type_name.as_ptr(), method_name.as_ptr(), ptr::null())
         }?;
-        Ok(ManagedFunction(unsafe { FunctionPtr::from_ptr(function) }))
+        Ok(ManagedFunction(unsafe { FnPtr::from_ptr(function) }))
     }
 
     /// Calling this function will find the specified type and method and return a native function pointer to that method.
@@ -279,19 +285,21 @@ impl DelegateLoader {
     /// [`UnmanagedCallersOnly`]: https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.unmanagedcallersonlyattribute
     #[cfg(feature = "net5_0")]
     #[cfg_attr(feature = "doc-cfg", doc(cfg(feature = "net5_0")))]
-    pub fn get_function_with_unmanaged_callers_only<F: FunctionPtr>(
+    pub fn get_function_with_unmanaged_callers_only<F: FnPtr>(
         &self,
         type_name: &PdCStr,
         method_name: &PdCStr,
-    ) -> Result<ManagedFunction<F::Managed>, GetManagedFunctionError> {
+    ) -> Result<ManagedFunction<as_managed!(F)>, GetManagedFunctionError> {
         let function = unsafe {
             self.get_function_pointer_raw(
                 type_name.as_ptr(),
                 method_name.as_ptr(),
                 UNMANAGED_CALLERS_ONLY_METHOD,
             )
         }?;
-        Ok(ManagedFunction(unsafe { F::Managed::from_ptr(function) }))
+        Ok(ManagedFunction(unsafe {
+            <as_managed!(F)>::from_ptr(function)
+        }))
     }
 }
 
@@ -330,12 +338,12 @@ impl AssemblyDelegateLoader {
     ///    Name of the method on the `type_name` to find. The method must be static and must match the signature of `delegate_type_name`.
     ///  * `delegate_type_name`:
     ///    Assembly qualified delegate type name for the method signature.
-    pub fn get_function<F: FunctionPtr>(
+    pub fn get_function<F: FnPtr>(
         &self,
         type_name: &PdCStr,
         method_name: &PdCStr,
         delegate_type_name: &PdCStr,
-    ) -> Result<ManagedFunction<F::Managed>, GetManagedFunctionError> {
+    ) -> Result<ManagedFunction<as_managed!(F)>, GetManagedFunctionError> {
         self.loader.load_assembly_and_get_function::<F>(
             self.assembly_path.as_ref(),
             type_name,
@@ -385,11 +393,11 @@ impl AssemblyDelegateLoader {
     /// [`UnmanagedCallersOnly`]: https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.unmanagedcallersonlyattribute
     #[cfg(feature = "net5_0")]
     #[cfg_attr(feature = "doc-cfg", doc(cfg(feature = "net5_0")))]
-    pub fn get_function_with_unmanaged_callers_only<F: FunctionPtr>(
+    pub fn get_function_with_unmanaged_callers_only<F: FnPtr>(
         &self,
         type_name: &PdCStr,
         method_name: &PdCStr,
-    ) -> Result<ManagedFunction<F::Managed>, GetManagedFunctionError> {
+    ) -> Result<ManagedFunction<as_managed!(F)>, GetManagedFunctionError> {
         self.loader
             .load_assembly_and_get_function_with_unmanaged_callers_only::<F>(
                 self.assembly_path.as_ref(),
diff --git a/src/hostfxr/managed_function.rs b/src/hostfxr/managed_function.rs
@@ -1,9 +1,11 @@
 use std::{fmt::Debug, ops::Deref};
 
+pub use fn_ptr::{FnPtr, UntypedFnPtr as RawFnPtr};
+
 /// A wrapper around a managed function pointer.
-pub struct ManagedFunction<F: ManagedFunctionPtr>(pub(crate) F);
+pub struct ManagedFunction<F: ManagedFnPtr>(pub(crate) F);
 
-impl<F: ManagedFunctionPtr> Debug for ManagedFunction<F> {
+impl<F: ManagedFnPtr> Debug for ManagedFunction<F> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("ManagedFunction")
             .field("ptr", &self.0.as_ptr())
@@ -12,139 +14,24 @@ impl<F: ManagedFunctionPtr> Debug for ManagedFunction<F> {
     }
 }
 
-impl<F: ManagedFunctionPtr> Deref for ManagedFunction<F> {
+impl<F: ManagedFnPtr> Deref for ManagedFunction<F> {
     type Target = F;
 
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 
-ffi_opaque::opaque! {
-    /// A struct representing an opaque function.
-    pub struct OpaqueFunction;
-}
-
-/// Type alias for a raw untyped function pointer.
-pub type RawFunctionPtr = *const OpaqueFunction;
-
-/// Trait representing a function pointer.
-///
-/// # Safety
-/// This trait should only be implemented for function pointers and the associated types and constants have to match the function pointer type.
-pub unsafe trait FunctionPtr: Sized + Copy + Send + Sync + 'static {
-    /// The argument types as a tuple.
-    type Args;
-
-    /// The return type.
-    type Output;
-
-    /// The function's arity (number of arguments).
-    const ARITY: usize;
-
-    /// The `extern "system"` version of this function pointer.
-    type Managed: ManagedFunctionPtr;
-
-    /// Constructs a [`FunctionPtr`] from an untyped function pointer.
-    ///
-    /// # Safety
-    /// This function is unsafe because it can not check if the argument points to a function
-    /// of the correct type.
-    unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self;
-
-    /// Returns a untyped function pointer for this function.
-    fn as_ptr(&self) -> RawFunctionPtr;
-}
-
 /// Trait representing a managed function pointer.
-///
-/// # Safety
-/// This trait should only be implemented for `extern "system"` function pointers and the associated types and constants have to match the function pointer type.
-pub unsafe trait ManagedFunctionPtr: FunctionPtr {
-    /// The argument types as a tuple.
-    type Args;
-
-    /// The return type.
-    type Output;
-
-    /// The function's arity (number of arguments).
-    const ARITY: usize;
-}
-
-macro_rules! impl_fn {
-    (@recurse () ($($nm:ident : $ty:ident),*)) => {
-        impl_fn!(@impl_all ($($nm : $ty),*));
-    };
-    (@recurse ($hd_nm:ident : $hd_ty:ident $(, $tl_nm:ident : $tl_ty:ident)*) ($($nm:ident : $ty:ident),*)) => {
-        impl_fn!(@impl_all ($($nm : $ty),*));
-        impl_fn!(@recurse ($($tl_nm : $tl_ty),*) ($($nm : $ty,)* $hd_nm : $hd_ty));
-    };
-
-    (@impl_all ($($nm:ident : $ty:ident),*)) => {
-        impl_fn!(@impl_u_and_s ($($nm : $ty),*) fn($($ty),*) -> Ret);
-    };
-
-    (@impl_u_and_s ($($nm:ident : $ty:ident),*) fn($($param_ty:ident),*) -> $ret:ty) => {
-        impl_fn!(@impl_core ($($nm : $ty),*) (fn($($param_ty),*) -> $ret) (extern "system" fn($($param_ty),*) -> $ret));
-        impl_fn!(@impl_core ($($nm : $ty),*) (unsafe fn($($param_ty),*) -> $ret) (unsafe extern "system" fn($($param_ty),*) -> $ret));
-    };
-
-    (@impl_core ($($nm:ident : $ty:ident),*) ($fn_type:ty) ($managed_fn_type:ty)) => {
-        unsafe impl<Ret: 'static, $($ty: 'static),*> crate::hostfxr::FunctionPtr for $fn_type {
-            type Args = ($($ty,)*);
-            type Output = Ret;
-            type Managed = $managed_fn_type;
-
-            const ARITY: ::core::primitive::usize = impl_fn!(@count ($($ty)*));
-
-            unsafe fn from_ptr(ptr: crate::hostfxr::RawFunctionPtr) -> Self {
-                ::core::assert!(!ptr.is_null());
-                unsafe { ::core::mem::transmute(ptr) }
-            }
-
-            fn as_ptr(&self) -> crate::hostfxr::RawFunctionPtr {
-                *self as crate::hostfxr::RawFunctionPtr
-            }
-        }
-
-        unsafe impl<Ret: 'static, $($ty: 'static),*> crate::hostfxr::FunctionPtr for $managed_fn_type {
-            type Args = ($($ty,)*);
-            type Output = Ret;
-            type Managed = $managed_fn_type;
-
-            const ARITY: ::core::primitive::usize = impl_fn!(@count ($($ty)*));
+pub trait ManagedFnPtr: fn_ptr::FnPtr + fn_ptr::HasAbi<{ fn_ptr::abi!("system") }> {}
 
-            unsafe fn from_ptr(ptr: crate::hostfxr::RawFunctionPtr) -> Self {
-                ::core::assert!(!ptr.is_null());
-                unsafe { ::core::mem::transmute(ptr) }
-            }
+impl<T: fn_ptr::FnPtr + fn_ptr::HasAbi<{ fn_ptr::abi!("system") }>> ManagedFnPtr for T {}
 
-            fn as_ptr(&self) -> crate::hostfxr::RawFunctionPtr {
-                *self as crate::hostfxr::RawFunctionPtr
-            }
-        }
-
-        unsafe impl<Ret: 'static, $($ty: 'static),*> crate::hostfxr::ManagedFunctionPtr for $managed_fn_type {
-            type Args = ($($ty,)*);
-            type Output = Ret;
-
-            const ARITY: ::core::primitive::usize = impl_fn!(@count ($($ty)*));
-        }
-    };
-
-    (@count ()) => {
-        0
-    };
-    (@count ($hd:tt $($tl:tt)*)) => {
-        1 + impl_fn!(@count ($($tl)*))
+#[macro_export]
+#[doc(hidden)]
+macro_rules! __as_managed {
+    ($t:ty) => {
+        ::fn_ptr::with_abi!(::fn_ptr::Abi::System, $t)
     };
-
-    ($($nm:ident : $ty:ident),*) => {
-        impl_fn!(@recurse ($($nm : $ty),*) ());
-    };
-}
-
-impl_fn! {
-    __arg_0:  A, __arg_1:  B, __arg_2:  C, __arg_3:  D, __arg_4:  E, __arg_5:  F, __arg_6:  G,
-    __arg_7:  H, __arg_8:  I, __arg_9:  J, __arg_10: K, __arg_11: L
 }
+pub(crate) use __as_managed as as_managed;
