Merge pull request #491 from madsmtm/main-thread-refactoring

Change a few things in our main thread utilities

Author: madsmtm

crates/icrate/CHANGELOG.md

@@ -10,6 +10,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## icrate Unreleased - YYYY-MM-DD
 
+### Added
+* Added `MainThreadMarker` `From` implementation for `MainThreadOnly` types.
+
 ### Changed
 * Moved the `ns_string!` macro to `icrate::Foundation::ns_string`. The old
   location in the crate root is deprecated.
@@ -18,6 +21,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   - `refitAccelerationStructure_descriptor_destination_scratchBuffer_scratchBufferOffset`
   - `refitAccelerationStructure_descriptor_destination_scratchBuffer_scratchBufferOffset_options`
 
+### Removed
+* **BREAKING**: Removed the `MainThreadMarker` argument from the closure
+  passed to `MainThreadBound::get_on_main`.
+
 
 ## icrate 0.0.4 - 2023-07-31
 

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

@@ -8,6 +8,7 @@ use crate::common::*;
 use crate::Foundation::NSThread;
 
 use objc2::msg_send_id;
+use objc2::mutability::IsMainThreadOnly;
 
 unsafe impl Send for NSThread {}
 unsafe impl Sync for NSThread {}
@@ -191,6 +192,23 @@ impl MainThreadMarker {
     }
 }
 
+/// Get a [`MainThreadMarker`] from a main-thread-only object.
+///
+/// This function exists purely in the type-system, and will always
+/// succeed at runtime.
+impl<T: ?Sized + IsMainThreadOnly> From<&T> for MainThreadMarker {
+    #[inline]
+    fn from(_obj: &T) -> Self {
+        // SAFETY: Objects which are `IsMainThreadOnly` are guaranteed
+        // `!Send + !Sync` and are only constructible on the main thread.
+        //
+        // Since we hold a reference to such an object, and we know it cannot
+        // now possibly be on another thread than the main, we know that the
+        // current thread is the main thread.
+        unsafe { Self::new_unchecked() }
+    }
+}
+
 impl fmt::Debug for MainThreadMarker {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("MainThreadMarker").finish()
@@ -311,10 +329,10 @@ impl<T> MainThreadBound<T> {
     #[inline]
     pub fn get_on_main<F, R>(&self, f: F) -> R
     where
-        F: Send + FnOnce(&T, MainThreadMarker) -> R,
+        F: Send + FnOnce(&T) -> R,
         R: Send,
     {
-        MainThreadMarker::run_on_main(|mtm| f(self.get(mtm), mtm))
+        MainThreadMarker::run_on_main(|mtm| f(self.get(mtm)))
     }
 
     /// Access the item mutably on the main thread.
@@ -323,10 +341,10 @@ impl<T> MainThreadBound<T> {
     #[inline]
     pub fn get_on_main_mut<F, R>(&mut self, f: F) -> R
     where
-        F: Send + FnOnce(&mut T, MainThreadMarker) -> R,
+        F: Send + FnOnce(&mut T) -> R,
         R: Send,
     {
-        MainThreadMarker::run_on_main(|mtm| f(self.get_mut(mtm), mtm))
+        MainThreadMarker::run_on_main(|mtm| f(self.get_mut(mtm)))
     }
 }
 

crates/objc2/CHANGELOG.md

@@ -6,6 +6,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## Unreleased - YYYY-MM-DD
 
+### Added
+* Added `mutability::IsMainThreadOnly`.
+
+
 ## 0.4.1 - 2023-07-31
 
 ### Added

crates/objc2/src/mutability.rs

@@ -190,6 +190,9 @@ pub struct InteriorMutable {
 ///
 /// This is commonly used in GUI code like `AppKit` and `UIKit`, e.g.
 /// `UIWindow` is only usable from the application's main thread.
+///
+/// It is unsound to implement [`Send`] or [`Sync`] on a type with this
+/// mutability.
 //
 // While Xcode's Main Thread Checker doesn't report `alloc` and `dealloc` as
 // unsafe from other threads, things like `NSView` and `NSWindow` still do a
@@ -308,6 +311,19 @@ impl<T: ?Sized + ClassType> IsAllocableAnyThread for T where
 pub trait IsMutable: ClassType {}
 impl<T: ?Sized + ClassType> IsMutable for T where T::Mutability: private::MutabilityIsMutable {}
 
+/// Marker trait for classes that are only available on the main thread.
+///
+/// This is implemented for classes whose [`ClassType::Mutability`] is one of:
+/// - [`MainThreadOnly`].
+///
+/// Since `MainThreadOnly` types must be `!Send` and `!Sync`, if you hold a
+/// type that implements this trait, then you're guaranteed to be on the main
+/// thread.
+//
+// Note: MainThreadMarker::from relies on this.
+pub trait IsMainThreadOnly: ClassType {}
+impl<T: ?Sized + ClassType<Mutability = MainThreadOnly>> IsMainThreadOnly for T {}
+
 #[cfg(test)]
 mod tests {
     use super::*;