Make all structs transparent

Author: pronebird

crates/dispatch2/src/group.rs

@@ -6,21 +6,20 @@ use core::{ffi::c_void, time::Duration};
 use super::{ffi::*, function_wrapper, queue::Queue, rc::Retained, AsRawDispatchObject, WaitError};
 
 /// Dispatch group.
-#[derive(Debug)]
+#[derive(Debug, Clone, Copy)]
 pub struct Group {
-    inner: Retained<dispatch_group_s>,
+    _inner: [u8; 0],
 }
 
 impl Group {
     /// Creates a new [Group].
-    pub fn new() -> Option<Self> {
+    pub fn new() -> Option<Retained<Self>> {
         // Safety: valid to call.
         let object = unsafe { dispatch_group_create() };
+        assert!(!object.is_null());
 
-        // Safety: retained accepts null pointer.
-        let inner = unsafe { Retained::from_raw(object)? };
-
-        Some(Group { inner })
+        // Safety: object must be valid.
+        unsafe { Retained::from_raw(object.cast()) }
     }
 
     /// Submit a function to a [Queue] and associates it with the [Group].
@@ -89,7 +88,11 @@ impl Group {
             dispatch_group_enter(self.as_raw());
         }
 
-        GroupGuard(self.clone(), false)
+        let group =
+            // Safety: group cannot be null.
+            unsafe { Retained::retain(self.as_raw().cast()) }.expect("failed to retain semaphore");
+
+        GroupGuard(group, false)
     }
 
     /// Get the raw [dispatch_group_t] value.
@@ -98,19 +101,7 @@ impl Group {
     ///
     /// - Object shouldn't be released manually.
     pub fn as_raw(&self) -> dispatch_group_t {
-        // Safety: Upheld by caller
-        Retained::as_ptr(&self.inner).cast_mut()
-    }
-}
-
-impl Clone for Group {
-    fn clone(&self) -> Self {
-        Self {
-            // Safety: pointer must be valid.
-            inner: unsafe {
-                Retained::retain(self.as_raw()).expect("failed to retain dispatch_group")
-            },
-        }
+        self as *const Self as _
     }
 }
 
@@ -128,7 +119,7 @@ unsafe impl Sync for Group {}
 
 /// Dispatch group guard.
 #[derive(Debug)]
-pub struct GroupGuard(Group, bool);
+pub struct GroupGuard(Retained<Group>, bool);
 
 impl GroupGuard {
     /// Explicitly indicates that the function in the [Group] finished executing.

crates/dispatch2/src/lib.rs

@@ -42,7 +42,7 @@ mod main_thread_bound;
 pub mod object;
 mod once;
 pub mod queue;
-mod rc;
+pub mod rc;
 pub mod semaphore;
 pub mod workloop;
 

crates/dispatch2/src/queue.rs

@@ -1,7 +1,7 @@
 //! Dispatch queue definition.
 
 use alloc::{boxed::Box, ffi::CString};
-use core::{mem::ManuallyDrop, ptr::NonNull, time::Duration};
+use core::{ptr::NonNull, time::Duration};
 
 use super::{
     ffi::*, function_wrapper, rc::Retained, AsRawDispatchObject, QualityOfServiceClass,
@@ -86,34 +86,32 @@ impl Default for GlobalQueueIdentifier {
 }
 
 /// Dispatch queue.
-#[derive(Debug)]
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone)]
 pub struct Queue {
-    inner: ManuallyDrop<Retained<dispatch_queue_s>>,
-    is_global_queue: bool,
+    _inner: [u8; 0],
 }
 
 impl Queue {
     /// Create a new [Queue].
-    pub fn new(label: &str, queue_attribute: QueueAttribute) -> Self {
+    pub fn new(label: &str, queue_attribute: QueueAttribute) -> Retained<Self> {
         let label = CString::new(label).expect("Invalid label!");
 
         // Safety: label and queue_attribute can only be valid.
         let object = unsafe {
             dispatch_queue_create(label.as_ptr(), dispatch_queue_attr_t::from(queue_attribute))
         };
 
-        // Safety: object cannot be null.
-        let inner =
-            unsafe { Retained::from_raw(object).expect("dispatch_queue_create shouldn't fail!") };
-
-        Queue {
-            inner: ManuallyDrop::new(inner),
-            is_global_queue: false,
-        }
+        // Safety: object must be valid.
+        unsafe { Retained::from_raw(object.cast()) }.expect("dispatch_queue_create failed")
     }
 
     /// Create a new [Queue] with a given target [Queue].
-    pub fn new_with_target(label: &str, queue_attribute: QueueAttribute, target: &Queue) -> Self {
+    pub fn new_with_target(
+        label: &str,
+        queue_attribute: QueueAttribute,
+        target: &Queue,
+    ) -> Retained<Self> {
         let label = CString::new(label).expect("Invalid label!");
 
         // Safety: label, queue_attribute and target can only be valid.
@@ -125,47 +123,31 @@ impl Queue {
             )
         };
 
-        // Safety: object cannot be null.
-        let inner =
-            unsafe { Retained::from_raw(object).expect("dispatch_queue_create shouldn't fail!") };
+        assert!(!object.is_null());
 
         // NOTE: dispatch_queue_create_with_target is in charge of retaining the target Queue.
 
-        Queue {
-            inner: ManuallyDrop::new(inner),
-            is_global_queue: false,
-        }
+        // Safety: object must be valid.
+        unsafe { Retained::from_raw(object.cast()) }.expect("dispatch_queue_create failed")
     }
 
     /// Return a system-defined global concurrent [Queue] with the priority derived from [GlobalQueueIdentifier].
-    pub fn global_queue(identifier: GlobalQueueIdentifier) -> Self {
-        let raw_identifier = identifier.to_identifier();
-
+    pub fn global_queue(identifier: GlobalQueueIdentifier) -> Retained<Self> {
         // Safety: raw_identifier cannot be invalid, flags is reserved.
-        let object = unsafe { dispatch_get_global_queue(raw_identifier, 0) };
+        let object = unsafe { dispatch_get_global_queue(identifier.to_identifier(), 0) };
+        assert!(!object.is_null());
 
-        // Safety: object cannot be null.
-        let inner = unsafe {
-            Retained::from_raw(object.cast()).expect("dispatch_get_global_queue shouldn't fail!")
-        };
-
-        Queue {
-            inner: ManuallyDrop::new(inner),
-            is_global_queue: true,
-        }
+        // Safety: object must be valid.
+        unsafe { Retained::from_raw(object.cast()) }.expect("dispatch_get_global_queue failed")
     }
 
     /// Return the main queue.
-    pub fn main() -> Self {
-        // Safety: object cannot be null.
-        let inner = unsafe {
-            Retained::from_raw(dispatch_get_main_queue().cast())
-                .expect("dispatch_get_main_queue shouldn't fail!")
-        };
-        Queue {
-            inner: ManuallyDrop::new(inner),
-            is_global_queue: true,
-        }
+    pub fn main() -> Retained<Self> {
+        let object = dispatch_get_main_queue();
+        assert!(!object.is_null());
+
+        // Safety: object must be valid.
+        unsafe { Retained::from_raw(object.cast()) }.expect("dispatch_get_main_queue failed")
     }
 
     /// Submit a function for synchronous execution on the [Queue].
@@ -291,30 +273,7 @@ impl Queue {
     ///
     /// - Object shouldn't be released manually.
     pub fn as_raw(&self) -> dispatch_queue_t {
-        Retained::as_ptr(&self.inner).cast_mut()
-    }
-}
-
-impl Drop for Queue {
-    fn drop(&mut self) {
-        if !self.is_global_queue {
-            // Safety: do not release global queues as they are singletons.
-            let _ = unsafe { ManuallyDrop::take(&mut self.inner) };
-        }
-    }
-}
-
-impl Clone for Queue {
-    fn clone(&self) -> Self {
-        Self {
-            // Safety: pointer must be valid.
-            inner: unsafe {
-                ManuallyDrop::new(
-                    Retained::retain(self.as_raw()).expect("failed to retain dispatch_queue"),
-                )
-            },
-            is_global_queue: self.is_global_queue,
-        }
+        self as *const Self as _
     }
 }
 

crates/dispatch2/src/rc.rs

@@ -6,30 +6,37 @@ use super::ffi::*;
 
 /// Smart pointer based on libdispatch reference counting system.
 #[repr(transparent)]
-pub(crate) struct Retained<T: ?Sized> {
+pub struct Retained<T: ?Sized> {
     ptr: NonNull<T>,
 }
 
 impl<T> Retained<T> {
     /// Create new smart pointer assuming the ownership over the object.
     /// The retain count will stay the same.
-    pub(crate) unsafe fn from_raw(ptr: *mut T) -> Option<Self> {
+    ///
+    /// # Safety
+    /// Must be a valid pointer to the dispatch object having a retain count of +1.
+    pub unsafe fn from_raw(ptr: *mut T) -> Option<Self> {
         NonNull::new(ptr).map(|ptr| Self { ptr })
     }
 
     /// Create new smart pointer with shared ownership.
     /// Increments reference counter by 1.
+    ///
+    /// # Safety
+    /// Must be a valid pointer to the dispatch object.
     #[allow(unused)]
-    pub(crate) unsafe fn retain(ptr: *mut T) -> Option<Self> {
+    pub unsafe fn retain(ptr: *mut T) -> Option<Self> {
         NonNull::new(ptr).map(|ptr| {
             // Safety: upheld by the caller
             unsafe { dispatch_retain(ptr.as_ptr().cast()) };
             Self { ptr }
         })
     }
 
+    /// Returns the pointer to retained object.
     #[inline]
-    pub(crate) fn as_ptr(this: &Self) -> *const T {
+    pub fn as_ptr(this: &Self) -> *const T {
         this.ptr.as_ptr()
     }
 }

crates/dispatch2/src/semaphore.rs

@@ -5,16 +5,17 @@ use core::time::Duration;
 use super::{ffi::*, rc::Retained, AsRawDispatchObject, WaitError};
 
 /// Dispatch semaphore.
-#[derive(Debug)]
+#[repr(transparent)]
+#[derive(Debug, Clone, Copy)]
 pub struct Semaphore {
-    inner: Retained<dispatch_semaphore_s>,
+    _inner: [u8; 0],
 }
 
 impl Semaphore {
     /// Creates a new [Semaphore] with an initial value.
     ///
     /// Returns None if value is negative or if creation failed.
-    pub fn new(value: isize) -> Option<Self> {
+    pub fn new(value: isize) -> Option<Retained<Self>> {
         // Per documentation creating a semaphore with a negative size isn't allowed.
         if value < 0 {
             return None;
@@ -24,11 +25,7 @@ impl Semaphore {
         let object = unsafe { dispatch_semaphore_create(value) };
 
         // Safety: retained accepts null pointer.
-        let dispatch_object = unsafe { Retained::from_raw(object)? };
-
-        Some(Semaphore {
-            inner: dispatch_object,
-        })
+        unsafe { Retained::from_raw(object.cast()) }
     }
 
     /// Attempt to acquire the [Semaphore] and return a [SemaphoreGuard].
@@ -48,8 +45,12 @@ impl Semaphore {
         // Safety: Semaphore cannot be null.
         let result = unsafe { dispatch_semaphore_wait(self.as_raw(), timeout) };
 
+        let sema =
+            // Safety: semaphore cannot be null.
+            unsafe { Retained::retain(self.as_raw().cast()) }.expect("failed to retain semaphore");
+
         match result {
-            0 => Ok(SemaphoreGuard(self.clone(), false)),
+            0 => Ok(SemaphoreGuard(sema, false)),
             _ => Err(WaitError::Timeout),
         }
     }
@@ -60,18 +61,7 @@ impl Semaphore {
     ///
     /// - Object shouldn't be released manually.
     pub fn as_raw(&self) -> dispatch_semaphore_t {
-        Retained::as_ptr(&self.inner).cast_mut()
-    }
-}
-
-impl Clone for Semaphore {
-    fn clone(&self) -> Self {
-        Self {
-            // Safety: pointer must be valid.
-            inner: unsafe {
-                Retained::retain(self.as_raw()).expect("failed to retain dispatch_semaphore_t")
-            },
-        }
+        self as *const Self as _
     }
 }
 
@@ -89,7 +79,7 @@ unsafe impl Sync for Semaphore {}
 
 /// Dispatch semaphore guard.
 #[derive(Debug)]
-pub struct SemaphoreGuard(Semaphore, bool);
+pub struct SemaphoreGuard(Retained<Semaphore>, bool);
 
 impl SemaphoreGuard {
     /// Release the [Semaphore].