Add MainThreadMarker From implementation for MainThreadOnly types

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.

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()

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,15 @@ 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`].
+//
+// 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::*;