Finish crate rewrite

Author: OpenByteDev

README.md

@@ -24,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 { unwind: false });
+assert_eq!(<F as FnPtr>::abi, Abi::C { unwind: false });
 ```
 
 There are also some const helper functons to do so ergonomically.
@@ -33,7 +33,7 @@ There are also some const helper functons to do so ergonomically.
 const A: usize = fn_ptr::arity::<F>();         // 2
 const SAFE: bool = fn_ptr::is_safe::<F>();     // true
 const EXT: bool = fn_ptr::is_extern::<F>();    // true
-const ABI: Abi = fn_ptr::abi::<F>();           // Abi::C
+const abi: Abi = fn_ptr::abi::<F>();           // Abi::C
 ```
 
 ### 2. Toggle Function Pointer Safety
@@ -60,7 +60,7 @@ let safe_add2: fn(i32, i32) -> i32 = unsafe { unsafe_add.as_safe() };
 
 ### 3. Changing ABIs
 
-You can also change the ABI of a function pointer at the type level:
+You can also change the abi of a function pointer at the type level:
 
 ```rust
 use fn_ptr::{with_abi, Abi};
@@ -80,7 +80,7 @@ let rust_add: fn(i32, i32) -> i32 = |a, b| {a + b};
 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.
+Note that this does not change the underlying abi and should be used with caution.
 
 ## How It Works
 

src/abi.rs

@@ -1,12 +1,12 @@
 use crate::AbiValue;
 
-/// Type-level marker trait for function ABI.
+/// Type-level marker trait for function abi.
 ///
-/// Types implementing this trait represent a specific `extern "..."` ABI.
+/// Types implementing this trait represent a specific `extern "..."` abi.
 ///
 /// See [`Abi`] for the runtime representation.
 pub trait Abi {
-    /// The exact ABI string used in `extern "..."`.
+    /// The exact abi string used in `extern "..."`.
     const STR: &'static str;
 
     /// The runtime [`Abi`] that represent this marker type.
@@ -22,7 +22,7 @@ macro_rules! define_abi_marker {
         #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
         #[doc = "Type-level marker for the `"]
         #[doc = $lit]
-        #[doc = "` ABI."]
+        #[doc = "` abi."]
         pub struct $name;
 
         impl Abi for $name {
@@ -63,7 +63,7 @@ define_abi_marker!(SysV64Unwind, "sysv64-unwind");
 define_abi_marker!(Win64, "win64");
 define_abi_marker!(Win64Unwind, "win64-unwind");
 
-/// Macro to convert an ABI string to the corrsponding [`Abi`] marker type.
+/// Macro to convert an abi string to the corresponding [`Abi`] marker type.
 #[macro_export]
 macro_rules! abi {
     // Common

src/abi_value.rs

@@ -3,69 +3,69 @@ use core::{
     str::FromStr,
 };
 
-/// The ABI or calling convention of a function pointer.
+/// The abi or calling convention of a function pointer.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 // from https://github.com/rust-lang/rust/blob/4fa80a5e733e2202d7ca4c203c2fdfda41cfe7dc/compiler/rustc_abi/src/extern_abi.rs#L21
 pub enum AbiValue {
     /* universal */
     /// This is the same as `extern fn foo()`; whatever the default your C compiler supports.
     C {
-        /// Whether unwinding across this ABI boundary is allowed (`*-unwind`).
+        /// Whether unwinding across this abi boundary is allowed (`*-unwind`).
         unwind: bool,
     },
     /// Usually the same as [`extern "C"`](AbiValue::C), except on Win32, in which case it's
     /// [`"stdcall"`](AbiValue::Stdcall), or what you should use to link to the Windows API itself.
     System {
-        /// Whether unwinding across this ABI boundary is allowed (`*-unwind`).
+        /// Whether unwinding across this abi boundary is allowed (`*-unwind`).
         unwind: bool,
     },
 
-    /// The default ABI when you write a normal `fn foo()` in any Rust code.
+    /// The default abi when you write a normal `fn foo()` in any Rust code.
     Rust,
 
     /* arm */
     /// The default for ARM.
     Aapcs {
-        /// Whether unwinding across this ABI boundary is allowed (`*-unwind`).
+        /// Whether unwinding across this abi boundary is allowed (`*-unwind`).
         unwind: bool,
     },
 
     /* x86 */
     /// The default for `x86_32` C code.
     Cdecl {
-        /// Whether unwinding across this ABI boundary is allowed (`*-unwind`).
+        /// Whether unwinding across this abi boundary is allowed (`*-unwind`).
         unwind: bool,
     },
     /// The default for the Win32 API on `x86_32`.
     Stdcall {
-        /// Whether unwinding across this ABI boundary is allowed (`*-unwind`).
+        /// Whether unwinding across this abi boundary is allowed (`*-unwind`).
         unwind: bool,
     },
-    /// The `fastcall` ABI.
+    /// The `fastcall` abi.
     Fastcall {
-        /// Whether unwinding across this ABI boundary is allowed (`*-unwind`).
+        /// Whether unwinding across this abi boundary is allowed (`*-unwind`).
         unwind: bool,
     },
-    /// The Windows C++ ABI.
+    /// The Windows C++ abi.
     Thiscall {
-        /// Whether unwinding across this ABI boundary is allowed (`*-unwind`).
+        /// Whether unwinding across this abi boundary is allowed (`*-unwind`).
         unwind: bool,
     },
-    /// The `vectorcall` ABI.
+    /// The `vectorcall` abi.
     Vectorcall {
-        /// Whether unwinding across this ABI boundary is allowed (`*-unwind`).
+        /// Whether unwinding across this abi boundary is allowed (`*-unwind`).
         unwind: bool,
     },
 
     /* x86_64 */
     /// The default for C code on non-Windows `x86_64`.
     SysV64 {
-        /// Whether unwinding across this ABI boundary is allowed (`*-unwind`).
+        /// Whether unwinding across this abi boundary is allowed (`*-unwind`).
         unwind: bool,
     },
     /// The default for C code on `x86_64` Windows.
     Win64 {
-        /// Whether unwinding across this ABI boundary is allowed (`*-unwind`).
+        /// Whether unwinding across this abi boundary is allowed (`*-unwind`).
         unwind: bool,
     },
 }
@@ -89,12 +89,12 @@ impl AbiValue {
         }
     }
 
-    /// Canonicalize this ABI for the current target.
+    /// Canonicalize this abi for the current target.
     ///
-    /// Maps aliases (e.g. `system`, `cdecl`) to the concrete ABI actually used on
+    /// Maps aliases (e.g. `system`, `cdecl`) to the concrete abi actually used on
     /// the current OS/architecture, following Rust compiler rules.
     ///
-    /// Returns [`None`] if this ABI is not supported on the current target.
+    /// Returns [`None`] if this abi is not supported on the current target.
     #[must_use]
     pub fn canonize(self, has_c_varargs: bool) -> Option<AbiValue> {
         // from https://github.com/rust-lang/rust/blob/4fa80a5e733e2202d7ca4c203c2fdfda41cfe7dc/compiler/rustc_target/src/spec/abi_map.rs#L79
@@ -165,7 +165,7 @@ macro_rules! abi_kind_impl {
         }
     ) => {
         impl $t {
-            /// Returns the string representation of this ABI.
+            /// Returns the string representation of this abi.
             #[must_use]
             pub const fn to_str(&self) -> &'static str {
                 match self {

src/base.rs

@@ -5,7 +5,8 @@ use core::{
 };
 
 use crate::{
-    AsSafe, AsUnsafe, WithAbi, WithArgs, WithOutput, WithSafety, abi,
+    WithAbi, WithAbiImpl, WithArgs, WithArgsImpl, WithOutput, WithOutputImpl, WithSafety,
+    WithSafetyImpl, abi,
     abi_value::AbiValue,
     safety::{self, Safe, Unsafe},
     tuple::Tuple,
@@ -19,6 +20,8 @@ ffi_opaque::opaque! {
 /// Type alias for a raw untyped function pointer.
 pub type UntypedFnPtr = *const OpaqueFn;
 
+cfg_tt::cfg_tt! {}
+
 cfg_tt::cfg_tt! {
 /// Marker trait for all function pointers.
 pub trait FnPtr:
@@ -37,8 +40,32 @@ pub trait FnPtr:
     + UnwindSafe
     + RefUnwindSafe
     + Sized
-    #[cfg(nightly_build)]
-    (+ core::marker::FnPtr)
+    + WithOutputImpl
+    + WithArgsImpl
+    + WithSafetyImpl<safety::Safe>
+    + WithSafetyImpl<safety::Unsafe>
+    + WithAbiImpl<abi::Rust>
+    + WithAbiImpl<abi::C>
+    + WithAbiImpl<abi::CUnwind>
+    + WithAbiImpl<abi::System>
+    + WithAbiImpl<abi::SystemUnwind>
+    #[cfg(nightly_build)](+ core::marker::FnPtr)
+    #[cfg(has_abi_aapcs)](+ WithAbiImpl<abi::Aapcs>)
+    #[cfg(has_abi_aapcs)](+ WithAbiImpl<abi::AapcsUnwind>)
+    #[cfg(has_abi_cdecl)](+ WithAbiImpl<abi::Cdecl>)
+    #[cfg(has_abi_cdecl)](+ WithAbiImpl<abi::CdeclUnwind>)
+    #[cfg(has_abi_cdecl)](+ WithAbiImpl<abi::Stdcall>)
+    #[cfg(has_abi_cdecl)](+ WithAbiImpl<abi::StdcallUnwind>)
+    #[cfg(has_abi_cdecl)](+ WithAbiImpl<abi::Fastcall>)
+    #[cfg(has_abi_cdecl)](+ WithAbiImpl<abi::FastcallUnwind>)
+    #[cfg(has_abi_cdecl)](+ WithAbiImpl<abi::Thiscall>)
+    #[cfg(has_abi_cdecl)](+ WithAbiImpl<abi::ThiscallUnwind>)
+    #[cfg(has_abi_vectorcall)](+ WithAbiImpl<abi::Vectorcall>)
+    #[cfg(has_abi_vectorcall)](+ WithAbiImpl<abi::VectorcallUnwind>)
+    #[cfg(has_abi_sysv64)](+ WithAbiImpl<abi::SysV64>)
+    #[cfg(has_abi_sysv64)](+ WithAbiImpl<abi::SysV64Unwind>)
+    #[cfg(has_abi_win64)](+ WithAbiImpl<abi::Win64>)
+    #[cfg(has_abi_win64)](+ WithAbiImpl<abi::Win64Unwind>)
 {
     /// The argument types as a tuple.
     type Args: Tuple;
@@ -61,7 +88,7 @@ pub trait FnPtr:
     /// Whether the function pointer uses an extern calling convention.
     const IS_EXTERN: bool;
 
-    /// The ABI associated with this function pointer.
+    /// The abi associated with this function pointer.
     const ABI: AbiValue;
 
     /// Returns the address of this function.
@@ -99,10 +126,7 @@ pub trait FnPtr:
 
     /// Produces an unsafe version of this function pointer.
     #[must_use]
-    fn as_unsafe(&self) -> <Self as AsUnsafe>::F
-    where
-        Self: AsUnsafe,
-    {
+    fn as_unsafe(&self) -> <Self as WithSafety<Unsafe>>::F {
         unsafe { FnPtr::from_ptr(self.as_ptr()) }
     }
 
@@ -111,10 +135,7 @@ pub trait FnPtr:
     /// # Safety
     /// Caller must ensure the underlying function is actually safe to call.
     #[must_use]
-    unsafe fn as_safe(&self) -> <Self as AsSafe>::F
-    where
-        Self: AsSafe,
-    {
+    unsafe fn as_safe(&self) ->  <Self as WithSafety<Safe>>::F {
         self.cast()
     }
 
@@ -130,10 +151,10 @@ pub trait FnPtr:
         self.cast()
     }
 
-    /// Produces a version of this function pointer with the given ABI.
+    /// Produces a version of this function pointer with the given abi.
     ///
     /// # Safety
-    /// Caller must ensure that the resulting ABI transformation is sound.
+    /// Caller must ensure that the resulting abi transformation is sound.
     #[must_use]
     unsafe fn with_abi<Abi: abi::Abi>(&self) -> <Self as WithAbi<Abi>>::F
     where
@@ -147,7 +168,7 @@ pub trait FnPtr:
     /// # Safety
     /// Caller must ensure that the resulting transformation is sound.
     #[must_use]
-    unsafe fn with_ret<Output>(&self) -> <Self as WithOutput<Output>>::F
+    unsafe fn with_output<Output>(&self) -> <Self as WithOutput<Output>>::F
     where
         Self: WithOutput<Output>,
     {
@@ -212,3 +233,22 @@ pub trait UnsafeFnPtr: FnPtr<Safety = Unsafe> {
 /// The return type and all parameter types have to be `'static`.
 pub trait StaticFnPtr: FnPtr + 'static {}
 impl<F: FnPtr + 'static> StaticFnPtr for F {}
+
+#[cfg(test)]
+#[allow(unused)]
+mod test {
+    use super::*;
+
+    fn h<F: FnPtr>(f: F) -> crate::with_abi!("system", F) {
+        unsafe { f.cast() }
+    }
+    fn f<F: FnPtr>(f: F) -> crate::with_safety!(unsafe, F) {
+        unsafe { f.cast() }
+    }
+    fn j<F: FnPtr>(f: F) -> crate::with_output!(i32, F) {
+        unsafe { f.cast() }
+    }
+    fn k<F: FnPtr>(f: F) -> crate::with_args!((i32,), F) {
+        unsafe { f.cast() }
+    }
+}

src/build.rs

@@ -1,19 +1,14 @@
-use crate::{
-    FnPtr, Tuple, WithAbi, WithArgs, WithOutput, WithSafety,
-    abi::{self, Rust},
-    safety::{self, Safe},
-};
+use crate::{FnPtr, Tuple, abi::Rust, safety::Safe};
 
 /// Constructs a function-pointer type from its components.
 ///
 /// Given
 /// - a tuple of argument types (`Self`)
 /// - a safety marker ([`Safety`](crate::safety::Safety))
-/// - an ABI ([`Abi`](crate::abi::Abi))
+/// - an abi ([`Abi`](crate::abi::Abi))
 /// - an output type (`Output`)
 ///
-/// The trait is implemented for tuples of argument types and produces the
-/// corresponding function-pointer type via the associated type [`F`](BuildFn::F).
+/// The trait is implemented for tuples, which get turned into the parameter types of [`F`](BuildFn::F).
 ///
 /// # Examples
 ///
@@ -28,6 +23,10 @@ pub trait BuildFn<Safety = Safe, Abi = Rust, Output = ()>: Tuple {
     type F: FnPtr<Args = Self, Output = Output, Safety = Safety, Abi = Abi>;
 }
 
+/*
+These blanket impls could replace a large portion of impl.rs but would lead to
+additional bounds when using the traits.
+
 impl<G: FnPtr, Args: BuildFn<G::Safety, G::Abi, G::Output>> WithArgs<Args> for G {
     type F = <Args as BuildFn<G::Safety, G::Abi, G::Output>>::F;
 }
@@ -52,3 +51,4 @@ where
 {
     type F = <G::Args as BuildFn<G::Safety, Abi, G::Output>>::F;
 }
+*/