Add malloc feature to allow cutting down on dependencies

Author: madsmtm

.github/workflows/apple.yml

@@ -77,7 +77,7 @@ jobs:
       with:
         command: test
         # Not using --all-features because some features are nightly-only
-        args: --no-fail-fast --features block,exception,catch_all,verify_message
+        args: --no-fail-fast --features malloc,block,exception,catch_all,verify_message
 
   build_32_bit:
     name: Build 32-bit
@@ -105,8 +105,14 @@ jobs:
         tar -xyf MacOSX10.13.tar.bz2
         echo "SDKROOT=$(pwd)/MacOSX10.13.sdk" >> $GITHUB_ENV
 
+    - name: Build without features
+      uses: actions-rs/cargo@v1
+      with:
+        command: build
+        args: -Zbuild-std --tests --no-default-features
+
     - name: Build with features
       uses: actions-rs/cargo@v1
       with:
         command: build
-        args: -Zbuild-std --tests --features exception,catch_all,verify_message
+        args: -Zbuild-std --tests --features malloc,exception,catch_all,verify_message

.github/workflows/gnustep.yml

@@ -148,4 +148,4 @@ jobs:
       with:
         command: test
         # Not using --all-features because some features are nightly-only
-        args: --no-fail-fast --features gnustep-1-9,block,exception,catch_all,verify_message
+        args: --no-fail-fast --features gnustep-1-9,malloc,block,exception,catch_all,verify_message

objc2/CHANGELOG.md

@@ -19,10 +19,23 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   // `init` takes ownership and possibly returns a new object.
   let obj = Id::new(msg_send![obj, init]);
   ```
+* New cargo feature `"malloc"`, which allows cutting down on dependencies,
+  most crates don't need the introspection features that this provides.
 
 ### Changed
 * Deprecated `runtime::BOOL`, `runtime::YES` and `runtime::NO`. Use the
   newtype `Bool` instead, or low-level `ffi::BOOL`, `ffi::YES` and `ffi::NO`.
+* **BREAKING**: The following methods now require the new `"malloc"` feature
+  flag to be enabled:
+  - `MessageReceiver::verify_message` (temporarily)
+  - `Method::return_type`
+  - `Method::argument_type`
+  - `Class::classes`
+  - `Class::instance_methods`
+  - `Class::adopted_protocols`
+  - `Class::instance_variables`
+  - `Protocol::protocols`
+  - `Protocol::adopted_protocols`
 
 ### Removed
 * **BREAKING**: Removed the raw FFI functions from the `runtime` module. These

objc2/Cargo.toml

@@ -24,11 +24,22 @@ exception = ["cc"]
 
 # Wrap every `objc2::msg_send` call in a `@try/@catch` block
 catch_all = ["exception"]
-verify_message = []
+
+# Verify type encodings on every message send
+# Only intended to be used while debugging!
+verify_message = ["malloc"] # TODO: Remove malloc feature here
+
+# Expose features that require linking to `libc::free`.
+#
+# This is not enabled by default because most users won't need it, and it
+# increases compilation time.
+malloc = ["malloc_buf"]
+
+# Uses nightly features to make AutoreleasePool zero-cost even in debug mode
 unstable_autoreleasesafe = []
 
 [dependencies]
-malloc_buf = "1.0"
+malloc_buf = { version = "1.0", optional = true }
 objc-sys = { path = "../objc-sys", version = "0.1.0" }
 # Loose dependency, because objc2-encode is not expected to change much more
 objc2-encode = { path = "../objc2-encode", version = "^2.0.0-beta.0" }
@@ -39,7 +50,7 @@ cc = { version = "1", optional = true }
 [package.metadata.docs.rs]
 default-target = "x86_64-apple-darwin"
 
-features = ["exception"]
+features = ["exception", "malloc"]
 
 targets = [
     # MacOS

objc2/examples/introspection.rs

@@ -2,17 +2,22 @@ use core::ptr::NonNull;
 
 use objc2::rc::{Id, Owned};
 use objc2::runtime::{Class, Object};
-use objc2::{class, msg_send, sel, Encode};
+use objc2::{class, msg_send};
+#[cfg(feature = "malloc")]
+use objc2::{sel, Encode};
 
 fn main() {
     // Get a class
     let cls = class!(NSObject);
     println!("NSObject size: {}", cls.instance_size());
 
-    // Inspect its ivars
-    println!("NSObject ivars:");
-    for ivar in cls.instance_variables().iter() {
-        println!("{}", ivar.name());
+    #[cfg(feature = "malloc")]
+    {
+        // Inspect its ivars
+        println!("NSObject ivars:");
+        for ivar in cls.instance_variables().iter() {
+            println!("{}", ivar.name());
+        }
     }
 
     // Allocate an instance
@@ -27,12 +32,15 @@ fn main() {
     let isa: *const Class = unsafe { *obj.get_ivar("isa") };
     println!("NSObject isa: {:?}", isa);
 
-    // Inspect a method of the class
-    let hash_sel = sel!(hash);
-    let hash_method = cls.instance_method(hash_sel).unwrap();
-    let hash_return = hash_method.return_type();
-    println!("-[NSObject hash] return type: {:?}", hash_return);
-    assert!(usize::ENCODING.equivalent_to_str(&hash_return));
+    #[cfg(feature = "malloc")]
+    {
+        // Inspect a method of the class
+        let hash_sel = sel!(hash);
+        let hash_method = cls.instance_method(hash_sel).unwrap();
+        let hash_return = hash_method.return_type();
+        println!("-[NSObject hash] return type: {:?}", hash_return);
+        assert!(usize::ENCODING.equivalent_to_str(&hash_return));
+    }
 
     // Invoke a method on the object
     let hash: usize = unsafe { msg_send![obj, hash] };

objc2/src/message/mod.rs

@@ -1,4 +1,4 @@
-use alloc::string::{String, ToString};
+use alloc::string::String;
 use core::fmt;
 use core::mem;
 use core::mem::ManuallyDrop;
@@ -27,6 +27,7 @@ unsafe fn conditional_try<R: Encode>(f: impl FnOnce() -> R) -> Result<R, Message
     Ok(f())
 }
 
+#[cfg(feature = "malloc")]
 mod verify;
 
 #[cfg(apple)]
@@ -37,6 +38,7 @@ mod platform;
 mod platform;
 
 use self::platform::{send_super_unverified, send_unverified};
+#[cfg(feature = "malloc")]
 use self::verify::{verify_message_signature, VerificationError};
 
 /// Types that can be sent Objective-C messages.
@@ -197,6 +199,7 @@ pub unsafe trait MessageReceiver: private::Sealed {
     /// let result = obj.verify_message::<(&Class,), Bool>(sel);
     /// assert!(result.is_ok());
     /// ```
+    #[cfg(feature = "malloc")]
     fn verify_message<A, R>(&self, sel: Sel) -> Result<(), MessageError>
     where
         A: EncodeArguments,
@@ -357,8 +360,10 @@ impl Error for MessageError {
     }
 }
 
+#[cfg(feature = "malloc")]
 impl<'a> From<VerificationError<'a>> for MessageError {
     fn from(err: VerificationError<'_>) -> MessageError {
+        use alloc::string::ToString;
         MessageError(err.to_string())
     }
 }
@@ -448,6 +453,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(feature = "malloc")]
     fn test_verify_message() {
         let obj = test_utils::custom_object();
         assert!(obj.verify_message::<(), u32>(sel!(foo)).is_ok());

objc2/src/runtime.rs

@@ -8,8 +8,10 @@ use core::fmt;
 use core::panic::{RefUnwindSafe, UnwindSafe};
 use core::ptr;
 use core::str;
+#[cfg(feature = "malloc")]
 use malloc_buf::Malloc;
 use std::ffi::{CStr, CString};
+#[cfg(feature = "malloc")]
 use std::os::raw::c_uint;
 
 pub use super::bool::Bool;
@@ -177,6 +179,7 @@ impl Method {
     }
 
     /// Returns the `Encoding` of self's return type.
+    #[cfg(feature = "malloc")]
     pub fn return_type(&self) -> Malloc<str> {
         unsafe {
             let encoding = ffi::method_copyReturnType(self.as_ptr());
@@ -186,6 +189,7 @@ impl Method {
 
     /// Returns the `Encoding` of a single parameter type of self, or
     /// [`None`] if self has no parameter at the given index.
+    #[cfg(feature = "malloc")]
     pub fn argument_type(&self, index: usize) -> Option<Malloc<str>> {
         unsafe {
             let encoding = ffi::method_copyArgumentType(self.as_ptr(), index as c_uint);
@@ -243,6 +247,7 @@ impl Class {
     // fn lookup(name: &str) -> Option<&'static Self>;
 
     /// Obtains the list of registered class definitions.
+    #[cfg(feature = "malloc")]
     pub fn classes() -> Malloc<[&'static Self]> {
         unsafe {
             let mut count: c_uint = 0;
@@ -340,6 +345,7 @@ impl Class {
     }
 
     /// Describes the instance methods implemented by self.
+    #[cfg(feature = "malloc")]
     pub fn instance_methods(&self) -> Malloc<[&Method]> {
         unsafe {
             let mut count: c_uint = 0;
@@ -356,6 +362,7 @@ impl Class {
     }
 
     /// Get a list of the protocols to which this class conforms.
+    #[cfg(feature = "malloc")]
     pub fn adopted_protocols(&self) -> Malloc<[&Protocol]> {
         unsafe {
             let mut count: c_uint = 0;
@@ -365,6 +372,7 @@ impl Class {
     }
 
     /// Describes the instance variables declared by self.
+    #[cfg(feature = "malloc")]
     pub fn instance_variables(&self) -> Malloc<[&Ivar]> {
         unsafe {
             let mut count: c_uint = 0;
@@ -431,6 +439,7 @@ impl Protocol {
     }
 
     /// Obtains the list of registered protocol definitions.
+    #[cfg(feature = "malloc")]
     pub fn protocols() -> Malloc<[&'static Protocol]> {
         unsafe {
             let mut count: c_uint = 0;
@@ -440,6 +449,7 @@ impl Protocol {
     }
 
     /// Get a list of the protocols to which this protocol conforms.
+    #[cfg(feature = "malloc")]
     pub fn adopted_protocols(&self) -> Malloc<[&Protocol]> {
         unsafe {
             let mut count: c_uint = 0;
@@ -612,8 +622,8 @@ mod tests {
         assert!(<u32>::ENCODING.equivalent_to_str(ivar.type_encoding()));
         assert!(ivar.offset() > 0);
 
-        let ivars = cls.instance_variables();
-        assert!(ivars.len() > 0);
+        #[cfg(feature = "malloc")]
+        assert!(cls.instance_variables().len() > 0);
     }
 
     #[test]
@@ -623,11 +633,14 @@ mod tests {
         let method = cls.instance_method(sel).unwrap();
         assert_eq!(method.name().name(), "foo");
         assert_eq!(method.arguments_count(), 2);
-        assert!(<u32>::ENCODING.equivalent_to_str(&method.return_type()));
-        assert!(Sel::ENCODING.equivalent_to_str(&method.argument_type(1).unwrap()));
+        #[cfg(feature = "malloc")]
+        {
+            assert!(<u32>::ENCODING.equivalent_to_str(&method.return_type()));
+            assert!(Sel::ENCODING.equivalent_to_str(&method.argument_type(1).unwrap()));
 
-        let methods = cls.instance_methods();
-        assert!(methods.len() > 0);
+            let methods = cls.instance_methods();
+            assert!(methods.len() > 0);
+        }
     }
 
     #[test]
@@ -648,8 +661,13 @@ mod tests {
     }
 
     #[test]
-    fn test_classes() {
+    fn test_classes_count() {
         assert!(Class::classes_count() > 0);
+    }
+
+    #[test]
+    #[cfg(feature = "malloc")]
+    fn test_classes() {
         let classes = Class::classes();
         assert!(classes.len() > 0);
     }
@@ -660,8 +678,8 @@ mod tests {
         assert_eq!(proto.name(), "CustomProtocol");
         let class = test_utils::custom_class();
         assert!(class.conforms_to(proto));
-        let class_protocols = class.adopted_protocols();
-        assert!(class_protocols.len() > 0);
+        #[cfg(feature = "malloc")]
+        assert!(class.adopted_protocols().len() > 0);
     }
 
     #[test]
@@ -676,17 +694,17 @@ mod tests {
         let sub_proto = test_utils::custom_subprotocol();
         let super_proto = test_utils::custom_protocol();
         assert!(sub_proto.conforms_to(super_proto));
-        let adopted_protocols = sub_proto.adopted_protocols();
-        assert_eq!(adopted_protocols[0], super_proto);
+        #[cfg(feature = "malloc")]
+        assert_eq!(sub_proto.adopted_protocols()[0], super_proto);
     }
 
     #[test]
     fn test_protocols() {
         // Ensure that a protocol has been registered on linux
         let _ = test_utils::custom_protocol();
 
-        let protocols = Protocol::protocols();
-        assert!(protocols.len() > 0);
+        #[cfg(feature = "malloc")]
+        assert!(Protocol::protocols().len() > 0);
     }
 
     #[test]