Fixup

Author: OpenByteDev

README.md

@@ -14,9 +14,7 @@ The trait provides associated types and constants to introspect function pointer
 
 ### 1. Function Pointer Metadata
 
-Every function pointer automatically implements [`FnPtr`](https://docs.rs/fn-ptr/latest/fn_ptr/trait.FnPtr.html).
-Depending on the type, they also implement [`SafeFnPtr`](https://docs.rs/fn-ptr/latest/fn_ptr/trait.SafeFnPtr.html), [`UnsafeFnPtr`](https://docs.rs/fn-ptr/latest/fn_ptr/trait.UnsafeFnPtr.html), [`StaticFnPtr`](https://docs.rs/fn-ptr/latest/fn_ptr/trait.StaticFnPtr.html) and [`HasAbi<Abi>`](https://docs.rs/fn-ptr/latest/fn_ptr/trait.HasAbi.html).
-With it you can inspect the type of function:
+Every function pointer automatically implements [`FnPtr`](https://docs.rs/fn-ptr/latest/fn_ptr/trait.FnPtr.html) as well as a bunch of other related traits. With these you can inspect the type of function pointers at compile time:
 
 ```rust
 use fn_ptr::{FnPtr, Abi};
@@ -26,7 +24,7 @@ type F = extern "C" fn(i32, i32) -> i32;
 assert_eq!(<F as FnPtr>::ARITY, 2);
 assert_eq!(<F as FnPtr>::IS_SAFE, true);
 assert_eq!(<F as FnPtr>::IS_EXTERN, true);
-assert_eq!(<F as FnPtr>::ABI, Abi::C);
+assert_eq!(<F as FnPtr>::ABI, Abi::C { unwind: false });
 ```
 
 There are also some const helper functons to do so ergonomically.
@@ -69,7 +67,7 @@ use fn_ptr::{with_abi, Abi};
 
 type F = extern "C" fn(i32) -> i32;
 
-type G = with_abi!(Abi::Sysv64, F);
+type G = with_abi!("sysv64", F);
 type H = with_abi!("C", extern "system" fn());
 ```
 
@@ -79,7 +77,7 @@ Or at the instance level:
 use fn_ptr::{FnPtr, abi};
 let rust_add: fn(i32, i32) -> i32 = |a, b| {a + b};
 // Safety: not actually safe!
-let c_add: extern "C" fn(i32, i32) -> i32 = unsafe { rust_add.with_abi::<{abi!("C")}>() };
+let c_add: extern "C" fn(i32, i32) -> i32 = unsafe { rust_add.with_abi::<abi!("C")>() };
 ```
 
 Note that this does not change the underlying ABI and should be used with caution.
@@ -90,11 +88,11 @@ To implement the traits for all function pointer types, there is a large [macro]
 For the conversion macros the crate relies on two traits: [`WithAbi`](https://docs.rs/fn-ptr/latest/fn_ptr/trait.WithAbi.html) and [`WithSafety`](https://docs.rs/fn-ptr/latest/fn_ptr/trait.WithSafety.html) that can also be used directly:
 
 ```rust
-use fn_ptr::{FnPtr, WithAbi, WithSafety, Abi};
+use fn_ptr::{FnPtr, WithAbi, WithSafety, marker::{SysV64, Unsafe}};
 
 type F = extern "C" fn(i32);
-type G = <F as WithAbi<{Abi::Sysv64}>>::F;
-type U = <F as WithSafety<{false}>>::F;
+type G = <F as WithAbi<SysV64>>::F;
+type U = <F as WithSafety<Unsafe>::F;
 ```
 
 ## License

src/base.rs

@@ -5,11 +5,11 @@ use core::{
 };
 
 use crate::{
-    AsSafe, AsUnsafe, WithAbi,
+    AsSafe, AsUnsafe, WithAbi, WithSafety,
     abi::Abi,
     make_safe, make_unsafe,
     marker::{self, Safe, Unsafe},
-    with_abi,
+    with_abi, with_safety,
 };
 
 ffi_opaque::opaque! {
@@ -116,6 +116,18 @@ pub trait FnPtr:
     {
         unsafe { FnPtr::from_ptr(self.as_ptr()) }
     }
+
+    /// Produces a version of this function pointer with the given safety.
+    ///
+    /// # Safety
+    /// Caller must ensure that this function pointer is safe when casting to a safe function.
+    #[must_use]
+    unsafe fn with_safety<Safety: marker::Safety>(&self) -> with_safety!(Safety, Self)
+    where
+        Self: WithSafety<Safety>,
+    {
+        unsafe { FnPtr::from_ptr(self.as_ptr()) }
+    }
 }
 }
 

src/conversion.rs

@@ -43,6 +43,7 @@ impl<F: WithSafety<Unsafe>> AsUnsafe for F {}
 
 cfg_tt::cfg_tt! {
 /// Helper trait that simplifies generic bounds when converting between funciton pointer types.
+// using has_abi_cdecl instead of stdcall, fastcall, thiscall is to reduce compile times
 pub trait Convertible:
     FnPtr
     + WithAbi<marker::Rust>
@@ -58,12 +59,12 @@ pub trait Convertible:
     #[cfg(has_abi_aapcs)](+ WithAbi<marker::AapcsUnwind>)
     #[cfg(has_abi_cdecl)](+ WithAbi<marker::Cdecl>)
     #[cfg(has_abi_cdecl)](+ WithAbi<marker::CdeclUnwind>)
-    #[cfg(has_abi_stdcall)](+ WithAbi<marker::Stdcall>)
-    #[cfg(has_abi_stdcall)](+ WithAbi<marker::StdcallUnwind>)
-    #[cfg(has_abi_fastcall)](+ WithAbi<marker::Fastcall>)
-    #[cfg(has_abi_fastcall)](+ WithAbi<marker::FastcallUnwind>)
-    #[cfg(has_abi_thiscall)](+ WithAbi<marker::Thiscall>)
-    #[cfg(has_abi_thiscall)](+ WithAbi<marker::ThiscallUnwind>)
+    #[cfg(has_abi_cdecl)](+ WithAbi<marker::Stdcall>)
+    #[cfg(has_abi_cdecl)](+ WithAbi<marker::StdcallUnwind>)
+    #[cfg(has_abi_cdecl)](+ WithAbi<marker::Fastcall>)
+    #[cfg(has_abi_cdecl)](+ WithAbi<marker::FastcallUnwind>)
+    #[cfg(has_abi_cdecl)](+ WithAbi<marker::Thiscall>)
+    #[cfg(has_abi_cdecl)](+ WithAbi<marker::ThiscallUnwind>)
     #[cfg(has_abi_vectorcall)](+ WithAbi<marker::Vectorcall>)
     #[cfg(has_abi_vectorcall)](+ WithAbi<marker::VectorcallUnwind>)
     #[cfg(has_abi_sysv64)](+ WithAbi<marker::SysV64>)
@@ -88,12 +89,12 @@ where
         #[cfg(has_abi_aapcs)](+ WithAbi<marker::AapcsUnwind>)
         #[cfg(has_abi_cdecl)](+ WithAbi<marker::Cdecl>)
         #[cfg(has_abi_cdecl)](+ WithAbi<marker::CdeclUnwind>)
-        #[cfg(has_abi_stdcall)](+ WithAbi<marker::Stdcall>)
-        #[cfg(has_abi_stdcall)](+ WithAbi<marker::StdcallUnwind>)
-        #[cfg(has_abi_fastcall)](+ WithAbi<marker::Fastcall>)
-        #[cfg(has_abi_fastcall)](+ WithAbi<marker::FastcallUnwind>)
-        #[cfg(has_abi_thiscall)](+ WithAbi<marker::Thiscall>)
-        #[cfg(has_abi_thiscall)](+ WithAbi<marker::ThiscallUnwind>)
+        #[cfg(has_abi_cdecl)](+ WithAbi<marker::Stdcall>)
+        #[cfg(has_abi_cdecl)](+ WithAbi<marker::StdcallUnwind>)
+        #[cfg(has_abi_cdecl)](+ WithAbi<marker::Fastcall>)
+        #[cfg(has_abi_cdecl)](+ WithAbi<marker::FastcallUnwind>)
+        #[cfg(has_abi_cdecl)](+ WithAbi<marker::Thiscall>)
+        #[cfg(has_abi_cdecl)](+ WithAbi<marker::ThiscallUnwind>)
         #[cfg(has_abi_vectorcall)](+ WithAbi<marker::Vectorcall>)
         #[cfg(has_abi_vectorcall)](+ WithAbi<marker::VectorcallUnwind>)
         #[cfg(has_abi_sysv64)](+ WithAbi<marker::SysV64>)
@@ -107,31 +108,65 @@ where
 /// the specified ABI.
 ///
 /// Accepts either:
-/// - an `Abi` value (e.g., `Abi::C`, `Abi::SysV64`), or
+/// - an [`Abi`](crate::marker::Abi) marker type (e.g., [`C`](crate::marker::C), [`SysV64`](crate::marker::SysV64)), or
 /// - a string literal (e.g., `"C"`, `"system"`, `"stdcall"`).
 ///
 /// # Examples
 ///
 /// ```rust
 /// # use fn_ptr::{with_abi, marker};
-/// type F = extern "C" fn(i32) -> i32;
+/// type F = with_abi!(marker::SysV64, extern "C" fn(i32) -> i32);
+/// // `F` is `extern "sysv64" fn(i32) -> i32`
 ///
-/// type G = with_abi!(marker::SysV64, F);
-/// // `G` is `extern "sysv64" fn(i32) -> i32`
-///
-/// type H = with_abi!("C", extern "system" fn());
-/// // `H` is `extern "C" fn()`
+/// type G = with_abi!("C", extern "system" fn());
+/// // `G` is `extern "C" fn()`
 /// ```
 #[macro_export]
 macro_rules! with_abi {
-    // ABI given as a path (Abi::C, Abi::SysV64, ...)
     ( $abi:path, $ty:ty ) => {
         <$ty as $crate::WithAbi<$abi>>::F
     };
 
-    // ABI given as a string literal
-    ( $abi_lit:tt, $ty:ty ) => {
-        <$ty as $crate::WithAbi<$crate::abi!($abi_lit)>>::F
+    ( $lit:tt, $ty:ty ) => {
+        <$ty as $crate::WithAbi<$crate::abi!($lit)>>::F
+    };
+}
+
+/// Construct a function-pointer type identical to the given one but using
+/// the specified safety.
+///
+/// Accepts either:
+/// - an [`Safety`](crate::marker::Safety) marker type ([`Safe`](crate::marker::Safe) or [`Unsafe`](crate::marker::Unsafe))
+/// - safety keyword (`safe` or `unsafe`).
+/// - a boolean literal.
+///
+/// # Examples
+///
+/// ```rust
+/// # use fn_ptr::{with_safety, marker};
+/// type F = with_safety!(marker::Safe, unsafe extern "C" fn(i32) -> i32);
+/// // `F` is `extern "C" fn(i32) -> i32`
+///
+/// type G = with_safety!(unsafe, fn());
+/// // `G` is `unsafe fn()`
+/// ```
+#[macro_export]
+macro_rules! with_safety {
+    ( safe, $ty:ty ) => {
+        $crate::with_safety!(@inner $crate::marker::Safe, $ty)
+    };
+    ( unsafe, $ty:ty ) => {
+        $crate::with_safety!(@inner $crate::marker::Unsafe, $ty)
+    };
+    ( $safety:path, $ty:ty ) => {
+        $crate::with_safety!(@inner $safety, $ty)
+    };
+    ( $safety:tt, $ty:ty ) => {
+        $crate::with_safety!(@inner $crate::safety!($safety), $ty)
+    };
+
+    ( @inner $safety:ty, $ty:ty ) => {
+        <$ty as $crate::WithSafety<$safety>>::F
     };
 }
 

src/impl.rs

@@ -85,7 +85,7 @@ macro_rules! impl_fn {
 
             const ARITY: ::core::primitive::usize = <Self::ArityMarker as $crate::marker::Arity>::N;
             const IS_SAFE: ::core::primitive::bool = <Self::SafetyMarker as $crate::marker::Safety>::IS_SAFE;
-            const ABI: $crate::Abi = <$crate::marker::$abi_ident as $crate::marker::Abi>::KIND;
+            const ABI: $crate::Abi = <$crate::marker::$abi_ident as $crate::marker::Abi>::VALUE;
             const IS_EXTERN: ::core::primitive::bool = !matches!(Self::ABI, $crate::Abi::Rust);
 
             fn as_ptr(&self) -> $crate::UntypedFnPtr {

src/lib.rs

@@ -15,9 +15,8 @@
 //!
 //! ### 1. Function Pointer Metadata
 //!
-//! Every function pointer automatically implements [`FnPtr`].
-//! Depending on the type, they also implement [`SafeFnPtr`], [`UnsafeFnPtr`], and [`HasAbi<Abi>`].
-//! With it you can inspect the type of function:
+//! Every function pointer automatically implements [`FnPtr`] as well as a bunch of other related traits.
+//! With these you can inspect the type of function pointers at compile time:
 //!
 //! ```rust
 //! use fn_ptr::{FnPtr, Abi};
@@ -70,14 +69,12 @@
 //! You can also change the ABI of a function pointer at the type level:
 //!
 //! ```rust
-//! # #[cfg(nightly_build)] {
 //! use fn_ptr::{with_abi, Abi};
 //!
 //! type F = extern "C" fn(i32) -> i32;
 //!
-//! type G = with_abi!(Abi::Sysv64, F);
+//! type G = with_abi!("sysv64", F);
 //! type H = with_abi!("C", extern "system" fn());
-//! # }
 //! ```
 //!
 //! Or at the instance level:
@@ -98,13 +95,11 @@
 //! For the conversion macros the crate relies on two traits: [`WithAbi`] and [`WithSafety`] that can also be used directly:
 //!
 //! ```rust
-//! # #[cfg(nightly_build)] {
-//! use fn_ptr::{FnPtr, WithAbi, WithSafety, Abi};
+//! use fn_ptr::{FnPtr, WithAbi, WithSafety, marker::{SysV64, Unsafe}};
 //!
 //! type F = extern "C" fn(i32);
-//! type G = <F as WithAbi<{Abi::Sysv64}>>::F;
-//! type U = <F as WithSafety<{false}>>::F;
-//! # }
+//! type G = <F as WithAbi<SysV64>>::F;
+//! type U = <F as WithSafety<Unsafe>>::F;
 //! ```
 //!
 //! ## License

src/marker.rs

@@ -64,7 +64,7 @@ pub trait Abi {
     const STR: &'static str;
 
     /// The runtime [`Abi`] that represent this marker type.
-    const KIND: crate::Abi;
+    const VALUE: crate::Abi;
 }
 
 /// Helper macro to implement [`Abi`].
@@ -78,7 +78,7 @@ macro_rules! define_abi_marker {
 
         impl Abi for $name {
             const STR: &'static str = $lit;
-            const KIND: $crate::Abi = $crate::Abi::from_str_const($lit).unwrap();
+            const VALUE: $crate::Abi = $crate::Abi::from_str_const($lit).unwrap();
         }
     };
 }