Fix remaining clippy lints

Author: madsmtm

objc/src/declare.rs

@@ -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>,

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

@@ -63,6 +63,7 @@ The bindings can be used on Linux or *BSD utilizing the
 #![crate_name = "objc"]
 #![crate_type = "lib"]
 #![warn(missing_docs)]
+#![allow(clippy::missing_safety_doc)]
 
 pub use objc_encode::{Encode, Encoding};
 

objc/src/rc/strong.rs

@@ -12,14 +12,20 @@ impl StrongPtr {
     /// Constructs a `StrongPtr` to a newly created object that already has a
     /// +1 retain count. This will not retain the object.
     /// When dropped, the object will be released.
-    /// Unsafe because the caller must ensure the given object pointer is valid.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure the given object pointer is valid.
     pub unsafe fn new(ptr: *mut Object) -> Self {
         StrongPtr(ptr)
     }
 
     /// Retains the given object and constructs a `StrongPtr` to it.
     /// When dropped, the object will be released.
-    /// Unsafe because the caller must ensure the given object pointer is valid.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure the given object pointer is valid.
     pub unsafe fn retain(ptr: *mut Object) -> Self {
         StrongPtr(runtime::objc_retain(ptr))
     }

objc/src/rc/weak.rs

@@ -14,7 +14,10 @@ pub struct WeakPtr(Box<UnsafeCell<*mut Object>>);
 
 impl WeakPtr {
     /// Constructs a `WeakPtr` to the given object.
-    /// Unsafe because the caller must ensure the given object pointer is valid.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure the given object pointer is valid.
     pub unsafe fn new(obj: *mut Object) -> Self {
         let ptr = Box::new(UnsafeCell::new(ptr::null_mut()));
         runtime::objc_initWeak(ptr.get(), obj);

objc/src/runtime.rs

@@ -177,6 +177,10 @@ impl Sel {
 
     /// Wraps a raw pointer to a selector into a `Sel` object.
     ///
+    /// # Safety
+    ///
+    /// The pointer must a valid, registered selector.
+    ///
     /// This is almost never what you want; use `Sel::register()` instead.
     #[inline]
     pub unsafe fn from_ptr(ptr: *const c_void) -> Sel {
@@ -478,8 +482,10 @@ impl Object {
 
     /// Returns a reference to the ivar of self with the given name.
     /// Panics if self has no ivar with the given name.
-    /// Unsafe because the caller must ensure that the ivar is actually
-    /// of type `T`.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that the ivar is actually of type `T`.
     pub unsafe fn get_ivar<T>(&self, name: &str) -> &T
     where
         T: Encode,
@@ -503,8 +509,10 @@ impl Object {
 
     /// Returns a mutable reference to the ivar of self with the given name.
     /// Panics if self has no ivar with the given name.
-    /// Unsafe because the caller must ensure that the ivar is actually
-    /// of type `T`.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that the ivar is actually of type `T`.
     pub unsafe fn get_mut_ivar<T>(&mut self, name: &str) -> &mut T
     where
         T: Encode,
@@ -528,8 +536,10 @@ impl Object {
 
     /// Sets the value of the ivar of self with the given name.
     /// Panics if self has no ivar with the given name.
-    /// Unsafe because the caller must ensure that the ivar is actually
-    /// of type `T`.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that the ivar is actually of type `T`.
     pub unsafe fn set_ivar<T>(&mut self, name: &str, value: T)
     where
         T: Encode,

objc_encode/src/parse.rs

@@ -36,43 +36,43 @@ fn rm_enc_prefix<'a>(s: &'a str, enc: &Encoding<'_>) -> Option<&'a str> {
         Sel => ":",
         Unknown => "?",
         BitField(b) => {
-            let s = rm_prefix(s, "b")?;
+            let s = s.strip_prefix('b')?;
             return rm_int_prefix(s, b);
         }
         Pointer(t) => {
-            let s = rm_prefix(s, "^")?;
+            let s = s.strip_prefix('^')?;
             return rm_enc_prefix(s, t);
         }
         Array(len, item) => {
             let mut s = s;
-            s = rm_prefix(s, "[")?;
+            s = s.strip_prefix('[')?;
             s = rm_int_prefix(s, len)?;
             s = rm_enc_prefix(s, item)?;
-            return rm_prefix(s, "]");
+            return s.strip_prefix(']');
         }
         Struct(name, fields) => {
             let mut s = s;
-            s = rm_prefix(s, "{")?;
-            s = rm_prefix(s, name)?;
-            s = rm_prefix(s, "=")?;
+            s = s.strip_prefix('{')?;
+            s = s.strip_prefix(name)?;
+            s = s.strip_prefix('=')?;
             for field in fields {
                 s = rm_enc_prefix(s, field)?;
             }
-            return rm_prefix(s, "}");
+            return s.strip_prefix('}');
         }
         Union(name, members) => {
             let mut s = s;
-            s = rm_prefix(s, "(")?;
-            s = rm_prefix(s, name)?;
-            s = rm_prefix(s, "=")?;
+            s = s.strip_prefix('(')?;
+            s = s.strip_prefix(name)?;
+            s = s.strip_prefix('=')?;
             for member in members {
                 s = rm_enc_prefix(s, member)?;
             }
-            return rm_prefix(s, ")");
+            return s.strip_prefix(')');
         }
     };
 
-    rm_prefix(s, code)
+    s.strip_prefix(code)
 }
 
 fn chomp_int(s: &str) -> Option<(u32, &str)> {
@@ -88,14 +88,6 @@ fn rm_int_prefix(s: &str, other: u32) -> Option<&str> {
     chomp_int(s).and_then(|(n, t)| if other == n { Some(t) } else { None })
 }
 
-fn rm_prefix<'a>(s: &'a str, other: &str) -> Option<&'a str> {
-    if s.starts_with(other) {
-        Some(&s[other.len()..])
-    } else {
-        None
-    }
-}
-
 pub fn eq_enc(s: &str, enc: &Encoding<'_>) -> bool {
     // strip qualifiers
     let s = s.trim_start_matches(QUALIFIERS);

objc_exception/src/lib.rs

@@ -22,7 +22,10 @@ pub enum Exception {}
 /// Throws an Objective-C exception.
 /// The argument must be a pointer to an Objective-C object.
 ///
-/// Unsafe because this unwinds from Objective-C.
+/// # Safety
+///
+/// This unwinds from Objective-C, and the exception must be caught using an
+/// Objective-C exception handler.
 pub unsafe fn throw(exception: *mut Exception) -> ! {
     RustObjCExceptionThrow(exception as *mut _);
     unreachable!();
@@ -64,7 +67,9 @@ where
 /// 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.
 ///
-/// Unsafe because this encourages unwinding through the closure from
+/// # Safety
+///
+/// This encourages unwinding through the closure from
 /// Objective-C, which is not safe.
 pub unsafe fn r#try<F, R>(closure: F) -> Result<R, *mut Exception>
 where

objc_foundation/src/data.rs

@@ -12,6 +12,10 @@ pub trait INSData: INSObject {
         unsafe { msg_send![self, length] }
     }
 
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
     fn bytes(&self) -> &[u8] {
         let ptr: *const c_void = unsafe { msg_send![self, bytes] };
         // The bytes pointer may be null for length zero

objc_foundation/src/enumerator.rs

@@ -21,6 +21,12 @@ impl<'a, T> NSEnumerator<'a, T>
 where
     T: INSObject,
 {
+    /// TODO
+    ///
+    /// # Safety
+    ///
+    /// The object pointer must be a valid `NSEnumerator` with `Owned`
+    /// ownership.
     pub unsafe fn from_ptr(ptr: *mut Object) -> NSEnumerator<'a, T> {
         NSEnumerator {
             id: Id::from_ptr(ptr),

objc_foundation/src/string.rs

@@ -36,6 +36,10 @@ pub trait INSString: INSObject {
         unsafe { msg_send![self, lengthOfBytesUsingEncoding: UTF8_ENCODING] }
     }
 
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
     fn as_str(&self) -> &str {
         let bytes = unsafe {
             let bytes: *const c_char = msg_send![self, UTF8String];

objc_id/src/id.rs

@@ -54,8 +54,11 @@ where
 
     /// Constructs an `Id` from a pointer to an unretained object and
     /// retains it. Panics if the pointer is null.
-    /// Unsafe because the pointer must be to a valid object and
-    /// the caller must ensure the ownership is correct.
+    ///
+    /// # Safety
+    ///
+    /// The pointer must be to a valid object and the caller must ensure the
+    /// ownership is correct.
     pub unsafe fn from_ptr(ptr: *mut T) -> Id<T, O> {
         assert!(
             !ptr.is_null(),
@@ -67,8 +70,11 @@ where
     /// Constructs an `Id` from a pointer to a retained object; this won't
     /// retain the pointer, so the caller must ensure the object has a +1
     /// retain count. Panics if the pointer is null.
-    /// Unsafe because the pointer must be to a valid object and
-    /// the caller must ensure the ownership is correct.
+    ///
+    /// # Safety
+    ///
+    /// The pointer must be to a valid object and the caller must ensure the
+    /// ownership is correct.
     pub unsafe fn from_retained_ptr(ptr: *mut T) -> Id<T, O> {
         assert!(
             !ptr.is_null(),
@@ -125,10 +131,6 @@ where
     fn eq(&self, other: &Id<T, O>) -> bool {
         self.deref() == other.deref()
     }
-
-    fn ne(&self, other: &Id<T, O>) -> bool {
-        self.deref() != other.deref()
-    }
 }
 
 impl<T, O> Eq for Id<T, O> where T: Eq {}