Tweak some type annotations for better verification.

Author: SSheldon

src/array.rs

@@ -1,6 +1,7 @@
 use std::cmp::Ordering;
 use std::marker::PhantomData;
 use std::ops::{Index, Range};
+use std::os::raw::c_void;
 
 use objc::runtime::{Class, Object};
 use objc_id::{Id, Owned, Ownership, Shared, ShareId};
@@ -264,9 +265,11 @@ pub trait INSMutableArray : INSArray {
         let f: extern fn(&Self::Item, &Self::Item, &mut F) -> NSComparisonResult =
             compare_with_closure;
         let mut closure = compare;
+        let closure_ptr: *mut F = &mut closure;
+        let context = closure_ptr as *mut c_void;
         unsafe {
             let _: () = msg_send![self, sortUsingFunction:f
-                                                  context:&mut closure];
+                                                  context:context];
         }
     }
 }

src/data.rs

@@ -29,9 +29,10 @@ pub trait INSData : INSObject {
 
     fn with_bytes(bytes: &[u8]) -> Id<Self> {
         let cls = Self::class();
+        let bytes_ptr = bytes.as_ptr() as *const c_void;
         unsafe {
             let obj: *mut Self = msg_send![cls, alloc];
-            let obj: *mut Self = msg_send![obj, initWithBytes:bytes.as_ptr()
+            let obj: *mut Self = msg_send![obj, initWithBytes:bytes_ptr
                                                        length:bytes.len()];
             Id::from_retained_ptr(obj)
         }
@@ -47,10 +48,11 @@ pub trait INSData : INSObject {
         let dealloc: &Block<(*mut c_void, usize), ()> = &dealloc;
 
         let mut bytes = bytes;
+        let bytes_ptr = bytes.as_mut_ptr() as *mut c_void;
         let cls = Self::class();
         unsafe {
             let obj: *mut Self = msg_send![cls, alloc];
-            let obj: *mut Self = msg_send![obj, initWithBytesNoCopy:bytes.as_mut_ptr()
+            let obj: *mut Self = msg_send![obj, initWithBytesNoCopy:bytes_ptr
                                                              length:bytes.len()
                                                         deallocator:dealloc];
             mem::forget(bytes);
@@ -92,17 +94,19 @@ pub trait INSMutableData : INSData {
     }
 
     fn append(&mut self, bytes: &[u8]) {
+        let bytes_ptr = bytes.as_ptr() as *const c_void;
         unsafe {
-            let _: () = msg_send![self, appendBytes:bytes.as_ptr()
+            let _: () = msg_send![self, appendBytes:bytes_ptr
                                              length:bytes.len()];
         }
     }
 
     fn replace_range(&mut self, range: Range<usize>, bytes: &[u8]) {
         let range = NSRange::from_range(range);
+        let bytes_ptr = bytes.as_ptr() as *const c_void;
         unsafe {
             let _: () = msg_send![self, replaceBytesInRange:range
-                                                  withBytes:bytes.as_ptr()
+                                                  withBytes:bytes_ptr
                                                      length:bytes.len()];
         }
     }

src/dictionary.rs

@@ -44,7 +44,7 @@ pub trait INSDictionary : INSObject {
         let len = self.count();
         let mut keys = Vec::with_capacity(len);
         unsafe {
-            let _: () = msg_send![self, getObjects:ptr::null_mut::<Self::Value>()
+            let _: () = msg_send![self, getObjects:ptr::null_mut::<&Self::Value>()
                                            andKeys:keys.as_mut_ptr()];
             keys.set_len(len);
         }
@@ -56,7 +56,7 @@ pub trait INSDictionary : INSObject {
         let mut vals = Vec::with_capacity(len);
         unsafe {
             let _: () = msg_send![self, getObjects:vals.as_mut_ptr()
-                                           andKeys:ptr::null_mut::<Self::Key>()];
+                                           andKeys:ptr::null_mut::<&Self::Key>()];
             vals.set_len(len);
         }
         vals

src/string.rs

@@ -1,4 +1,4 @@
-use std::os::raw::c_char;
+use std::os::raw::{c_char, c_void};
 use std::slice;
 use std::str;
 
@@ -51,9 +51,10 @@ pub trait INSString : INSObject {
 
     fn from_str(string: &str) -> Id<Self> {
         let cls = Self::class();
+        let bytes = string.as_ptr() as *const c_void;
         unsafe {
             let obj: *mut Self = msg_send![cls, alloc];
-            let obj: *mut Self = msg_send![obj, initWithBytes:string.as_ptr()
+            let obj: *mut Self = msg_send![obj, initWithBytes:bytes
                                                        length:string.len()
                                                      encoding:UTF8_ENCODING];
             Id::from_retained_ptr(obj)

src/value.rs

@@ -2,7 +2,7 @@ use std::any::Any;
 use std::ffi::{CStr, CString};
 use std::marker::PhantomData;
 use std::mem;
-use std::os::raw::c_char;
+use std::os::raw::{c_char, c_void};
 use std::str;
 
 use objc::{Encode, Encoding};
@@ -18,7 +18,9 @@ pub trait INSValue : INSObject {
         assert!(Self::Value::encode() == self.encoding());
         unsafe {
             let mut value = mem::uninitialized::<Self::Value>();
-            let _: () = msg_send![self, getValue:&mut value];
+            let value_ptr: *mut Self::Value = &mut value;
+            let bytes = value_ptr as *mut c_void;
+            let _: () = msg_send![self, getValue:bytes];
             value
         }
     }
@@ -34,10 +36,12 @@ pub trait INSValue : INSObject {
 
     fn from_value(value: Self::Value) -> Id<Self> {
         let cls = Self::class();
+        let value_ptr: *const Self::Value = &value;
+        let bytes = value_ptr as *const c_void;
         let encoding = CString::new(Self::Value::encode().as_str()).unwrap();
         unsafe {
             let obj: *mut Self = msg_send![cls, alloc];
-            let obj: *mut Self = msg_send![obj, initWithBytes:&value
+            let obj: *mut Self = msg_send![obj, initWithBytes:bytes
                                                      objCType:encoding.as_ptr()];
             Id::from_retained_ptr(obj)
         }