Merge pull request #3 from madsmtm/chores

Fix warnings, and other chores

Author: madsmtm

objc_foundation/examples/example.rs renamed to examples/foundation.rs

@@ -1,5 +1,3 @@
-extern crate objc_foundation;
-
 use objc_foundation::{
     INSArray, INSCopying, INSDictionary, INSObject, INSString, NSArray, NSDictionary, NSObject,
     NSString,

objc_foundation/examples/custom_class.rs renamed to examples/foundation_custom_class.rs

@@ -1,10 +1,7 @@
-#[macro_use]
-extern crate objc;
-extern crate objc_foundation;
-
 use std::sync::{Once, ONCE_INIT};
 
 use objc::declare::ClassDecl;
+use objc::msg_send;
 use objc::runtime::{Class, Object, Sel};
 use objc::Message;
 use objc_foundation::{INSObject, NSObject};

objc/examples/example.rs renamed to examples/objc.rs

@@ -1,9 +1,6 @@
-#[macro_use]
-extern crate objc;
-
 use objc::rc::StrongPtr;
 use objc::runtime::{Class, Object};
-use objc::Encode;
+use objc::{class, msg_send, Encode};
 
 fn main() {
     // Get a class

objc/src/declare.rs

@@ -10,7 +10,7 @@ The following example demonstrates declaring a class named `MyNumber` that has
 one ivar, a `u32` named `_number` and a `number` method that returns it:
 
 ``` no_run
-# #[macro_use] extern crate objc;
+# use objc::class;
 # use objc::declare::ClassDecl;
 # use objc::runtime::{Class, Object, Sel};
 # fn main() {
@@ -91,7 +91,7 @@ fn count_args(sel: Sel) -> usize {
     sel.name().chars().filter(|&c| c == ':').count()
 }
 
-fn method_type_encoding(ret: &Encoding, args: &[Encoding]) -> CString {
+fn method_type_encoding(ret: &Encoding<'_>, args: &[Encoding<'_>]) -> CString {
     // First two arguments are always self and the selector
     let mut types = format!("{}{}{}", ret, <*mut Object>::ENCODING, Sel::ENCODING);
     for enc in args {
@@ -123,7 +123,7 @@ impl ClassDecl {
         if cls.is_null() {
             None
         } else {
-            Some(ClassDecl { cls: cls })
+            Some(ClassDecl { cls })
         }
     }
 
@@ -159,8 +159,11 @@ impl ClassDecl {
     /// Adds a method with the given name and implementation to self.
     /// Panics if the method wasn't sucessfully added
     /// or if the selector and function take different numbers of arguments.
-    /// Unsafe because the caller must ensure that the types match those that
-    /// are expected when the method is invoked from Objective-C.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that the types match those that are expected
+    /// when the method is invoked from Objective-C.
     pub unsafe fn add_method<F>(&mut self, sel: Sel, func: F)
     where
         F: MethodImplementation<Callee = Object>,
@@ -182,8 +185,11 @@ impl ClassDecl {
     /// Adds a class method with the given name and implementation to self.
     /// Panics if the method wasn't sucessfully added
     /// or if the selector and function take different numbers of arguments.
-    /// Unsafe because the caller must ensure that the types match those that
-    /// are expected when the method is invoked from Objective-C.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that the types match those that are expected
+    /// when the method is invoked from Objective-C.
     pub unsafe fn add_class_method<F>(&mut self, sel: Sel, func: F)
     where
         F: MethodImplementation<Callee = Class>,
@@ -262,7 +268,7 @@ impl ProtocolDecl {
         if proto.is_null() {
             None
         } else {
-            Some(ProtocolDecl { proto: proto })
+            Some(ProtocolDecl { proto })
         }
     }
 

objc/src/exception.rs

@@ -3,6 +3,19 @@ use objc_exception;
 use crate::rc::StrongPtr;
 use crate::runtime::Object;
 
+// Comment copied from `objc_exception`
+
+/// Tries to execute the given closure and catches an Objective-C exception
+/// if one is thrown.
+///
+/// Returns a `Result` that is either `Ok` if the closure succeeded without an
+/// exception being thrown, or an `Err` with a pointer to an exception if one
+/// was thrown. The exception is retained and so must be released.
+///
+/// # Safety
+///
+/// This encourages unwinding through the closure from Objective-C, which is
+/// not safe.
 pub unsafe fn catch_exception<F, R>(closure: F) -> Result<R, StrongPtr>
 where
     F: FnOnce() -> R,

objc/src/lib.rs

@@ -6,7 +6,7 @@ Objective-C Runtime bindings and wrapper for Rust.
 Objective-C objects can be messaged using the [`msg_send!`](macro.msg_send!.html) macro:
 
 ``` no_run
-# #[macro_use] extern crate objc;
+# use objc::{class, msg_send};
 # use objc::runtime::{BOOL, Class, Object};
 # fn main() {
 # unsafe {
@@ -63,11 +63,7 @@ The bindings can be used on Linux or *BSD utilizing the
 #![crate_name = "objc"]
 #![crate_type = "lib"]
 #![warn(missing_docs)]
-
-extern crate malloc_buf;
-extern crate objc_encode;
-#[cfg(feature = "exception")]
-extern crate objc_exception;
+#![allow(clippy::missing_safety_doc)]
 
 pub use objc_encode::{Encode, Encoding};
 

objc/src/macros.rs

@@ -6,7 +6,6 @@ To check for a class that may not exist, use `Class::get`.
 
 # Example
 ``` no_run
-# #[macro_use] extern crate objc;
 # fn main() {
 let cls = class!(NSObject);
 # }
@@ -31,7 +30,6 @@ Registers a selector, returning a `Sel`.
 
 # Example
 ```
-# #[macro_use] extern crate objc;
 # fn main() {
 let sel = sel!(description);
 let sel = sel!(setObject:forKey:);
@@ -64,7 +62,6 @@ Variadic arguments are not currently supported.
 
 # Example
 ``` no_run
-# #[macro_use] extern crate objc;
 # use objc::runtime::Object;
 # fn main() {
 # unsafe {

objc/src/message/apple/mod.rs

@@ -42,7 +42,7 @@ where
 {
     let sup = Super {
         receiver: obj as *mut T as *mut Object,
-        superclass: superclass,
+        superclass,
     };
     let receiver = &sup as *const Super as *mut Object;
     let msg_send_fn = msg_send_super_fn::<R>();

objc/src/message/mod.rs

@@ -70,6 +70,7 @@ pub unsafe trait Message {
         send_message(self, sel, args)
     }
 
+    #[allow(missing_docs)]
     #[cfg(feature = "verify_message")]
     unsafe fn send_message<A, R>(&self, sel: Sel, args: A) -> Result<R, MessageError>
     where
@@ -90,7 +91,7 @@ pub unsafe trait Message {
 
     # Example
     ``` no_run
-    # #[macro_use] extern crate objc;
+    # use objc::{class, msg_send};
     # use objc::runtime::{BOOL, Class, Object};
     # use objc::Message;
     # fn main() {
@@ -195,7 +196,7 @@ Currently, an error may be returned in two cases:
 pub struct MessageError(String);
 
 impl fmt::Display for MessageError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Display::fmt(&self.0, f)
     }
 }
@@ -207,7 +208,7 @@ impl Error for MessageError {
 }
 
 impl<'a> From<VerificationError<'a>> for MessageError {
-    fn from(err: VerificationError) -> MessageError {
+    fn from(err: VerificationError<'_>) -> MessageError {
         MessageError(err.to_string())
     }
 }
@@ -284,8 +285,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::Message;
-    use crate::runtime::Object;
+    use super::*;
     use crate::test_utils;
 
     #[test]

objc/src/message/verify.rs

@@ -12,7 +12,7 @@ pub enum VerificationError<'a> {
 }
 
 impl<'a> fmt::Display for VerificationError<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             VerificationError::NilReceiver(sel) => {
                 write!(f, "Messsaging {:?} to nil", sel)
@@ -55,7 +55,7 @@ impl<'a> fmt::Display for VerificationError<'a> {
     }
 }
 
-pub fn verify_message_signature<A, R>(cls: &Class, sel: Sel) -> Result<(), VerificationError>
+pub fn verify_message_signature<A, R>(cls: &Class, sel: Sel) -> Result<(), VerificationError<'_>>
 where
     A: EncodeArguments,
     R: Encode,