Push pointers in block typedefs up

This makes interacting with typedef'd blocks a lot safer, there
basically shouldn't be a need for `RcBlock::as_ptr` any more.

Author: madsmtm

crates/dispatch2/src/data.rs

@@ -21,7 +21,7 @@ impl DispatchData {
     #[inline]
     pub fn from_bytes(data: &[u8]) -> DispatchRetained<Self> {
         // TODO: Autogenerate?
-        const DISPATCH_DATA_DESTRUCTOR_DEFAULT: crate::dispatch_block_t = ptr::null_mut();
+        const DISPATCH_DATA_DESTRUCTOR_DEFAULT: Option<&crate::dispatch_block_t> = None;
 
         let ptr = NonNull::new(data.as_ptr().cast_mut()).unwrap().cast();
 
@@ -50,12 +50,10 @@ impl DispatchData {
         // We don't care which queue ends up running the destructor.
         let queue = None;
 
-        let destructor = (&*NOOP_BLOCK as *const block2::Block<_>).cast_mut();
-
         // SAFETY: Buffer pointer is valid for the given number of bytes.
         // Queue handle is valid, and the destructor is a NULL value which
         // indicates the buffer should be copied.
-        unsafe { Self::new(ptr, data.len(), queue, destructor) }
+        unsafe { Self::new(ptr, data.len(), queue, Some(&NOOP_BLOCK)) }
     }
 
     /// Creates a dispatch data object with ownership of the given contiguous
@@ -74,7 +72,6 @@ impl DispatchData {
             // dispatch_data_create().
             let _ = unsafe { alloc::boxed::Box::<[u8]>::from_raw(raw) };
         });
-        let destructor = block2::RcBlock::as_ptr(&destructor);
 
         // We don't care which queue ends up running the destructor.
         // Box<[u8]> is sendable, so it's fine for us to potentially pass it
@@ -84,7 +81,7 @@ impl DispatchData {
         // SAFETY: Buffer pointer is valid for the given number of bytes.
         //
         // The destructor is valid and correctly destroys the buffer.
-        unsafe { Self::new(ptr, data_len, queue, destructor) }
+        unsafe { Self::new(ptr, data_len, queue, Some(&destructor)) }
     }
 
     /// Copy all the non-contiguous parts of the data into a contiguous
@@ -114,23 +111,24 @@ impl DispatchData {
             },
         );
 
-        let block = block2::RcBlock::as_ptr(&block);
         // SAFETY: Transmute from return type `u8` to `bool` is safe, since we
         // only ever return `1` / `true`.
         // TODO: Fix the need for this in `block2`.
         let block = unsafe {
             core::mem::transmute::<
-                *mut block2::Block<
-                    dyn Fn(NonNull<DispatchData>, usize, NonNull<core::ffi::c_void>, usize) -> u8,
+                &'_ block2::Block<
+                    dyn Fn(NonNull<DispatchData>, usize, NonNull<core::ffi::c_void>, usize) -> u8
+                        + '_,
                 >,
-                *mut block2::Block<
-                    dyn Fn(NonNull<DispatchData>, usize, NonNull<core::ffi::c_void>, usize) -> bool,
+                &'_ block2::Block<
+                    dyn Fn(NonNull<DispatchData>, usize, NonNull<core::ffi::c_void>, usize) -> bool
+                        + '_,
                 >,
-            >(block)
+            >(&block)
         };
 
         // SAFETY: The block is implemented correctly.
-        unsafe { self.apply(block) };
+        self.apply(block);
         contents.take()
     }
 }
@@ -195,7 +193,7 @@ mod tests {
                 NonNull::new(data.as_ptr().cast_mut()).unwrap().cast(),
                 data.len(),
                 None,
-                RcBlock::as_ptr(&destructor),
+                Some(&destructor),
             )
         };
 

crates/dispatch2/translation-config.toml

@@ -275,6 +275,9 @@ fn.dispatch_allow_send_signals.unsafe = true
 fn.dispatch_semaphore_create.unsafe = false
 
 # The handler function must be correct.
+fn.dispatch_source_set_event_handler.unsafe = true
 fn.dispatch_source_set_event_handler_f.unsafe = true
+fn.dispatch_source_set_cancel_handler.unsafe = true
 fn.dispatch_source_set_cancel_handler_f.unsafe = true
+fn.dispatch_source_set_registration_handler.unsafe = true
 fn.dispatch_source_set_registration_handler_f.unsafe = true

crates/header-translator/src/rust_type.rs

@@ -1431,30 +1431,19 @@ impl PointeeTy {
     }
 
     fn is_cf_type(&self) -> bool {
-        match self {
-            // Recurse into typedefs
-            Self::TypeDef { to, .. } => to.is_cf_type(),
-            Self::CFTypeDef { .. } => true,
-            _ => false,
-        }
+        matches!(self.through_typedef(), Self::CFTypeDef { .. })
     }
 
     fn is_dispatch_type(&self) -> bool {
-        match self {
-            // Recurse into typedefs
-            Self::TypeDef { to, .. } => to.is_dispatch_type(),
-            Self::DispatchTypeDef { .. } => true,
-            _ => false,
-        }
+        matches!(self.through_typedef(), Self::DispatchTypeDef { .. })
     }
 
     fn is_network_type(&self) -> bool {
-        match self {
-            // Recurse into typedefs
-            Self::TypeDef { to, .. } => to.is_network_type(),
-            Self::NetworkTypeDef { .. } => true,
-            _ => false,
-        }
+        matches!(self.through_typedef(), Self::NetworkTypeDef { .. })
+    }
+
+    fn is_block_type(&self) -> bool {
+        matches!(self.through_typedef(), Self::Block { .. })
     }
 
     fn is_subtype_of(&self, other: &Self) -> bool {
@@ -2476,10 +2465,7 @@ impl Ty {
                             **pointee = Self::Pointee(PointeeTy::TypeDef { id, to });
                             return inner;
                         } else {
-                            error!(
-                                ?pointee,
-                                "is_object_like/is_cf_type/is_os_type but not Pointee"
-                            );
+                            error!(?pointee, "is_object_like but not Pointee");
                         }
                     }
                 } else {
@@ -2947,6 +2933,7 @@ impl Ty {
             || self.is_cf_type()
             || self.is_dispatch_type()
             || self.is_network_type()
+            || self.is_block_type()
     }
 
     /// Determine whether the inner type of a `Pointer` is object-like.
@@ -2985,6 +2972,15 @@ impl Ty {
         }
     }
 
+    /// Determine whether the inner type of a `Pointer` is a block.
+    fn is_block_type(&self) -> bool {
+        if let Self::Pointee(pointee_ty) = self.through_typedef() {
+            pointee_ty.is_block_type()
+        } else {
+            false
+        }
+    }
+
     /// Determine whether the pointee inside a `Pointer` is the inner
     /// struct/void type required for a type to be considered a CF type.
     ///
@@ -3257,13 +3253,23 @@ impl Ty {
                     write!(f, " -> Option<&'static {}>", pointee.behind_pointer(true))
                 }
             }
+            Self::Pointer {
+                nullability: _,
+                lifetime: _, // TODO
+                bounds: PointerBounds::Single,
+                pointee,
+                ..
+            } if pointee.is_block_type() => {
+                // TODO: Emit `RcBlock` or similar.
+                write!(f, " -> {}", self.plain(true))
+            }
             Self::Pointer {
                 nullability,
                 lifetime: _, // TODO: Use this somehow?
                 bounds: PointerBounds::Single,
                 pointee,
                 ..
-            } if pointee.is_object_like() && !pointee.is_static_object() => {
+            } if pointee.is_object_like() => {
                 // NOTE: We return CF types as `Retained` for now, since we
                 // don't have support for the CF wrapper in msg_send! yet.
                 if *nullability == Nullability::NonNull {
@@ -3324,7 +3330,7 @@ impl Ty {
                 bounds: PointerBounds::Single,
                 pointee,
                 ..
-            } if pointee.is_object_like() => {
+            } if pointee.is_object_like() && !pointee.is_block_type() => {
                 // NULL -> error
                 Box::new(move |f| {
                     write!(
@@ -4038,18 +4044,22 @@ impl Ty {
                     *no_escape = arg_no_escape;
                     arg_no_escape = false;
                 }
+                // Ignore `arg_no_escape` on typedefs for now.
+                Self::Pointee(PointeeTy::TypeDef { .. }) => {
+                    arg_no_escape = false;
+                }
                 _ => {}
             },
-            // Ignore typedefs for now
+            // Ignore `arg_no_escape` on typedefs for now.
             Self::TypeDef { .. } => {
-                arg_sendable = None;
                 arg_no_escape = false;
             }
             _ => {}
         }
 
         if arg_sendable.is_some() {
-            warn!(?ty, "did not consume sendable in argument");
+            // Important for soundness.
+            error!(?ty, "did not consume sendable in argument");
         }
 
         if arg_no_escape {
@@ -4347,7 +4357,8 @@ impl Ty {
 
     pub(crate) fn is_retainable(&self) -> bool {
         if let Self::Pointer { pointee, .. } = self {
-            pointee.is_object_like() && !pointee.is_static_object()
+            // Unsure if static items and blocks should be considered retainable?
+            pointee.is_object_like() && !pointee.is_static_object() && !pointee.is_block_type()
         } else {
             false
         }
@@ -4386,7 +4397,7 @@ impl Ty {
             Self::Struct { fields, .. } | Self::Union { fields, .. } => {
                 fields.iter().any(|(_, field)| field.needs_simd())
             }
-            Self::Pointee(
+            Self::Pointee(pointee) => match pointee.through_typedef() {
                 PointeeTy::Fn {
                     result_type,
                     arguments,
@@ -4396,8 +4407,9 @@ impl Ty {
                     result_type,
                     arguments,
                     ..
-                },
-            ) => result_type.needs_simd() || arguments.iter().any(|arg| arg.needs_simd()),
+                } => result_type.needs_simd() || arguments.iter().any(|arg| arg.needs_simd()),
+                _ => false,
+            },
             _ => false,
         }
     }

crates/objc2/src/topics/FRAMEWORKS_CHANGELOG.md

@@ -68,6 +68,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 * **BREAKING**: Use `Result<(), Retained<NSError>>` in more methods.
 * Fixed `SCContentSharingPickerConfiguration` having generics even though it shouldn't.
 * `NSArray`'s and `NSSet`'s `Debug` impl longer requires the `NSEnumerator` feature.
+* **BREAKING**: Type aliases now refer to the block instead of a pointer to the block.
+* **BREAKING**: Methods with blocks as type-aliases now take `&Block` instead of `*mut Block`.
 
 ## [0.3.2] - 2025-10-04
 [0.3.2]: https://github.com/madsmtm/objc2/compare/frameworks-0.3.1...frameworks-0.3.2

examples/metal/default_xcode_game/renderer.rs

@@ -322,9 +322,9 @@ impl Renderer {
 
         let block_sema = self.in_flight_semaphore().clone();
         unsafe {
-            command_buffer.addCompletedHandler(RcBlock::as_ptr(&RcBlock::new(move |_buffer| {
+            command_buffer.addCompletedHandler(&RcBlock::new(move |_buffer| {
                 block_sema.signal();
-            })))
+            }))
         };
 
         self.update_dynamic_buffer_state();

examples/metal/events/main.rs

@@ -44,13 +44,7 @@ fn main() {
         },
     );
 
-    unsafe {
-        shared_event.notifyListener_atValue_block(
-            &shared_event_listener,
-            2,
-            RcBlock::as_ptr(&notify_block),
-        )
-    };
+    unsafe { shared_event.notifyListener_atValue_block(&shared_event_listener, 2, &notify_block) };
 
     // Encode GPU work
     command_buffer.encodeSignalEvent_value(shared_event.as_ref(), 1);

examples/metal/raytracing/renderer.rs

@@ -433,7 +433,7 @@ impl Renderer {
         let block = block2::RcBlock::new(move |_| {
             sem.release();
         });
-        unsafe { command_buffer.addCompletedHandler(block2::RcBlock::as_ptr(&block)) };
+        unsafe { command_buffer.addCompletedHandler(&block) };
         let width = self.size.get().width as NSUInteger;
         let height = self.size.get().height as NSUInteger;
         let threads_per_thread_group = MTLSize {

framework-crates/objc2-av-foundation/translation-config.toml

@@ -69,3 +69,7 @@ class.AVPlayerInterstitialEvent.categories.MutableEvents.skipped = true
 
 # Breaks type-safety, you must check encodings before accessing a value.
 class.NSValue.unsafe = true
+
+# Must be unsafe, non-block parameters have `NS_SWIFT_SENDABLE` which we don't
+# know how to handle.
+class.AVContentKeySession.methods."processContentKeyRequestWithIdentifier:initializationData:options:".unsafe = true