Rename AllocAnyThread to AnyThread

UI tests unfortunately still seem to prefer AllocAnyThread, but that
should change once we fully remove it.

Author: madsmtm

crates/objc2/CHANGELOG.md

@@ -12,6 +12,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   same library possible.
 * Added conversion trait impls from `ProtocolObject<P>` to `AnyObject`.
 
+## Changed
+* Renamed `AllocAnyThread` to `AnyThread`. The old name is kept as deprecated.
+
 ## Fixed
 * Fixed undefined behaviour when calling `AnyObject::class` on invalid objects.
 * Fixed `available!` macro when running under Xcode's "Designed for iPad" setting.

crates/objc2/src/__macro_helpers/class.rs

@@ -1,4 +1,4 @@
-use crate::{AllocAnyThread, ClassType, MainThreadOnly, ThreadKind};
+use crate::{AnyThread, ClassType, MainThreadOnly, ThreadKind};
 
 /// Helper for ensuring that `ClassType::ThreadKind`, if specified, is set
 /// correctly.
@@ -20,11 +20,11 @@ where
 {
 }
 
-/// But restrict `AllocAnyThread` to only if the superclass also sets it.
-impl<'a, 'b, Cls> ValidThreadKind<dyn AllocAnyThread + 'a> for Cls
+/// But restrict `AnyThread` to only if the superclass also sets it.
+impl<'a, 'b, Cls> ValidThreadKind<dyn AnyThread + 'a> for Cls
 where
-    Self: ClassType<ThreadKind = dyn AllocAnyThread + 'a>,
-    Self::Super: ClassType<ThreadKind = dyn AllocAnyThread + 'b>,
+    Self: ClassType<ThreadKind = dyn AnyThread + 'a>,
+    Self::Super: ClassType<ThreadKind = dyn AnyThread + 'b>,
 {
 }
 
@@ -75,14 +75,14 @@ mod tests {
 
     extern_class!(
         #[unsafe(super(NSObject))]
-        #[thread_kind = AllocAnyThread]
+        #[thread_kind = AnyThread]
         #[name = "NSObject"]
         struct SetAnyThread;
     );
 
     extern_class!(
         #[unsafe(super(NSObject))]
-        #[thread_kind = AllocAnyThread]
+        #[thread_kind = AnyThread]
         #[name = "NSObject"]
         struct SendSync;
     );

crates/objc2/src/__macro_helpers/define_class.rs

@@ -13,22 +13,22 @@ use crate::runtime::{
 };
 #[cfg(debug_assertions)]
 use crate::runtime::{AnyProtocol, MethodDescription};
-use crate::{AllocAnyThread, ClassType, DefinedClass, Message, ProtocolType};
+use crate::{AnyThread, ClassType, DefinedClass, Message, ProtocolType};
 
 use super::defined_ivars::{register_with_ivars, setup_dealloc};
 use super::{CopyFamily, InitFamily, MutableCopyFamily, NewFamily, NoneFamily};
 
 /// Helper for determining auto traits of defined classes.
 ///
-/// This will contain either `dyn AllocAnyThread` or `dyn MainThreadOnly`, so
-/// it will have no auto traits by default.
+/// This will contain either `dyn AnyThread` or `dyn MainThreadOnly`, so it
+/// will have no auto traits by default.
 #[derive(Debug)]
 pub struct ThreadKindAutoTraits<T: ?Sized>(T);
 
-// SAFETY: `AllocAnyThread` does not place restrictions on thread safety.
-unsafe impl Send for ThreadKindAutoTraits<dyn AllocAnyThread> {}
+// SAFETY: `AnyThread` does not place restrictions on thread safety.
+unsafe impl Send for ThreadKindAutoTraits<dyn AnyThread> {}
 // SAFETY: Same as above.
-unsafe impl Sync for ThreadKindAutoTraits<dyn AllocAnyThread> {}
+unsafe impl Sync for ThreadKindAutoTraits<dyn AnyThread> {}
 
 // NOTE: A similar implementation for `dyn MainThreadOnly` is explicitly not
 // allowed, as that would enable users to pass something that is tied to the

crates/objc2/src/__macro_helpers/defined_ivars.rs

@@ -435,7 +435,7 @@ mod tests {
     use super::*;
     use crate::rc::{Allocated, PartialInit, RcTestObject, Retained, ThreadTestData};
     use crate::runtime::NSObject;
-    use crate::{define_class, msg_send, AllocAnyThread, Message};
+    use crate::{define_class, msg_send, AnyThread, Message};
 
     /// Initialize superclasses, but not own class.
     unsafe fn init_only_superclasses<T: DefinedClass>(obj: Allocated<T>) -> Retained<T>

crates/objc2/src/__macro_helpers/msg_send_retained.rs

@@ -320,7 +320,7 @@ mod tests {
 
     use crate::rc::{autoreleasepool, Allocated, PartialInit, RcTestObject, ThreadTestData};
     use crate::runtime::{AnyObject, NSObject, NSObjectProtocol, NSZone};
-    use crate::{class, define_class, extern_methods, msg_send, test_utils, AllocAnyThread};
+    use crate::{class, define_class, extern_methods, msg_send, test_utils, AnyThread};
 
     #[test]
     fn test_send_message_manuallydrop() {

crates/objc2/src/lib.rs

@@ -133,7 +133,7 @@ pub use self::downcast::DowncastTarget;
 pub use self::encode::{Encode, Encoding, RefEncode};
 pub use self::main_thread_marker::MainThreadMarker;
 pub use self::top_level_traits::{
-    AllocAnyThread, ClassType, DefinedClass, MainThreadOnly, Message, ProtocolType, ThreadKind,
+    AnyThread, ClassType, DefinedClass, MainThreadOnly, Message, ProtocolType, ThreadKind,
 };
 
 #[cfg(any(feature = "unstable-static-sel", feature = "unstable-static-class"))]
@@ -191,6 +191,10 @@ pub mod declare {
 #[deprecated = "renamed to DefinedClass"]
 pub use DefinedClass as DeclaredClass;
 
+/// Deprecated alias of [`AnyThread`].
+#[deprecated = "renamed to AnyThread"]
+pub use AnyThread as AllocAnyThread;
+
 #[cfg(not(feature = "std"))]
 compile_error!("The `std` feature currently must be enabled.");
 

crates/objc2/src/macros/define_class.rs

@@ -275,7 +275,7 @@
 /// use objc2_foundation::{CopyingHelper, NSCopying, NSObject, NSObjectProtocol, NSZone};
 /// use objc2::rc::{Allocated, Retained};
 /// use objc2::{
-///     define_class, extern_methods, extern_protocol, msg_send, AllocAnyThread,
+///     define_class, extern_methods, extern_protocol, msg_send, AnyThread,
 ///     ClassType, DefinedClass, ProtocolType,
 /// };
 ///

crates/objc2/src/macros/extern_protocol.rs

@@ -247,7 +247,7 @@ macro_rules! __extern_protocol_check_no_thread_kind {
     () => {};
     ($($ivars:tt)*) => {
         $crate::__macro_helpers::compile_error!(
-            "#[thread_kind = ...] is not supported in extern_protocol!. Add MainThreadOnly or AllocAnyThread bound instead"
+            "#[thread_kind = ...] is not supported in extern_protocol!. Add MainThreadOnly or AnyThread bound instead"
         );
     };
 }

crates/objc2/src/rc/allocated_partial_init.rs

@@ -399,7 +399,7 @@ mod tests {
     #[cfg(feature = "unstable-arbitrary-self-types")]
     fn arbitrary_self_types() {
         use crate::rc::Retained;
-        use crate::{extern_methods, AllocAnyThread};
+        use crate::{extern_methods, AnyThread};
 
         impl RcTestObject {
             extern_methods!(

crates/objc2/src/rc/retained.rs

@@ -194,7 +194,7 @@ impl<T: ?Sized + Message> Retained<T> {
     /// ```
     /// use objc2::rc::Retained;
     /// use objc2::runtime::NSObject;
-    /// use objc2::{msg_send, AllocAnyThread, ClassType};
+    /// use objc2::{msg_send, AnyThread, ClassType};
     ///
     /// // Manually using `msg_send!`, pointers and `Retained::from_raw`
     /// let obj: *mut NSObject = unsafe { msg_send![NSObject::class(), alloc] };

crates/objc2/src/runtime/nsobject.rs

@@ -7,7 +7,7 @@ use crate::ffi::NSUInteger;
 use crate::rc::{Allocated, DefaultRetained, Retained};
 use crate::runtime::{AnyClass, AnyObject, AnyProtocol, ImplementedBy, ProtocolObject, Sel};
 use crate::DowncastTarget;
-use crate::{extern_methods, msg_send, AllocAnyThread, ClassType, Message, ProtocolType};
+use crate::{extern_methods, msg_send, AnyThread, ClassType, Message, ProtocolType};
 
 /// The root class of most Objective-C class hierarchies.
 ///
@@ -78,7 +78,7 @@ impl RefUnwindSafe for private::ForDefinedSubclasses {}
 
 unsafe impl ClassType for NSObject {
     type Super = AnyObject;
-    type ThreadKind = dyn AllocAnyThread;
+    type ThreadKind = dyn AnyThread;
     const NAME: &'static str = "NSObject";
 
     #[inline]
@@ -391,10 +391,8 @@ impl NSObject {
     extern_methods!(
         /// Create a new empty `NSObject`.
         ///
-        /// This method is a shorthand for calling [`alloc`] and then
-        /// [`init`][Self::init].
-        ///
-        /// [`alloc`]: AllocAnyThread::alloc
+        /// This method is a shorthand for calling [`alloc`][AnyThread::alloc]
+        /// and then [`init`][Self::init].
         #[unsafe(method(new))]
         #[unsafe(method_family = new)]
         pub fn new() -> Retained<Self>;
@@ -410,7 +408,7 @@ impl NSObject {
         ///
         /// ```
         /// use objc2::runtime::NSObject;
-        /// use objc2::AllocAnyThread;
+        /// use objc2::AnyThread;
         ///
         /// let obj = NSObject::init(NSObject::alloc());
         /// ```

crates/objc2/src/runtime/nsproxy.rs

@@ -5,7 +5,7 @@ use core::hash;
 
 use crate::runtime::{AnyClass, AnyObject, NSObjectProtocol, ProtocolObject};
 use crate::DowncastTarget;
-use crate::{AllocAnyThread, ClassType};
+use crate::{AnyThread, ClassType};
 
 /// An abstract superclass defining an API for objects that act as
 /// stand-ins for other objects or for objects that don’t exist yet.
@@ -27,7 +27,7 @@ crate::__extern_class_impl_traits! {
 
 unsafe impl ClassType for NSProxy {
     type Super = AnyObject;
-    type ThreadKind = dyn AllocAnyThread;
+    type ThreadKind = dyn AnyThread;
     const NAME: &'static str = "NSProxy";
 
     #[inline]

crates/objc2/src/top_level_traits.rs

@@ -166,7 +166,7 @@ pub unsafe trait Message: RefEncode {
 /// Use the trait to allocate a new instance of an object.
 ///
 /// ```
-/// use objc2::{msg_send, AllocAnyThread};
+/// use objc2::{msg_send, AnyThread};
 /// use objc2::rc::Retained;
 /// # use objc2::runtime::{NSObject as MyObject};
 ///
@@ -183,7 +183,7 @@ pub unsafe trait Message: RefEncode {
 ///
 /// ```
 /// use objc2::runtime::NSObject;
-/// use objc2::{extern_class, ClassType, AllocAnyThread};
+/// use objc2::{extern_class, ClassType, AnyThread};
 ///
 /// extern_class!(
 ///     // SAFETY: The superclass is correctly specified, and the class can be
@@ -224,12 +224,12 @@ pub unsafe trait ClassType: Message {
     /// Whether the type can be used from any thread, or from only the main
     /// thread.
     ///
-    /// One of [`dyn AllocAnyThread`] or [`dyn MainThreadOnly`].
+    /// One of [`dyn AnyThread`] or [`dyn MainThreadOnly`].
     ///
     /// Setting this makes `ClassType` provide an implementation of either
-    /// [`AllocAnyThread`] or [`MainThreadOnly`].
+    /// [`AnyThread`] or [`MainThreadOnly`].
     ///
-    /// [`dyn AllocAnyThread`]: AllocAnyThread
+    /// [`dyn AnyThread`]: AnyThread
     /// [`dyn MainThreadOnly`]: MainThreadOnly
     type ThreadKind: ?Sized + ThreadKind;
 
@@ -398,7 +398,7 @@ fn get_protocol(name: &str) -> Option<&'static AnyProtocol> {
 
 // Split into separate traits for better diagnostics
 mod private {
-    pub trait SealedAllocAnyThread {}
+    pub trait SealedAnyThread {}
     pub trait SealedMainThreadOnly {}
     pub trait SealedThreadKind {}
 }
@@ -426,7 +426,7 @@ mod private {
 //     impl<T: ?Sized + MainThreadOnly> !AnyThread for T {}
 //
 // This isn't possible in current Rust though, so we'll have to hack it.
-pub unsafe trait AllocAnyThread: private::SealedAllocAnyThread {
+pub unsafe trait AnyThread: private::SealedAnyThread {
     /// Allocate a new instance of the class.
     ///
     /// The return value can be used directly inside [`msg_send!`] to
@@ -461,14 +461,11 @@ pub unsafe trait AllocAnyThread: private::SealedAllocAnyThread {
 
 // The impl here is a bit bad for diagnostics, but required to prevent users
 // implementing the trait themselves.
-impl<'a, T: ?Sized + ClassType<ThreadKind = dyn AllocAnyThread + 'a>> private::SealedAllocAnyThread
-    for T
-{
-}
-unsafe impl<'a, T: ?Sized + ClassType<ThreadKind = dyn AllocAnyThread + 'a>> AllocAnyThread for T {}
+impl<'a, T: ?Sized + ClassType<ThreadKind = dyn AnyThread + 'a>> private::SealedAnyThread for T {}
+unsafe impl<'a, T: ?Sized + ClassType<ThreadKind = dyn AnyThread + 'a>> AnyThread for T {}
 
-impl<P: ?Sized> private::SealedAllocAnyThread for ProtocolObject<P> {}
-unsafe impl<P: ?Sized + AllocAnyThread> AllocAnyThread for ProtocolObject<P> {}
+impl<P: ?Sized> private::SealedAnyThread for ProtocolObject<P> {}
+unsafe impl<P: ?Sized + AnyThread> AnyThread for ProtocolObject<P> {}
 
 /// Marker trait for classes and protocols that are only safe to use on the
 /// main thread.
@@ -569,18 +566,18 @@ unsafe impl<P: ?Sized + MainThreadOnly> MainThreadOnly for ProtocolObject<P> {}
 
 /// The allowed values in [`ClassType::ThreadKind`].
 ///
-/// One of [`dyn AllocAnyThread`] or [`dyn MainThreadOnly`].
+/// One of [`dyn AnyThread`] or [`dyn MainThreadOnly`].
 ///
-/// [`dyn AllocAnyThread`]: AllocAnyThread
+/// [`dyn AnyThread`]: AnyThread
 /// [`dyn MainThreadOnly`]: MainThreadOnly
 pub trait ThreadKind: private::SealedThreadKind {
     // To mark `ThreadKind` as dyn-incompatible for now.
     #[doc(hidden)]
     const __DYN_INCOMPATIBLE: ();
 }
 
-impl private::SealedThreadKind for dyn AllocAnyThread + '_ {}
-impl ThreadKind for dyn AllocAnyThread + '_ {
+impl private::SealedThreadKind for dyn AnyThread + '_ {}
+impl ThreadKind for dyn AnyThread + '_ {
     const __DYN_INCOMPATIBLE: () = ();
 }
 
@@ -594,5 +591,5 @@ mod tests {
     use super::*;
 
     #[allow(unused)]
-    fn dyn_compatible(_: &dyn AllocAnyThread, _: &dyn MainThreadOnly) {}
+    fn dyn_compatible(_: &dyn AnyThread, _: &dyn MainThreadOnly) {}
 }

crates/objc2/src/topics/kvo.md

@@ -21,7 +21,7 @@ use core::ptr;
 
 use objc2::rc::Retained;
 use objc2::runtime::AnyObject;
-use objc2::{define_class, msg_send, AllocAnyThread, ClassType, DefinedClass};
+use objc2::{define_class, msg_send, AnyThread, ClassType, DefinedClass};
 use objc2_foundation::{
     ns_string, NSCopying, NSDictionary, NSKeyValueChangeKey, NSKeyValueObservingOptions, NSObject,
     NSObjectNSKeyValueObserverRegistration, NSObjectProtocol, NSString,

crates/objc2/src/topics/swift.md

@@ -78,7 +78,7 @@ Mapping this to Rust would then look something like:
 
 use objc2::rc::{Allocated, Retained};
 use objc2::runtime::NSObject;
-use objc2::{extern_class, extern_methods, AllocAnyThread};
+use objc2::{extern_class, extern_methods, AnyThread};
 
 extern_class!(
     #[unsafe(super(NSObject))]

crates/objc2/tests/track_caller.rs

@@ -10,7 +10,7 @@ use std::sync::Mutex;
 use objc2::encode::Encode;
 use objc2::rc::{self, Allocated, Retained};
 use objc2::runtime::{self, NSObject};
-use objc2::{class, define_class, msg_send, AllocAnyThread, ClassType};
+use objc2::{class, define_class, msg_send, AnyThread, ClassType};
 
 #[path = "../src/rc/test_object.rs"]
 #[allow(dead_code)]

crates/test-fuzz/fuzz_targets/collection_interior_mut.rs

@@ -12,7 +12,7 @@ use std::hint::black_box;
 use arbitrary::Arbitrary;
 use objc2::rc::{autoreleasepool, Retained};
 use objc2::runtime::AnyObject;
-use objc2::{define_class, msg_send, AllocAnyThread, ClassType, DefinedClass, Message};
+use objc2::{define_class, msg_send, AnyThread, ClassType, DefinedClass, Message};
 use objc2_foundation::{
     CopyingHelper, NSCopying, NSMutableDictionary, NSMutableSet, NSObject, NSObjectProtocol,
     NSUInteger, NSZone,

crates/test-ui/ui/define_class_delegate_not_mainthreadonly.rs

@@ -1,7 +1,7 @@
 //! Test that implementing `NSApplicationDelegate` and similar requires
 //! a `MainThreadOnly` class.
 use objc2::rc::Retained;
-use objc2::{define_class, extern_methods, extern_protocol, AllocAnyThread, MainThreadOnly};
+use objc2::{define_class, extern_methods, extern_protocol, AnyThread, MainThreadOnly};
 use objc2_foundation::{MainThreadMarker, NSNotification, NSObject, NSObjectProtocol};
 
 // Use fake `NSApplicationDelegate` so that this works on iOS too.
@@ -17,7 +17,7 @@ extern_protocol!(
 
 define_class!(
     #[unsafe(super(NSObject))]
-    #[thread_kind = AllocAnyThread] // Not `MainThreadOnly`
+    #[thread_kind = AnyThread] // Not `MainThreadOnly`
     struct CustomObject;
 
     unsafe impl NSObjectProtocol for CustomObject {}

crates/test-ui/ui/define_class_delegate_not_mainthreadonly.stderr

@@ -2,7 +2,7 @@ use core::ops::Deref;
 
 use objc2::encode::{Encoding, RefEncode};
 use objc2::runtime::AnyObject;
-use objc2::{extern_class, AllocAnyThread, Message};
+use objc2::{extern_class, AnyThread, Message};
 
 #[repr(transparent)]
 struct MyObject(AnyObject);
@@ -23,7 +23,7 @@ impl Deref for MyObject {
 
 extern_class!(
     #[unsafe(super(MyObject))]
-    #[thread_kind = AllocAnyThread]
+    #[thread_kind = AnyThread]
     pub struct MyRootClass;
 );