Make Class no longer implement Message directly

This is done so that:
- `Id<T, O>` is correct for all `T: Message` (currently `Id<Class, _>` is possible).
- `ClassBuilder::add_method` doesn't accept functions that take `&Class` as the receiver.

Author: madsmtm

objc2/CHANGELOG.md

@@ -58,6 +58,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
   If you previously used `*mut Object` or `&Object` as the receiver, message
   sending should work exactly as before.
+* **BREAKING**: `Class` no longer implements `Message` (but it can still be
+  used as the receiver in `msg_send!`, so this is unlikely to break anything
+  in practice).
 
 ### Fixed
 * Properly sealed the `MessageArguments` trait (it already had a hidden

objc2/src/declare.rs

@@ -48,7 +48,7 @@ use crate::{ffi, Encode, EncodeArguments, Encoding, Message};
 /// Types that can be used as the implementation of an Objective-C method.
 pub trait MethodImplementation {
     /// The callee type of the method.
-    type Callee: Message + ?Sized;
+    type Callee: ?Sized;
     /// The return type of the method.
     type Ret: Encode;
     /// The argument types of the method.
@@ -75,13 +75,32 @@ macro_rules! method_decl_impl {
             }
         }
     );
+    (@$s:ident, $r:ident, $f:ty, $($t:ident),*) => (
+        impl<$r, $($t),*> MethodImplementation for $f
+        where
+            $r: Encode,
+            $($t: Encode,)*
+        {
+            type Callee = $s;
+            type Ret = $r;
+            type Args = ($($t,)*);
+
+            fn imp(self) -> Imp {
+                unsafe { mem::transmute(self) }
+            }
+        }
+    );
     ($($t:ident),*) => (
         method_decl_impl!(-T, R, extern "C" fn(&T, Sel $(, $t)*) -> R, $($t),*);
         method_decl_impl!(-T, R, extern "C" fn(&mut T, Sel $(, $t)*) -> R, $($t),*);
         method_decl_impl!(-T, R, unsafe extern "C" fn(*const T, Sel $(, $t)*) -> R, $($t),*);
         method_decl_impl!(-T, R, unsafe extern "C" fn(*mut T, Sel $(, $t)*) -> R, $($t),*);
         method_decl_impl!(-T, R, unsafe extern "C" fn(&T, Sel $(, $t)*) -> R, $($t),*);
         method_decl_impl!(-T, R, unsafe extern "C" fn(&mut T, Sel $(, $t)*) -> R, $($t),*);
+
+        method_decl_impl!(@Class, R, extern "C" fn(&Class, Sel $(, $t)*) -> R, $($t),*);
+        method_decl_impl!(@Class, R, unsafe extern "C" fn(*const Class, Sel $(, $t)*) -> R, $($t),*);
+        method_decl_impl!(@Class, R, unsafe extern "C" fn(&Class, Sel $(, $t)*) -> R, $($t),*);
     );
 }
 
@@ -200,7 +219,7 @@ impl ClassBuilder {
     /// when the method is invoked from Objective-C.
     pub unsafe fn add_method<T, F>(&mut self, sel: Sel, func: F)
     where
-        T: Message + ?Sized, // TODO: Disallow `Class`
+        T: Message + ?Sized,
         F: MethodImplementation<Callee = T>,
     {
         let encs = F::Args::ENCODINGS;

objc2/src/message/mod.rs

@@ -43,8 +43,6 @@ use self::verify::{verify_message_signature, VerificationError};
 
 /// Types that can be sent Objective-C messages.
 ///
-/// Examples include objects, classes, and blocks.
-///
 /// Implementing this provides [`MessageReceiver`] implementations for common
 /// pointer types and references to the type, which allows using them as the
 /// receiver (first argument) in the [`msg_send!`][`crate::msg_send`] macro.
@@ -54,6 +52,9 @@ use self::verify::{verify_message_signature, VerificationError};
 /// A pointer to the type must be able to be the receiver of an Objective-C
 /// message sent with [`objc_msgSend`] or similar.
 ///
+/// The object must also respond to the `retain`, `release` and `autorelease`
+/// messages, as that allows it to be used with [`rc::Id`][`Id`].
+///
 /// Additionally, the type must implement [`RefEncode`] and adhere to the
 /// safety requirements therein.
 ///
@@ -65,8 +66,6 @@ unsafe impl<T: Message + ?Sized> Message for ManuallyDrop<T> {}
 
 unsafe impl Message for Object {}
 
-unsafe impl Message for Class {}
-
 // TODO: Make this fully private
 pub(crate) mod private {
     use super::*;
@@ -85,10 +84,15 @@ pub(crate) mod private {
 
     impl<'a, T: Message + ?Sized, O: Ownership> Sealed for &'a ManuallyDrop<Id<T, O>> {}
     impl<'a, T: Message + ?Sized> Sealed for &'a mut ManuallyDrop<Id<T, Owned>> {}
+
+    impl Sealed for *const Class {}
+    impl<'a> Sealed for &'a Class {}
 }
 
 /// Types that can directly be used as the receiver of Objective-C messages.
 ///
+/// Examples include objects, classes, and blocks.
+///
 /// This is a sealed trait (for now) that is automatically implemented for
 /// pointers to types implementing [`Message`], so that code can be generic
 /// over the message receiver.
@@ -281,6 +285,20 @@ unsafe impl<'a, T: Message + ?Sized> MessageReceiver for &'a mut ManuallyDrop<Id
     }
 }
 
+unsafe impl MessageReceiver for *const Class {
+    #[inline]
+    fn as_raw_receiver(self) -> *mut Object {
+        self as *mut Class as *mut Object
+    }
+}
+
+unsafe impl<'a> MessageReceiver for &'a Class {
+    #[inline]
+    fn as_raw_receiver(self) -> *mut Object {
+        self as *const Class as *mut Class as *mut Object
+    }
+}
+
 /// Types that may be used as the arguments of an Objective-C message.
 ///
 /// This is implemented for tuples of up to 12 arguments, where each argument