Add msg_send_id to help with following memory management rules

Author: madsmtm

objc2/examples/introspection.rs

@@ -1,6 +1,6 @@
 use objc2::rc::{Id, Owned};
 use objc2::runtime::{Class, Object};
-use objc2::{class, msg_send};
+use objc2::{class, msg_send, msg_send_id};
 #[cfg(feature = "malloc")]
 use objc2::{sel, Encode};
 
@@ -20,9 +20,8 @@ fn main() {
 
     // Allocate an instance
     let obj: Id<Object, Owned> = unsafe {
-        let obj: *mut Object = msg_send![cls, alloc];
-        let obj: *mut Object = msg_send![obj, init];
-        Id::new(obj).unwrap()
+        let obj: Id<Object, Owned> = msg_send_id![cls, alloc].unwrap();
+        msg_send_id![obj, init].unwrap()
     };
     println!("NSObject address: {:p}", obj);
 

objc2/src/lib.rs

@@ -36,9 +36,8 @@
 //!
 //! // Creation
 //! let cls = class!(NSObject);
-//! let obj: *mut Object = unsafe { msg_send![cls, new] };
 //! let obj: Id<Object, Owned> = unsafe {
-//!     Id::new(obj).expect("Failed allocating object")
+//!     msg_send_id![cls, new].expect("Failed allocating object")
 //! };
 //!
 //! // Usage
@@ -152,6 +151,8 @@ pub use crate::message::{Message, MessageArguments, MessageError, MessageReceive
 pub use crate::cache::CachedClass as __CachedClass;
 pub use crate::cache::CachedSel as __CachedSel;
 
+pub use crate::macros::__starts_with_str;
+
 #[macro_use]
 mod macros;
 

objc2/src/macros.rs

@@ -172,3 +172,75 @@ macro_rules! msg_send {
         result
     });
 }
+
+/// TODO
+#[macro_export]
+macro_rules! msg_send_id {
+    ($obj:expr, $name:ident) => ({
+        const NAME: &[u8] = stringify!($name).as_bytes();
+        $crate::msg_send_id!(@ $obj, NAME, $name)
+    });
+    ($obj:expr, $($name:ident: $arg:expr),+ $(,)?) => ({
+        const NAME: &[u8] = concat!($(stringify!($name), ':'),+).as_bytes();
+        $crate::msg_send_id!(@ $obj, NAME, $($name: $arg),+)
+    });
+    (@ $obj:expr, $name:ident, $($sel:tt)+) => {{
+        const IS_INIT: bool = $crate::__starts_with_str($name, b"init");
+        const IS_RETAINED: bool = {
+            $crate::__starts_with_str($name, b"alloc")
+                || $crate::__starts_with_str($name, b"new")
+                || $crate::__starts_with_str($name, b"copy")
+                || $crate::__starts_with_str($name, b"mutableCopy")
+                || $crate::__starts_with_str($name, b"init")
+        };
+
+        ::std::println!("IS_INIT: {}", IS_INIT);
+        ::std::println!("IS_RETAINED: {}", IS_RETAINED);
+
+        let result = if IS_INIT {
+            // TODO: Ensure `obj` is Id here
+            let obj = ::core::mem::ManuallyDrop::new($obj);
+            $crate::msg_send![obj, $($sel)+]
+        } else {
+            $crate::msg_send![$obj, $($sel)+]
+        };
+        if IS_RETAINED {
+            $crate::rc::Id::new(result)
+        } else {
+            // All code between the `msg_send!` and the `retain_autoreleased` must
+            // be able to be optimized away for this to work.
+            $crate::rc::Id::retain_autoreleased(result)
+        }
+    }};
+}
+
+#[doc(hidden)]
+pub const fn __starts_with_str(haystack: &[u8], needle: &[u8]) -> bool {
+    if needle.len() > haystack.len() {
+        return false;
+    }
+    let mut i = 0;
+    while i < needle.len() {
+        if needle[i] != haystack[i] {
+            return false;
+        }
+        i += 1;
+    }
+    true
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_starts_with_str() {
+        assert!(__starts_with_str(b"abcdef", b"abc"));
+        assert!(__starts_with_str(b"a", b""));
+        assert!(__starts_with_str(b"", b""));
+
+        assert!(!__starts_with_str(b"abcdef", b"def"));
+        assert!(!__starts_with_str(b"abcdef", b"abb"));
+        assert!(!__starts_with_str(b"", b"a"));
+    }
+}