Decouple objc2 CF helper impls from objc2-core-foundation

This allows compiling `objc2-io-bluetooth-ui` without having to enable
the `objc2-core-foundation` feature of `objc2-io-bluetooth`.

Author: madsmtm

Cargo.lock

@@ -2042,7 +2042,7 @@ impl Stmt {
             }
             Self::OpaqueDecl { is_cf, .. } => {
                 if *is_cf {
-                    vec![ItemTree::cf("cf_type")]
+                    vec![ItemTree::cf("cf_type"), ItemTree::objc("cf_objc2_type")]
                 } else {
                     vec![ItemTree::objc("Encoding")]
                 }
@@ -3094,7 +3094,6 @@ impl Stmt {
                         // SAFETY: The type is a CoreFoundation type, and
                         // correctly declared as a #[repr(C)] ZST.
                         writeln!(f, "cf_type!(")?;
-                        writeln!(f, "    #[encoding_name = {encoding_name:?}]")?;
 
                         // SAFETY: It's fine to implement helper traits for
                         // all generics (e.g. all of `CFArray<u32>`,
@@ -3114,6 +3113,22 @@ impl Stmt {
                         }
                         writeln!(f, " {{}}")?;
                         writeln!(f, ");")?;
+
+                        let required_items = self
+                            .required_items()
+                            .chain(iter::once(ItemTree::objc("cf_objc2_type")));
+                        let cfg_objc2 = self.cfg_gate_ln_for(required_items, config);
+                        write!(f, "{cfg_objc2}")?;
+                        writeln!(f, "cf_objc2_type!(")?;
+                        // SAFETY: The type is a CoreFoundation type.
+                        writeln!(
+                            f,
+                            "    unsafe impl{} RefEncode<{encoding_name:?}> for {}{} {{}}",
+                            GenericParamsHelper(generics, "?Sized"),
+                            id.name,
+                            GenericTyHelper(generics),
+                        )?;
+                        writeln!(f, ");")?;
                     } else {
                         let required_items = self
                             .required_items()

crates/header-translator/src/stmt.rs

@@ -10,6 +10,6 @@ pub use crate::runtime::{
     AnyClass, AnyObject, AnyProtocol, Bool, Imp, NSObject, NSObjectProtocol, ProtocolObject, Sel,
 };
 pub use crate::{
-    extern_class, extern_methods, extern_protocol, ClassType, MainThreadMarker, MainThreadOnly,
-    Message, ProtocolType,
+    cf_objc2_type, extern_class, extern_methods, extern_protocol, ClassType, MainThreadMarker,
+    MainThreadOnly, Message, ProtocolType,
 };

crates/objc2/src/__framework_prelude.rs

@@ -6,7 +6,7 @@ pub use core::default::Default;
 pub use core::fmt;
 pub use core::hash::{Hash, Hasher};
 pub use core::marker::{PhantomData, Sized};
-pub use core::mem::{size_of, ManuallyDrop, MaybeUninit};
+pub use core::mem::{size_of, transmute, ManuallyDrop, MaybeUninit};
 pub use core::ops::Deref;
 pub use core::option::Option::{self, None, Some};
 pub use core::primitive::{bool, isize, str, u8};

crates/objc2/src/__macro_helpers/mod.rs

@@ -0,0 +1,47 @@
+/// Helper macro for implementing [`objc2`][crate] traits for
+/// CoreFoundation-like types.
+#[doc(hidden)] // For now, though still a breaking change to modify
+#[macro_export]
+macro_rules! cf_objc2_type {
+    (unsafe impl $(<$($generic:ident : ?$sized:ident),* $(,)?>)? RefEncode<$encoding_name:literal> for $ty:ty {}) => {
+        // SAFETY: Caller upholds that the struct is a ZST type, and
+        // represents a C struct with the given encoding.
+        unsafe impl $(<$($generic : ?$sized),*>)? $crate::encode::RefEncode for $ty {
+            const ENCODING_REF: $crate::encode::Encoding = $crate::encode::Encoding::Pointer(
+                &$crate::encode::Encoding::Struct($encoding_name, &[]),
+            );
+        }
+
+        // SAFETY: CF types are message-able in the Objective-C runtime.
+        //
+        // (Yes, even e.g. `CFArray<u32>`, though the return type from methods
+        // might not be what's expected).
+        unsafe impl $(<$($generic : ?$sized),*>)? $crate::Message for $ty {}
+
+        // Allow converting to AnyObject.
+        // Similar to __extern_class_impl_as_ref_borrow!
+        impl $(<$($generic : ?$sized),*>)? $crate::__macro_helpers::AsRef<$crate::runtime::AnyObject> for $ty {
+            #[inline]
+            fn as_ref(&self) -> &$crate::runtime::AnyObject {
+                // SAFETY: CF types are valid to re-interpret as AnyObject.
+                unsafe { $crate::__macro_helpers::transmute(self) }
+            }
+        }
+
+        impl $(<$($generic : ?$sized),*>)? $crate::__macro_helpers::Borrow<$crate::runtime::AnyObject> for $ty {
+            #[inline]
+            fn borrow(&self) -> &$crate::runtime::AnyObject {
+                <Self as $crate::__macro_helpers::AsRef<$crate::runtime::AnyObject>>::as_ref(self)
+            }
+        }
+
+        // Do not implement `ClassType`, CoreFoundation objects are root
+        // objects, and all inherit from the same (hidden) __NSCFType class.
+        //
+        // This also means that casting etc. must be implemented differently
+        // for CoreFoundation objects (compare).
+
+        // NOTE: Make sure to keep objc2-core-foundation/src/base.rs up to
+        // date with changes in here.
+    };
+}

crates/objc2/src/macros/cf_objc2_type.rs

@@ -4,6 +4,7 @@ mod __method_msg_send;
 mod __msg_send_parse;
 mod __rewrite_self_param;
 mod available;
+mod cf_objc2_type;
 mod define_class;
 mod extern_class;
 mod extern_methods;

crates/objc2/src/macros/mod.rs

@@ -188,7 +188,32 @@ impl hash::Hash for CFType {
     }
 }
 
-crate::__cf_type_objc2!(impl () CFType, crate::__cf_macro_helpers::Encoding::Void);
+// SAFETY: CFType is defined as the following in the header:
+// typedef const CF_BRIDGED_TYPE(id) void * CFTypeRef;
+#[cfg(feature = "objc2")]
+unsafe impl objc2::encode::RefEncode for CFType {
+    const ENCODING_REF: objc2::encode::Encoding =
+        objc2::encode::Encoding::Pointer(&objc2::encode::Encoding::Void);
+}
+
+// SAFETY: CF types are message-able in the Objective-C runtime.
+#[cfg(feature = "objc2")]
+unsafe impl objc2::Message for CFType {}
+
+#[cfg(feature = "objc2")]
+impl AsRef<objc2::runtime::AnyObject> for CFType {
+    fn as_ref(&self) -> &objc2::runtime::AnyObject {
+        // SAFETY: CFType is valid to re-interpret as AnyObject.
+        unsafe { core::mem::transmute(self) }
+    }
+}
+
+#[cfg(feature = "objc2")]
+impl core::borrow::Borrow<objc2::runtime::AnyObject> for CFType {
+    fn borrow(&self) -> &objc2::runtime::AnyObject {
+        <Self as AsRef<objc2::runtime::AnyObject>>::as_ref(self)
+    }
+}
 
 // NOTE: impl AsRef<CFType> for AnyObject would probably not be valid, since
 // not all Objective-C objects can be used as CoreFoundation objects (?)

framework-crates/objc2-core-foundation/src/base.rs

@@ -29,7 +29,6 @@
 #[macro_export]
 macro_rules! cf_type {
     (
-        #[encoding_name = $encoding_name:expr]
         unsafe impl $(<$($generic:ident : ?$sized:ident),* $(,)?>)? $ty:ident $(<$($generic_param:ident),* $(,)?>)? $(: $superclass:ty)? {}
     ) => {
         // Reflexive AsRef impl.
@@ -46,12 +45,6 @@ macro_rules! cf_type {
         $crate::__cf_type_needs_cf_base!(impl ($(<$($generic : ?$sized),*>)?) $ty $(<$($generic_param),*>)?);
 
         $crate::__cf_type_superclass!(impl ($(<$($generic : ?$sized),*>)?) $ty $(<$($generic_param),*>)? $(: $superclass)?);
-
-        // Objective-C interop
-        $crate::__cf_type_objc2!(
-            impl ($(<$($generic : ?$sized),*>)?) $ty $(<$($generic_param),*>)?,
-            $crate::__cf_macro_helpers::Encoding::Struct($encoding_name, &[])
-        );
     };
 }
 
@@ -182,53 +175,3 @@ macro_rules! __cf_type_no_superclass {
 macro_rules! __cf_type_no_superclass {
     (impl ($($generics:tt)*) $ty:ty) => {};
 }
-
-#[cfg(feature = "objc2")]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __cf_type_objc2 {
-    (impl ($($generics:tt)*) $ty:ty, $encoding:expr) => {
-        // SAFETY: Caller upholds that the struct is a ZST type, and
-        // represents a C struct with the given encoding.
-        unsafe impl $($generics)* $crate::__cf_macro_helpers::RefEncode for $ty {
-            const ENCODING_REF: $crate::__cf_macro_helpers::Encoding =
-                $crate::__cf_macro_helpers::Encoding::Pointer(&$encoding);
-        }
-
-        // SAFETY: CF types are message-able in the Objective-C runtime.
-        //
-        // (Yes, even e.g. `CFArray<u32>`, though the return type from methods
-        // might not be what's expected).
-        unsafe impl $($generics)* $crate::__cf_macro_helpers::Message for $ty {}
-
-        // Allow converting to AnyObject.
-        // Similar to objc2::__extern_class_impl_as_ref_borrow!
-        impl $($generics)* $crate::__cf_macro_helpers::AsRef<$crate::__cf_macro_helpers::AnyObject> for $ty {
-            #[inline]
-            fn as_ref(&self) -> &$crate::__cf_macro_helpers::AnyObject {
-                // SAFETY: CF types are valid to re-interpret as AnyObject.
-                unsafe { $crate::__cf_macro_helpers::transmute(self) }
-            }
-        }
-
-        impl $($generics)* $crate::__cf_macro_helpers::Borrow<$crate::__cf_macro_helpers::AnyObject> for $ty {
-            #[inline]
-            fn borrow(&self) -> &$crate::__cf_macro_helpers::AnyObject {
-                <Self as $crate::__cf_macro_helpers::AsRef<$crate::__cf_macro_helpers::AnyObject>>::as_ref(self)
-            }
-        }
-
-        // Do not implement `ClassType`, CoreFoundation objects are root
-        // objects, and all inherit from the same (hidden) __NSCFType class.
-        //
-        // This also means that casting etc. must be implemented differently
-        // for CoreFoundation objects (compare).
-    };
-}
-
-#[cfg(not(feature = "objc2"))]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __cf_type_objc2 {
-    ($($t:tt)*) => {};
-}

framework-crates/objc2-core-foundation/src/cf_type.rs

@@ -10,14 +10,10 @@ pub struct IOSurfaceRef {
 
 #[cfg(feature = "objc2-core-foundation")]
 objc2_core_foundation::cf_type!(
-    #[encoding_name = "__IOSurface"]
     unsafe impl IOSurfaceRef {}
 );
 
-// Hacky fix for `IOSurfaceRef` being used without `objc2-core-foundation`
-// being enabled.
-#[cfg(all(not(feature = "objc2-core-foundation"), feature = "objc2"))]
-unsafe impl objc2::encode::RefEncode for IOSurfaceRef {
-    const ENCODING_REF: objc2::encode::Encoding =
-        objc2::encode::Encoding::Pointer(&objc2::encode::Encoding::Struct("__IOSurface", &[]));
-}
+#[cfg(feature = "objc2")]
+objc2::cf_objc2_type!(
+    unsafe impl RefEncode<"__IOSurface"> for IOSurfaceRef {}
+);