Merge pull request #139 from madsmtm/various

Various improvements

Author: madsmtm

Cargo.toml

@@ -9,3 +9,4 @@ members = [
     "tests",
     "tests/assembly/*",
 ]
+resolver = "2"

block-sys/Cargo.toml

@@ -2,7 +2,7 @@
 name = "block-sys"
 version = "0.0.3" # Remember to update html_root_url in lib.rs
 authors = ["Mads Marquart <[email protected]>"]
-edition = "2018"
+edition = "2021"
 
 description = "Raw bindings to Apple's C language extension of blocks"
 keywords = ["objective-c", "macos", "ios", "blocks", "sys"]

block2/Cargo.toml

@@ -3,7 +3,7 @@ name = "block2"
 # Remember to update html_root_url in lib.rs and README.md
 version = "0.2.0-alpha.3"
 authors = ["Steven Sheldon", "Mads Marquart <[email protected]>"]
-edition = "2018"
+edition = "2021"
 
 description = "Apple's C language extension of blocks"
 keywords = ["objective-c", "macos", "ios", "blocks"]

objc-sys/Cargo.toml

@@ -2,7 +2,7 @@
 name = "objc-sys"
 version = "0.2.0-alpha.1" # Remember to update html_root_url in lib.rs
 authors = ["Mads Marquart <[email protected]>"]
-edition = "2018"
+edition = "2021"
 
 description = "Raw bindings to the Objective-C runtime and ABI"
 keywords = ["objective-c", "macos", "ios", "objc_msgSend", "sys"]

objc-sys/README.md

@@ -18,6 +18,12 @@ and they act in slightly different ways. By default, Apple platforms link to
 Apple's runtime, but if you're using another runtime you must tell it to this
 library using feature flags.
 
+One could ask, why even bother supporting other runtimes? To that, there's a
+simple answer: _Robustness_. By testing with these alternative runtimes in CI,
+we become by extension much more confident that our implementation doesn't
+rely on brittle unspecified behaviour, and works across different macOS and
+iOS versions.
+
 
 ### Apple's [`objc4`](https://github.com/apple-oss-distributions/objc4)
 
@@ -73,7 +79,7 @@ and `objc_autoreleasePoolPop` is a vital requirement for most applications.
 
 Just so we're being clear, this rules out the GCC [`libobjc`][gcc-libobjc]
 runtime (see [this][gcc-objc-support]), the [`mulle-objc`] runtime and
-[cocotron]. (But support for [`ObjFW`] may be added).
+[cocotron]. (But support for [`ObjFW`] and [`darling`] may be added).
 More information on different runtimes can be found in GNUStep's
 [Objective-C Compiler and Runtime FAQ][gnustep-faq].
 
@@ -83,6 +89,7 @@ More information on different runtimes can be found in GNUStep's
 [`mulle-objc`]: https://github.com/mulle-objc/mulle-objc-runtime
 [cocotron]: https://cocotron.org/
 [`ObjFW`]: https://github.com/ObjFW/ObjFW
+[`darling`]: https://github.com/darlinghq/darling-objc4
 [gnustep-faq]: http://wiki.gnustep.org/index.php/Objective-C_Compiler_and_Runtime_FAQ
 
 

objc2-encode/Cargo.toml

@@ -3,7 +3,7 @@ name = "objc2-encode"
 # Remember to update html_root_url in lib.rs and README.md
 version = "2.0.0-beta.2"
 authors = ["Steven Sheldon", "Mads Marquart <[email protected]>"]
-edition = "2018"
+edition = "2021"
 
 description = "Objective-C type-encodings"
 keywords = ["objective-c", "macos", "ios", "encode"]

objc2-foundation/Cargo.toml

@@ -2,7 +2,7 @@
 name = "objc2-foundation"
 version = "0.2.0-alpha.4" # Remember to update html_root_url in lib.rs
 authors = ["Steven Sheldon", "Mads Marquart <[email protected]>"]
-edition = "2018"
+edition = "2021"
 
 description = "Bindings to the Objective-C Cocoa Foundation framework"
 keywords = ["objective-c", "macos", "ios", "cocoa", "uikit"]

objc2/Cargo.toml

@@ -2,7 +2,7 @@
 name = "objc2"
 version = "0.3.0-alpha.6" # Remember to update html_root_url in lib.rs
 authors = ["Steven Sheldon", "Mads Marquart <[email protected]>"]
-edition = "2018"
+edition = "2021"
 
 description = "Objective-C interface and runtime bindings"
 keywords = ["objective-c", "macos", "ios", "objc_msgSend"]

objc2/examples/talk_to_me.rs

@@ -11,14 +11,15 @@ extern "C" {}
 // Only works on macOS >= 10.15 or iOS > 7.0
 fn main() {
     let text = "Hello from Rust!";
+    const UTF8_ENCODING: NSUInteger = 4;
 
     let string: *const Object = unsafe { msg_send![class!(NSString), alloc] };
     let string = unsafe {
         msg_send![
             string,
             initWithBytes: text.as_ptr() as *const c_void,
             length: text.len(),
-            encoding: 4 as NSUInteger, // UTF8_ENCODING on macOS / iOS
+            encoding: UTF8_ENCODING,
         ]
     };
     let string: Id<Object, Shared> = unsafe { Id::new(string).unwrap() };

objc2/src/declare.rs

@@ -39,6 +39,7 @@ use alloc::string::ToString;
 use core::mem;
 use core::mem::ManuallyDrop;
 use core::ptr;
+use core::ptr::NonNull;
 use std::ffi::CString;
 
 use crate::runtime::{Bool, Class, Imp, Object, Protocol, Sel};
@@ -120,7 +121,7 @@ fn log2_align_of<T>() -> u8 {
 /// before registering it.
 #[derive(Debug)]
 pub struct ClassDecl {
-    cls: *mut Class,
+    cls: NonNull<Class>,
 }
 
 // SAFETY: The stuff that touch global state does so using locks internally.
@@ -138,23 +139,23 @@ unsafe impl Send for ClassDecl {}
 unsafe impl Sync for ClassDecl {}
 
 impl ClassDecl {
-    fn with_superclass(name: &str, superclass: Option<&Class>) -> Option<ClassDecl> {
+    fn as_ptr(&self) -> *mut ffi::objc_class {
+        self.cls.as_ptr().cast()
+    }
+
+    fn with_superclass(name: &str, superclass: Option<&Class>) -> Option<Self> {
         let name = CString::new(name).unwrap();
         let super_ptr = superclass.map_or(ptr::null(), |c| c) as _;
         let cls = unsafe { ffi::objc_allocateClassPair(super_ptr, name.as_ptr(), 0) };
-        if cls.is_null() {
-            None
-        } else {
-            Some(ClassDecl { cls: cls as _ })
-        }
+        NonNull::new(cls.cast()).map(|cls| Self { cls })
     }
 
     /// Constructs a [`ClassDecl`] with the given name and superclass.
     ///
     /// Returns [`None`] if the class couldn't be allocated, or a class with
     /// that name already exist.
-    pub fn new(name: &str, superclass: &Class) -> Option<ClassDecl> {
-        ClassDecl::with_superclass(name, Some(superclass))
+    pub fn new(name: &str, superclass: &Class) -> Option<Self> {
+        Self::with_superclass(name, Some(superclass))
     }
 
     /// Constructs a [`ClassDecl`] declaring a new root class with the given
@@ -171,12 +172,10 @@ impl ClassDecl {
     /// the entire `NSObject` protocol is implemented.
     /// Functionality it expects, like implementations of `-retain` and
     /// `-release` used by ARC, will not be present otherwise.
-    pub fn root(name: &str, intitialize_fn: extern "C" fn(&Class, Sel)) -> Option<ClassDecl> {
-        let mut decl = ClassDecl::with_superclass(name, None);
+    pub fn root(name: &str, intitialize_fn: extern "C" fn(&Class, Sel)) -> Option<Self> {
+        let mut decl = Self::with_superclass(name, None);
         if let Some(ref mut decl) = decl {
-            unsafe {
-                decl.add_class_method(sel!(initialize), intitialize_fn);
-            }
+            unsafe { decl.add_class_method(sel!(initialize), intitialize_fn) };
         }
         decl
     }
@@ -209,7 +208,7 @@ impl ClassDecl {
         let types = method_type_encoding(&F::Ret::ENCODING, encs);
         let success = Bool::from_raw(unsafe {
             ffi::class_addMethod(
-                self.cls as _,
+                self.as_ptr(),
                 sel.as_ptr() as _,
                 Some(func.imp()),
                 types.as_ptr(),
@@ -244,7 +243,7 @@ impl ClassDecl {
         );
 
         let types = method_type_encoding(&F::Ret::ENCODING, encs);
-        let metaclass = unsafe { &*self.cls }.metaclass() as *const _ as *mut _;
+        let metaclass = unsafe { self.cls.as_ref() }.metaclass() as *const _ as *mut _;
         let success = Bool::from_raw(unsafe {
             ffi::class_addMethod(
                 metaclass,
@@ -268,7 +267,7 @@ impl ClassDecl {
         let align = log2_align_of::<T>();
         let success = Bool::from_raw(unsafe {
             ffi::class_addIvar(
-                self.cls as _,
+                self.as_ptr(),
                 c_name.as_ptr(),
                 size,
                 align,
@@ -284,7 +283,7 @@ impl ClassDecl {
     ///
     /// If the protocol wasn't successfully added.
     pub fn add_protocol(&mut self, proto: &Protocol) {
-        let success = unsafe { ffi::class_addProtocol(self.cls as _, proto.as_ptr()) };
+        let success = unsafe { ffi::class_addProtocol(self.as_ptr(), proto.as_ptr()) };
         let success = Bool::from_raw(success).as_bool();
         assert!(success, "Failed to add protocol {:?}", proto);
     }
@@ -296,40 +295,40 @@ impl ClassDecl {
     pub fn register(self) -> &'static Class {
         // Forget self, otherwise the class will be disposed in drop
         let cls = ManuallyDrop::new(self).cls;
-        unsafe { ffi::objc_registerClassPair(cls as _) };
-        unsafe { &*cls }
+        unsafe { ffi::objc_registerClassPair(cls.as_ptr().cast()) };
+        unsafe { cls.as_ref() }
     }
 }
 
 impl Drop for ClassDecl {
     fn drop(&mut self) {
-        unsafe { ffi::objc_disposeClassPair(self.cls as _) }
+        unsafe { ffi::objc_disposeClassPair(self.as_ptr()) }
     }
 }
 
 /// A type for declaring a new protocol and adding new methods to it
 /// before registering it.
 #[derive(Debug)]
 pub struct ProtocolDecl {
-    proto: *mut Protocol,
+    proto: NonNull<Protocol>,
 }
 
 // SAFETY: Similar to ClassDecl
 unsafe impl Send for ProtocolDecl {}
 unsafe impl Sync for ProtocolDecl {}
 
 impl ProtocolDecl {
+    fn as_ptr(&self) -> *mut ffi::objc_protocol {
+        self.proto.as_ptr().cast()
+    }
+
     /// Constructs a [`ProtocolDecl`] with the given name.
     ///
     /// Returns [`None`] if the protocol couldn't be allocated.
-    pub fn new(name: &str) -> Option<ProtocolDecl> {
+    pub fn new(name: &str) -> Option<Self> {
         let c_name = CString::new(name).unwrap();
         let proto = unsafe { ffi::objc_allocateProtocol(c_name.as_ptr()) } as *mut Protocol;
-        if proto.is_null() {
-            None
-        } else {
-            Some(ProtocolDecl { proto })
-        }
+        NonNull::new(proto).map(|proto| Self { proto })
     }
 
     fn add_method_description_common<Args, Ret>(
@@ -353,7 +352,7 @@ impl ProtocolDecl {
         let types = method_type_encoding(&Ret::ENCODING, encs);
         unsafe {
             ffi::protocol_addMethodDescription(
-                self.proto as _,
+                self.as_ptr(),
                 sel.as_ptr() as _,
                 types.as_ptr(),
                 Bool::new(is_required).as_raw(),
@@ -383,16 +382,16 @@ impl ProtocolDecl {
     /// Adds a requirement on another protocol.
     pub fn add_protocol(&mut self, proto: &Protocol) {
         unsafe {
-            ffi::protocol_addProtocol(self.proto as _, proto.as_ptr());
+            ffi::protocol_addProtocol(self.as_ptr(), proto.as_ptr());
         }
     }
 
     /// Registers the [`ProtocolDecl`], consuming it and returning a reference
     /// to the newly registered [`Protocol`].
     pub fn register(self) -> &'static Protocol {
         unsafe {
-            ffi::objc_registerProtocol(self.proto as _);
-            &*self.proto
+            ffi::objc_registerProtocol(self.as_ptr());
+            self.proto.as_ref()
         }
     }
 }

objc2/src/message/apple/arm.rs

@@ -8,7 +8,8 @@ use crate::{Encode, Encoding};
 /// Double-word sized fundamental data types don't use stret, but any
 /// composite type larger than 4 bytes does.
 ///
-/// <http://infocenter.arm.com/help/topic/com.arm.doc.ihi0042e/IHI0042E_aapcs.pdf>
+/// <https://web.archive.org/web/20191016000656/http://infocenter.arm.com/help/topic/com.arm.doc.ihi0042f/IHI0042F_aapcs.pdf>
+/// <https://developer.arm.com/documentation/ihi0042/latest>
 unsafe impl<T: Encode> MsgSendFn for T {
     const MSG_SEND: Imp = {
         if let Encoding::LongLong | Encoding::ULongLong | Encoding::Double = T::ENCODING {

objc2/src/message/apple/mod.rs

@@ -17,6 +17,7 @@ mod arch;
 
 /// On the above architectures we can statically find the correct method to
 /// call from the return type, by looking at it's `Encode` implementation.
+#[allow(clippy::missing_safety_doc)]
 unsafe trait MsgSendFn: Encode {
     const MSG_SEND: Imp;
     const MSG_SEND_SUPER: Imp;

objc2/src/message/apple/x86_64.rs

@@ -9,7 +9,7 @@ use crate::{Encode, Encoding};
 /// MEMORY. If the type has class MEMORY, then the caller provides space for
 /// the return value and passes the address of this storage.
 ///
-/// <http://people.freebsd.org/~obrien/amd64-elf-abi.pdf>
+/// <https://www.uclibc.org/docs/psABI-x86_64.pdf>
 unsafe impl<T: Encode> MsgSendFn for T {
     const MSG_SEND: Imp = {
         // See https://github.com/apple-oss-distributions/objc4/blob/objc4-818.2/runtime/message.h#L156-L172

objc2/src/message/mod.rs

@@ -296,6 +296,9 @@ macro_rules! message_args_impl {
                 let imp: unsafe extern "C" fn(*mut Object, Sel $(, $t)*) -> R = unsafe {
                     mem::transmute(imp)
                 };
+                // TODO: On x86_64 it would be more efficient to use a GOT
+                // entry here (e.g. adding `nonlazybind` in LLVM).
+                // Same can be said of e.g. `objc_retain` and `objc_release`.
                 unsafe { imp(obj, sel $(, $a)*) }
             }
         }

objc2/src/rc/id.rs

@@ -312,7 +312,13 @@ impl<T: Message, O: Ownership> Id<T, O> {
         {
             // Supported since macOS 10.7.
             #[cfg(target_arch = "x86_64")]
-            {} // x86_64 looks at the next call instruction
+            {
+                // x86_64 looks at the next call instruction.
+                //
+                // This is expected to be a PLT entry - if the user specifies
+                // `-Zplt=no`, a GOT entry will be created instead, and this
+                // will not work.
+            }
 
             // Supported since macOS 10.8.
             #[cfg(target_arch = "arm")]
@@ -350,7 +356,7 @@ impl<T: Message, O: Ownership> Id<T, O> {
         {
             // SAFETY: Similar to above.
             unsafe { core::arch::asm!("nop", options(nomem, preserves_flags, nostack)) };
-            // TODO: Possibly more efficient alternative?
+            // TODO: Possibly more efficient alternative? Also consider PLT.
             // #![feature(asm_sym)]
             // core::arch::asm!(
             //     "mov rdi, rax",

objc2/src/rc/weak_id.rs

@@ -1,6 +1,5 @@
 use alloc::boxed::Box;
 use core::cell::UnsafeCell;
-use core::convert::TryFrom;
 use core::fmt;
 use core::marker::PhantomData;
 use core::ptr;
@@ -145,7 +144,7 @@ impl<T: Message> From<Id<T, Shared>> for WeakId<T> {
 impl<T: Message> TryFrom<WeakId<T>> for Id<T, Shared> {
     type Error = ();
     fn try_from(weak: WeakId<T>) -> Result<Self, ()> {
-        return weak.load().ok_or(());
+        weak.load().ok_or(())
     }
 }