Add MainThreadMarker::alloc

Author: madsmtm

crates/icrate/CHANGELOG.md

@@ -28,6 +28,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   - `NSDictionary::get_retained`
   - `NSDictionary::keys_retained`
   - `NSDictionary::values_retained`
+* Added `MainThreadMarker::alloc` for allocating objects that need to be so on
+  the main thread.
 
 ### Changed
 * **BREAKING**: Renamed the `from_slice` method on `NSArray`, `NSSet`,

crates/icrate/src/Foundation/additions/thread.rs

@@ -7,6 +7,8 @@ use core::panic::{RefUnwindSafe, UnwindSafe};
 use crate::common::*;
 use crate::Foundation::NSThread;
 
+use objc2::msg_send_id;
+
 unsafe impl Send for NSThread {}
 unsafe impl Sync for NSThread {}
 
@@ -120,6 +122,43 @@ impl MainThreadMarker {
         Self { _priv: PhantomData }
     }
 
+    /// Allocate a new instance of the specified class on the main thread.
+    ///
+    /// This is essentially the same as [`ClassType::alloc`], the difference
+    /// being that it is also callable with classes that can only be used on
+    /// the main thread.
+    ///
+    ///
+    /// # Example
+    ///
+    /// Create an object on the main thread.
+    ///
+    /// ```
+    /// use icrate::Foundation::MainThreadMarker;
+    /// # use icrate::Foundation::NSObject as SomeClass;
+    /// # #[cfg(for_example)]
+    /// use icrate::SomeFramework::SomeClass;
+    /// use objc2::rc::Id;
+    /// use objc2::msg_send_id;
+    ///
+    /// # let mtm = unsafe { MainThreadMarker::new_unchecked() };
+    /// # #[cfg(doctests_not_always_run_on_main_thread)]
+    /// let mtm = MainThreadMarker::new().expect("must be on the main thread");
+    ///
+    /// // _All_ objects are safe to allocate on the main thread!
+    /// let obj = mtm.alloc::<SomeClass>();
+    ///
+    /// // Though more knowledge is required for safe initialization
+    /// let obj: Id<SomeClass> = unsafe { msg_send_id![obj, init] };
+    /// ```
+    #[inline]
+    pub fn alloc<T: ClassType>(self) -> Option<Allocated<T>> {
+        // SAFETY: Same as `ClassType::alloc`, with the addition that since we
+        // take `self: MainThreadMarker`, the `IsAllocableAnyThread` bound is
+        // not required.
+        unsafe { msg_send_id![T::class(), alloc] }
+    }
+
     /// Submit the given closure to the runloop on the main thread.
     ///
     /// If the current thread is the main thread, this simply runs the

crates/objc2/src/class_type.rs

@@ -168,6 +168,9 @@ pub unsafe trait ClassType: Message {
     /// The return value can be used directly inside [`msg_send_id!`] to
     /// initialize the object.
     ///
+    /// For classes that are only usable on the main thread, you can use
+    /// `MainThreadMarker::alloc` instead.
+    ///
     /// [`msg_send_id!`]: crate::msg_send_id
     //
     // Note: We could have placed this on `mutability::IsAllocableAnyThread`,
@@ -185,6 +188,8 @@ pub unsafe trait ClassType: Message {
         // - The object is safe to `dealloc` on the current thread (due to the
         //   `IsAllocableAnyThread` bound which guarantees it is not
         //   `MainThreadOnly`).
+        //
+        // See also `MainThreadMarker::alloc`.
         unsafe { msg_send_id![Self::class(), alloc] }
     }