Inline basically all dispatch2 wrapper functions

Fixes #816, at least well enough
that you can build rustc on macOS 10.12 host.

(`invoke_dispatch_once` still isn't inlined, but that's fine, it's
generic, so it won't get instantiated unless it's used).

Author: madsmtm

crates/dispatch2/CHANGELOG.md

@@ -8,6 +8,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### Fixed
 - Fixed reference counting in `DispatchSemaphoreGuard::release`.
+- Inlined more functions. This should allow using this library on macOS 10.12 with `crate-type = ["dylib"]`.
 
 
 ## [0.3.0] - 2025-04-19

crates/dispatch2/src/data.rs

@@ -16,6 +16,7 @@ impl DispatchData {
     // pub const EMPTY: &Self = _dispatch_data_empty;
 
     /// Get an empty [`DispatchData`].
+    #[inline]
     pub fn empty() -> &'static Self {
         // SAFETY: The static is valid.
         unsafe { &_dispatch_data_empty }
@@ -24,6 +25,7 @@ impl DispatchData {
     /// Creates a dispatch data object with a copy of the given contiguous
     /// buffer of memory.
     #[cfg(feature = "block2")]
+    #[inline]
     pub fn from_bytes(data: &[u8]) -> DispatchRetained<Self> {
         // TODO: Autogenerate?
         const DISPATCH_DATA_DESTRUCTOR_DEFAULT: crate::dispatch_block_t = ptr::null_mut();
@@ -44,6 +46,7 @@ impl DispatchData {
     /// Creates a dispatch data object with a reference to the given
     /// contiguous buffer of memory.
     #[cfg(feature = "block2")]
+    #[inline]
     pub fn from_static_bytes(data: &'static [u8]) -> DispatchRetained<Self> {
         block2::global_block! {
             static NOOP_BLOCK = || {}
@@ -66,6 +69,7 @@ impl DispatchData {
     /// buffer of memory.
     #[cfg(feature = "alloc")]
     #[cfg(feature = "block2")]
+    #[inline]
     pub fn from_boxed(data: alloc::boxed::Box<[u8]>) -> DispatchRetained<Self> {
         let data_len = data.len();
         let raw = alloc::boxed::Box::into_raw(data);
@@ -104,6 +108,7 @@ impl DispatchData {
     #[cfg(feature = "alloc")]
     #[cfg(feature = "block2")]
     #[cfg(feature = "objc2")]
+    #[inline]
     pub fn to_vec(&self) -> alloc::vec::Vec<u8> {
         let contents = core::cell::RefCell::new(alloc::vec::Vec::new());
         let block = block2::RcBlock::new(

crates/dispatch2/src/group.rs

@@ -18,6 +18,7 @@ dispatch_object_not_data!(unsafe DispatchGroup);
 
 impl DispatchGroup {
     /// Submit a function to a [`DispatchQueue`] and associates it with the [`DispatchGroup`].
+    #[inline]
     pub fn exec_async<F>(&self, queue: &DispatchQueue, work: F)
     where
         // We need `'static` to make sure any referenced values are borrowed for
@@ -35,6 +36,7 @@ impl DispatchGroup {
     /// # Errors
     ///
     /// Return [WaitError::Timeout] in case of timeout.
+    #[inline]
     pub fn wait(&self, timeout: DispatchTime) -> Result<(), WaitError> {
         let result = dispatch_group_wait(self, timeout);
 
@@ -45,6 +47,7 @@ impl DispatchGroup {
     }
 
     /// Schedule a function to be submitted to a [`DispatchQueue`] when a group of previously submitted functions have completed.
+    #[inline]
     pub fn notify<F>(&self, queue: &DispatchQueue, work: F)
     where
         F: Send + FnOnce(),
@@ -58,6 +61,7 @@ impl DispatchGroup {
     }
 
     /// Explicitly indicates that the function has entered the [`DispatchGroup`].
+    #[inline]
     pub fn enter(&self) -> DispatchGroupGuard {
         // SAFETY: TODO: Is it a soundness requirement that this is paired with leave?
         unsafe { dispatch_group_enter(self) };
@@ -72,13 +76,15 @@ pub struct DispatchGroupGuard(DispatchRetained<DispatchGroup>);
 
 impl DispatchGroupGuard {
     /// Explicitly indicate that the function in the [`DispatchGroup`] finished executing.
+    #[inline]
     pub fn leave(self) {
         // Drop.
         let _ = self;
     }
 }
 
 impl Drop for DispatchGroupGuard {
+    #[inline]
     fn drop(&mut self) {
         // SAFETY: TODO: Is it a soundness requirement that this is paired with enter?
         unsafe { DispatchGroup::leave(&self.0) };

crates/dispatch2/src/main_thread_bound.rs

@@ -78,6 +78,7 @@ unsafe impl<T> Send for MainThreadBound<T> {}
 unsafe impl<T> Sync for MainThreadBound<T> {}
 
 impl<T> Drop for MainThreadBound<T> {
+    #[inline]
     fn drop(&mut self) {
         if mem::needs_drop::<T>() {
             // TODO: Figure out whether we should assume the main thread to be

crates/dispatch2/src/object.rs

@@ -65,6 +65,7 @@ pub unsafe trait DispatchObject {
     /// This extends the duration in which the object is alive by detaching it
     /// from the lifetime information carried by the reference.
     #[doc(alias = "dispatch_retain")]
+    #[inline]
     fn retain(&self) -> DispatchRetained<Self> {
         let ptr: NonNull<Self> = NonNull::from(self);
         // SAFETY:
@@ -80,6 +81,7 @@ pub unsafe trait DispatchObject {
     ///
     /// TODO.
     #[doc(alias = "dispatch_get_context")]
+    #[inline]
     fn context(&self) -> *mut c_void {
         dispatch_get_context(self.as_raw())
     }
@@ -90,6 +92,7 @@ pub unsafe trait DispatchObject {
     ///
     /// TODO.
     #[doc(alias = "dispatch_set_context")]
+    #[inline]
     unsafe fn set_context(&self, context: *mut c_void) {
         // SAFETY: Upheld by the caller.
         unsafe { dispatch_set_context(self.as_raw(), context) }
@@ -101,12 +104,14 @@ pub unsafe trait DispatchObject {
     ///
     /// TODO.
     #[doc(alias = "dispatch_set_finalizer_f")]
+    #[inline]
     unsafe fn set_finalizer_f(&self, finalizer: dispatch_function_t) {
         // SAFETY: Upheld by the caller.
         unsafe { dispatch_set_finalizer_f(self.as_raw(), finalizer) }
     }
 
     /// Set the finalizer function for the object.
+    #[inline]
     fn set_finalizer<F>(&self, destructor: F)
     where
         F: Send + FnOnce(),
@@ -132,6 +137,7 @@ pub unsafe trait DispatchObject {
     ///
     /// - There must not be a cycle in the hierarchy of queues.
     #[doc(alias = "dispatch_set_target_queue")]
+    #[inline]
     unsafe fn set_target_queue(&self, queue: &DispatchQueue) {
         // SAFETY: `object` and `queue` cannot be null, rest is upheld by caller.
         unsafe { dispatch_set_target_queue(self.as_raw(), Some(queue)) };
@@ -142,6 +148,7 @@ pub unsafe trait DispatchObject {
     /// # Safety
     ///
     /// - DispatchObject should be a queue or queue source.
+    #[inline]
     unsafe fn set_qos_class_floor(
         &self,
         qos_class: DispatchQoS,
@@ -158,20 +165,24 @@ pub unsafe trait DispatchObject {
     }
 
     /// Activate the object.
+    #[inline]
     fn activate(&self) {
         dispatch_activate(self.as_raw());
     }
 
     /// Suspend the invocation of functions on the object.
+    #[inline]
     fn suspend(&self) {
         dispatch_suspend(self.as_raw());
     }
 
     /// Resume the invocation of functions on the object.
+    #[inline]
     fn resume(&self) {
         dispatch_resume(self.as_raw());
     }
 
+    #[inline]
     #[doc(hidden)]
     fn as_raw(&self) -> NonNull<dispatch_object_s> {
         NonNull::from(self).cast()

crates/dispatch2/src/queue.rs

@@ -51,6 +51,7 @@ pub enum GlobalQueueIdentifier {
 
 impl GlobalQueueIdentifier {
     /// Convert and consume [GlobalQueueIdentifier] into its raw value.
+    #[inline]
     pub fn to_identifier(self) -> isize {
         match self {
             GlobalQueueIdentifier::Priority(queue_priority) => queue_priority.0 as isize,
@@ -70,13 +71,15 @@ dispatch_object_not_data!(unsafe DispatchQueue);
 
 impl DispatchQueue {
     /// Create a new [`DispatchQueue`].
+    #[inline]
     pub fn new(label: &str, queue_attribute: Option<&DispatchQueueAttr>) -> DispatchRetained<Self> {
         let label = CString::new(label).expect("Invalid label!");
 
         Self::__new(Some(&label), queue_attribute)
     }
 
     /// Create a new [`DispatchQueue`] with a given target [`DispatchQueue`].
+    #[inline]
     pub fn new_with_target(
         label: &str,
         queue_attribute: Option<&DispatchQueueAttr>,
@@ -89,6 +92,7 @@ impl DispatchQueue {
     }
 
     /// Return a system-defined global concurrent [`DispatchQueue`] with the priority derived from [GlobalQueueIdentifier].
+    #[inline]
     pub fn global_queue(identifier: GlobalQueueIdentifier) -> DispatchRetained<Self> {
         let raw_identifier = identifier.to_identifier();
 
@@ -109,6 +113,7 @@ impl DispatchQueue {
     }
 
     /// Submit a function for synchronous execution on the [`DispatchQueue`].
+    #[inline]
     pub fn exec_sync<F>(&self, work: F)
     where
         F: Send + FnOnce(),
@@ -124,6 +129,7 @@ impl DispatchQueue {
     }
 
     /// Submit a function for asynchronous execution on the [`DispatchQueue`].
+    #[inline]
     pub fn exec_async<F>(&self, work: F)
     where
         // We need `'static` to make sure any referenced values are borrowed for
@@ -137,6 +143,7 @@ impl DispatchQueue {
     }
 
     /// Enqueue a function for execution at the specified time on the [`DispatchQueue`].
+    #[inline]
     pub fn after<F>(&self, when: DispatchTime, work: F) -> Result<(), QueueAfterError>
     where
         F: Send + FnOnce(),
@@ -150,6 +157,7 @@ impl DispatchQueue {
     }
 
     /// Enqueue a barrier function for asynchronous execution on the [`DispatchQueue`] and return immediately.
+    #[inline]
     pub fn barrier_async<F>(&self, work: F)
     where
         // We need `'static` to make sure any referenced values are borrowed for
@@ -163,6 +171,7 @@ impl DispatchQueue {
     }
 
     /// Enqueue a barrier function for synchronous execution on the [`DispatchQueue`] and wait until that function completes.
+    #[inline]
     pub fn barrier_sync<F>(&self, work: F)
     where
         F: Send + FnOnce(),
@@ -174,6 +183,7 @@ impl DispatchQueue {
     }
 
     /// Submit a function for synchronous execution and mark the function as a barrier for subsequent concurrent tasks.
+    #[inline]
     pub fn barrier_async_and_wait<F>(&self, work: F)
     where
         // We need `'static` to make sure any referenced values are borrowed for
@@ -187,6 +197,7 @@ impl DispatchQueue {
     }
 
     /// Sets a function at the given key that will be executed at [`DispatchQueue`] destruction.
+    #[inline]
     pub fn set_specific<F>(&self, key: NonNull<()>, destructor: F)
     where
         F: Send + FnOnce(),
@@ -204,6 +215,7 @@ impl DispatchQueue {
     }
 
     /// Set the QOS class floor of the [`DispatchQueue`].
+    #[inline]
     pub fn set_qos_class_floor(
         &self,
         qos_class: DispatchQoS,
@@ -248,13 +260,15 @@ impl DispatchQueueAttr {
     // };
 
     /// A dispatch queue that executes blocks concurrently.
+    #[inline]
     pub fn concurrent() -> Option<&'static Self> {
         // SAFETY: Queues are
         unsafe { Some(&_dispatch_queue_attr_concurrent) }
     }
 }
 
 /// Executes blocks submitted to the main queue.
+#[inline]
 pub fn dispatch_main() -> ! {
     extern "C" {
         // `dispatch_main` is marked DISPATCH_NOTHROW.

crates/dispatch2/src/semaphore.rs

@@ -21,6 +21,7 @@ impl DispatchSemaphore {
     /// Return [WaitError::TimeOverflow] if the passed ``timeout`` is too big.
     ///
     /// Return [WaitError::Timeout] in case of timeout.
+    #[inline]
     pub fn try_acquire(&self, timeout: DispatchTime) -> Result<DispatchSemaphoreGuard, WaitError> {
         // Safety: DispatchSemaphore cannot be null.
         let result = Self::wait(self, timeout);
@@ -44,6 +45,7 @@ pub struct DispatchSemaphoreGuard(ManuallyDrop<DispatchRetained<DispatchSemaphor
 
 impl DispatchSemaphoreGuard {
     /// Release the [`DispatchSemaphore`].
+    #[inline]
     pub fn release(self) -> bool {
         // We suppress `Drop` for the guard because that would signal the semaphore again.
         // The inner `DispatchRetained` is wrapped in `ManuallyDrop` so that it can be
@@ -56,6 +58,7 @@ impl DispatchSemaphoreGuard {
 }
 
 impl Drop for DispatchSemaphoreGuard {
+    #[inline]
     fn drop(&mut self) {
         // SAFETY: The guard is being dropped; the `ManuallyDrop` contents will not be used again.
         let semaphore = unsafe { ManuallyDrop::take(&mut self.0) };

crates/dispatch2/src/time.rs

@@ -39,16 +39,16 @@ impl DispatchTime {
 impl TryFrom<Duration> for DispatchTime {
     type Error = ();
 
+    #[inline]
     fn try_from(value: Duration) -> Result<Self, Self::Error> {
         let secs = value.as_secs() as i64;
 
-        secs.checked_mul(1_000_000_000)
+        let delta = secs
+            .checked_mul(1_000_000_000)
             .and_then(|x| x.checked_add(i64::from(value.subsec_nanos())))
-            .map(|delta| {
-                // delta cannot overflow
-                Self::NOW.time(delta)
-            })
-            .ok_or(())
+            .ok_or(())?;
+        // delta cannot overflow
+        Ok(Self::NOW.time(delta))
     }
 }
 

crates/dispatch2/src/workloop.rs

@@ -14,6 +14,7 @@ dispatch_object_not_data!(unsafe DispatchWorkloop);
 
 impl DispatchWorkloop {
     /// Create a new [`DispatchWorkloop`].
+    #[inline]
     pub fn new(label: &str, inactive: bool) -> DispatchRetained<Self> {
         let label = CString::new(label).expect("Invalid label!");