Add Bool newtype wrapper

BOOL differs across platforms, and usage requires a comparison to NO, so while this is a bit cumbersome, it's really the best way to ensure that they are handled properly.

Using the Encode impl for the built in `bool` is heavily discouraged, since that can easily lead to errors!

Author: madsmtm

objc2/src/bool.rs

@@ -0,0 +1,107 @@
+use objc2_sys::BOOL;
+
+use crate::{Encode, Encoding, RefEncode};
+use core::fmt;
+
+/// The Objective-C `BOOL` type.
+///
+/// To convert an Objective-C `BOOL` into a Rust [`bool`], call the one of the
+/// [`Bool::is_false`] or [`Bool::is_true`] methods.
+///
+/// This is FFI-safe and can be used in directly with
+/// [`msg_send!`][`crate::msg_send`].
+#[repr(transparent)]
+// TODO: Might have to implement some of these manually, in case someone puts
+// something that is not 0 or 1 into the Bool?
+#[derive(Copy, Clone, Default, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub struct Bool {
+    value: BOOL,
+}
+
+impl Bool {
+    /// The equivalent of [`true`] for Objective-C's `BOOL` type.
+    pub const YES: Self = Self::new(true);
+
+    /// The equivalent of [`false`] for Objective-C's `BOOL` type.
+    pub const NO: Self = Self::new(false);
+
+    /// Creates an Objective-C boolean from a Rust boolean.
+    #[inline]
+    pub const fn new(value: bool) -> Self {
+        // true as u8 => 1
+        // false as u8 => 0
+        let value = value as BOOL;
+        Self { value }
+    }
+
+    /// Creates this from a boolean value received from a raw Objective-C API.
+    #[inline]
+    pub const fn from_raw(value: BOOL) -> Self {
+        Self { value }
+    }
+
+    /// Retrieves the inner `objc2_sys` boolean type, to be used in raw
+    /// Objective-C APIs.
+    #[inline]
+    pub const fn as_raw(self) -> BOOL {
+        self.value
+    }
+
+    /// Returns `true` if `self` is [`NO`][`Self::NO`].
+    #[inline]
+    pub const fn is_false(self) -> bool {
+        // Always compare with 0
+        // This is what happens with the `!` operator in C.
+        self.value as u8 == 0
+    }
+
+    /// Returns `true` if `self` is the opposite of [`NO`][`Self::NO`].
+    #[inline]
+    pub const fn is_true(self) -> bool {
+        // Always compare with 0
+        // This is what happens when using `if` in C.
+        self.value as u8 != 0
+    }
+}
+
+impl From<BOOL> for Bool {
+    #[inline]
+    fn from(b: BOOL) -> Bool {
+        Bool::from_raw(b)
+    }
+}
+
+impl From<Bool> for BOOL {
+    #[inline]
+    fn from(b: Bool) -> BOOL {
+        b.as_raw()
+    }
+}
+
+impl From<bool> for Bool {
+    #[inline]
+    fn from(b: bool) -> Bool {
+        Bool::new(b)
+    }
+}
+
+impl From<Bool> for bool {
+    #[inline]
+    fn from(b: Bool) -> bool {
+        b.is_true()
+    }
+}
+
+impl fmt::Debug for Bool {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(if self.is_true() { "YES" } else { "NO" })
+    }
+}
+
+unsafe impl Encode for Bool {
+    const ENCODING: Encoding<'static> = BOOL::ENCODING;
+}
+
+unsafe impl RefEncode for Bool {
+    const ENCODING_REF: Encoding<'static> = Encoding::Pointer(&Self::ENCODING);
+}

objc2/src/declare.rs

@@ -38,7 +38,7 @@ use core::mem;
 use core::ptr;
 use std::ffi::CString;
 
-use crate::runtime::{self, Class, Imp, Object, Protocol, Sel, BOOL, NO};
+use crate::runtime::{self, Bool, Class, Imp, Object, Protocol, Sel};
 use crate::{Encode, EncodeArguments, Encoding, Message};
 
 /// Types that can be used as the implementation of an Objective-C method.
@@ -182,13 +182,13 @@ impl ClassDecl {
         );
 
         let types = method_type_encoding(&F::Ret::ENCODING, encs);
-        let success = runtime::class_addMethod(
+        let success = Bool::from_raw(runtime::class_addMethod(
             self.cls as _,
             sel.as_ptr() as _,
             Some(func.imp()),
             types.as_ptr(),
-        );
-        assert!(success != NO, "Failed to add method {:?}", sel);
+        ));
+        assert!(success.is_true(), "Failed to add method {:?}", sel);
     }
 
     /// Adds a class method with the given name and implementation.
@@ -217,13 +217,13 @@ impl ClassDecl {
 
         let types = method_type_encoding(&F::Ret::ENCODING, encs);
         let metaclass = (*self.cls).metaclass() as *const _ as *mut _;
-        let success = runtime::class_addMethod(
+        let success = Bool::from_raw(runtime::class_addMethod(
             metaclass,
             sel.as_ptr() as _,
             Some(func.imp()),
             types.as_ptr(),
-        );
-        assert!(success != NO, "Failed to add class method {:?}", sel);
+        ));
+        assert!(success.is_true(), "Failed to add class method {:?}", sel);
     }
 
     /// Adds an ivar with type `T` and the provided name.
@@ -236,16 +236,16 @@ impl ClassDecl {
         let encoding = CString::new(T::ENCODING.to_string()).unwrap();
         let size = mem::size_of::<T>();
         let align = log2_align_of::<T>();
-        let success = unsafe {
+        let success = Bool::from_raw(unsafe {
             runtime::class_addIvar(
                 self.cls as _,
                 c_name.as_ptr(),
                 size,
                 align,
                 encoding.as_ptr(),
             )
-        };
-        assert!(success != NO, "Failed to add ivar {}", name);
+        });
+        assert!(success.is_true(), "Failed to add ivar {}", name);
     }
 
     /// Adds the given protocol to self.
@@ -255,7 +255,8 @@ impl ClassDecl {
     /// If the protocol wasn't successfully added.
     pub fn add_protocol(&mut self, proto: &Protocol) {
         let success = unsafe { runtime::class_addProtocol(self.cls as _, proto.as_ptr()) };
-        assert!(success != NO, "Failed to add protocol {:?}", proto);
+        let success = Bool::from_raw(success).is_true();
+        assert!(success, "Failed to add protocol {:?}", proto);
     }
 
     /// Registers the [`ClassDecl`], consuming it, and returns a reference to
@@ -322,8 +323,8 @@ impl ProtocolDecl {
                 self.proto as _,
                 sel.as_ptr() as _,
                 types.as_ptr(),
-                is_required as BOOL,
-                is_instance_method as BOOL,
+                Bool::new(is_required).into(),
+                Bool::new(is_instance_method).into(),
             );
         }
     }

objc2/src/lib.rs

@@ -89,6 +89,7 @@ pub use crate::cache::CachedSel as __CachedSel;
 #[macro_use]
 mod macros;
 
+mod bool;
 mod cache;
 pub mod declare;
 mod encode;

objc2/src/runtime.rs

@@ -11,8 +11,6 @@ use malloc_buf::Malloc;
 use std::ffi::{CStr, CString};
 use std::os::raw::c_uint;
 
-use crate::Encode;
-
 #[allow(deprecated)]
 pub use objc2_sys::object_dispose;
 pub use objc2_sys::{
@@ -32,6 +30,9 @@ pub use objc2_sys::{
 };
 pub use objc2_sys::{BOOL, NO, YES};
 
+pub use super::bool::Bool;
+use crate::Encode;
+
 /// A type that represents a method selector.
 #[repr(transparent)]
 pub struct Sel {
@@ -292,7 +293,7 @@ impl Class {
 
     /// Checks whether this class conforms to the specified protocol.
     pub fn conforms_to(&self, proto: &Protocol) -> bool {
-        unsafe { class_conformsToProtocol(self.as_ptr(), proto.as_ptr()) == YES }
+        unsafe { Bool::from_raw(class_conformsToProtocol(self.as_ptr(), proto.as_ptr())).into() }
     }
 
     /// Get a list of the protocols to which this class conforms.
@@ -367,7 +368,7 @@ impl Protocol {
 
     /// Checks whether this protocol conforms to the specified protocol.
     pub fn conforms_to(&self, proto: &Protocol) -> bool {
-        unsafe { protocol_conformsToProtocol(self.as_ptr(), proto.as_ptr()) == YES }
+        unsafe { Bool::from_raw(protocol_conformsToProtocol(self.as_ptr(), proto.as_ptr())).into() }
     }
 
     /// Returns the name of self.
@@ -379,7 +380,7 @@ impl Protocol {
 
 impl PartialEq for Protocol {
     fn eq(&self, other: &Protocol) -> bool {
-        unsafe { protocol_isEqual(self.as_ptr(), other.as_ptr()) == YES }
+        unsafe { Bool::from_raw(protocol_isEqual(self.as_ptr(), other.as_ptr())).is_true() }
     }
 }
 

objc2_encode/README.md

@@ -28,23 +28,23 @@ use objc2_encode::{Encode, Encoding, RefEncode};
 #[repr(C)]
 struct MyObject {
     a: f32,
-    b: bool,
+    b: i16,
 }
 
 unsafe impl Encode for MyObject {
     const ENCODING: Encoding<'static> = Encoding::Struct(
         "MyObject",
-        &[f32::ENCODING, bool::ENCODING
-    ]);
+        &[f32::ENCODING, i16::ENCODING],
+    );
 }
 
-assert_eq!(&MyObject::ENCODING, "{MyObject=fB}");
+assert_eq!(&MyObject::ENCODING, "{MyObject=fs}");
 
 unsafe impl RefEncode for MyObject {
     const ENCODING_REF: Encoding<'static> = Encoding::Pointer(&Self::ENCODING);
 }
 
-assert_eq!(&MyObject::ENCODING_REF, "^{MyObject=fB}");
+assert_eq!(&MyObject::ENCODING_REF, "^{MyObject=fs}");
 ```
 
 An `Encoding` can be compared with an encoding string from the Objective-C

objc2_encode/src/encode.rs

@@ -37,7 +37,7 @@ use crate::Encoding;
 /// #[repr(C)]
 /// struct MyType {
 ///     a: i32,
-///     b: bool,
+///     b: f64,
 ///     c: *const c_void,
 /// }
 ///
@@ -49,7 +49,7 @@ use crate::Encoding;
 ///             // Delegate to field's implementations.
 ///             // The order is the same as in the definition.
 ///             i32::ENCODING,
-///             bool::ENCODING,
+///             f64::ENCODING,
 ///             <*const c_void>::ENCODING,
 ///         ],
 ///     );
@@ -160,14 +160,21 @@ encode_impls!(
     u64 => ULongLong,
     f32 => Float,
     f64 => Double,
-    bool => Bool,
     () => Void,
     *mut i8 => String,
     *const i8 => String,
     *mut u8 => String,
     *const u8 => String,
 );
 
+/// Using this directly is heavily discouraged, since the type of BOOL differs
+/// across platforms.
+///
+/// Use `objc2_sys::BOOL::ENCODING` or `objc2::runtime::Bool` instead.
+unsafe impl Encode for bool {
+    const ENCODING: Encoding<'static> = Encoding::Bool;
+}
+
 macro_rules! encode_impls_size {
     ($($t:ty => ($t16:ty, $t32:ty, $t64:ty),)*) => ($(
         #[doc = concat!("The encoding of [`", stringify!($t), "`] varies based on the target pointer width.")]

objc2_foundation/src/object.rs

@@ -3,7 +3,7 @@ use core::ptr::NonNull;
 
 use objc2::msg_send;
 use objc2::rc::{Id, Owned, Shared};
-use objc2::runtime::{Class, BOOL, NO};
+use objc2::runtime::{Bool, Class};
 use objc2::Message;
 
 use super::NSString;
@@ -25,8 +25,8 @@ pub trait INSObject: Any + Sized + Message {
     where
         T: INSObject,
     {
-        let result: BOOL = unsafe { msg_send![self, isEqual: other] };
-        result != NO
+        let result: Bool = unsafe { msg_send![self, isEqual: other] };
+        result.is_true()
     }
 
     fn description(&self) -> Id<NSString, Shared> {
@@ -38,8 +38,8 @@ pub trait INSObject: Any + Sized + Message {
     }
 
     fn is_kind_of(&self, cls: &Class) -> bool {
-        let result: BOOL = unsafe { msg_send![self, isKindOfClass: cls] };
-        result != NO
+        let result: Bool = unsafe { msg_send![self, isKindOfClass: cls] };
+        result.is_true()
     }
 
     fn new() -> Id<Self, Owned> {

objc2_sys/src/constants.rs

@@ -5,19 +5,11 @@ use std::os::raw::c_int;
 
 use crate::{id, Class, BOOL};
 
-#[cfg(not(target_arch = "aarch64"))]
 /// The equivalent of `true` for Objective-C's [`BOOL`][`super::BOOL`] type.
-pub const YES: BOOL = 1;
-#[cfg(target_arch = "aarch64")]
-/// The equivalent of `true` for Objective-C's [`BOOL`][`super::BOOL`] type.
-pub const YES: BOOL = true;
+pub const YES: BOOL = true as BOOL;
 
-#[cfg(not(target_arch = "aarch64"))]
-/// The equivalent of `false` for Objective-C's [`BOOL`][`super::BOOL`] type.
-pub const NO: BOOL = 0;
-#[cfg(target_arch = "aarch64")]
 /// The equivalent of `false` for Objective-C's [`BOOL`][`super::BOOL`] type.
-pub const NO: BOOL = false;
+pub const NO: BOOL = false as BOOL;
 
 /// A quick alias for a [`null_mut`][`core::ptr::null_mut`] object / instance.
 pub const nil: id = 0 as *mut _;