Fix c_char mismatch between std::os::raw and CStr on arm64.

This should only be necessary until rust-lang/rust#29775 lands in stable
Rust with 1.6.

Author: SSheldon

src/declare.rs

@@ -40,9 +40,10 @@ use std::fmt;
 use std::mem;
 use std::ptr;
 
-use {Encode, Message};
 use runtime::{Class, Imp, NO, Object, Sel, self};
 use verify::EncodeArguments;
+use {Encode, Message};
+use to_c_str;
 
 /// An error returned from `MethodImplementation::imp_for` to indicate that a
 /// selector and function accept unequal numbers of arguments.
@@ -148,7 +149,7 @@ impl ClassDecl {
         let name = CString::new(name).unwrap();
         let super_ptr = superclass.map_or(ptr::null(), |c| c);
         let cls = unsafe {
-            runtime::objc_allocateClassPair(super_ptr, name.as_ptr(), 0)
+            runtime::objc_allocateClassPair(super_ptr, to_c_str(&name), 0)
         };
         if cls.is_null() {
             None
@@ -171,7 +172,7 @@ impl ClassDecl {
         };
 
         let success = runtime::class_addMethod(self.cls, sel, imp,
-            types.as_ptr());
+            to_c_str(&types));
         assert!(success != NO, "Failed to add method {:?}", sel);
     }
 
@@ -191,7 +192,7 @@ impl ClassDecl {
         let cls_obj = self.cls as *const Object;
         let metaclass = runtime::object_getClass(cls_obj) as *mut Class;
         let success = runtime::class_addMethod(metaclass, sel, imp,
-            types.as_ptr());
+            to_c_str(&types));
         assert!(success != NO, "Failed to add class method {:?}", sel);
     }
 
@@ -203,8 +204,8 @@ impl ClassDecl {
         let size = mem::size_of::<T>();
         let align = log2_align_of::<T>();
         let success = unsafe {
-            runtime::class_addIvar(self.cls, c_name.as_ptr(), size, align,
-                encoding.as_ptr())
+            runtime::class_addIvar(self.cls, to_c_str(&c_name), size, align,
+                to_c_str(&encoding))
         };
         assert!(success != NO, "Failed to add ivar {}", name);
     }

src/encode.rs

@@ -1,10 +1,10 @@
-use std::ffi::CStr;
 use std::fmt;
 use std::os::raw::{c_char, c_void};
 use std::str;
 use malloc_buf::MallocBuffer;
 
 use runtime::{Class, Object, Sel};
+use from_c_str;
 
 const QUALIFIERS: &'static [char] = &[
     'r', // const
@@ -101,7 +101,7 @@ pub fn from_str(code: &str) -> Encoding {
 }
 
 pub unsafe fn from_malloc_str(ptr: *mut c_char) -> Encoding {
-    let s = CStr::from_ptr(ptr);
+    let s = from_c_str(ptr);
     let bytes = s.to_bytes_with_nul();
     assert!(str::from_utf8(bytes).is_ok());
     let buf = MallocBuffer::new(ptr as *mut u8, bytes.len()).unwrap();

src/lib.rs

@@ -64,3 +64,19 @@ mod verify;
 
 #[cfg(test)]
 mod test_utils;
+
+// The from_c_str and to_c_str methods are unfortunately needed because,
+// prior to Rust 1.6, CStr uses a different definition of c_char than
+// std::os::raw on arm64.
+// TODO: remove this after most people are on Rust 1.6+
+
+use std::ffi::CStr;
+use std::os::raw::c_char;
+
+unsafe fn from_c_str<'a>(ptr: *const c_char) -> &'a CStr {
+    CStr::from_ptr(ptr as *const _)
+}
+
+fn to_c_str(s: &CStr) -> *const c_char {
+    s.as_ptr() as *const _
+}

src/runtime.rs

@@ -3,7 +3,7 @@
 //! For more information on foreign functions, see Apple's documentation:
 //! https://developer.apple.com/library/mac/documentation/Cocoa/Reference/ObjCRuntimeRef/index.html
 
-use std::ffi::{CStr, CString};
+use std::ffi::CString;
 use std::fmt;
 use std::os::raw::{c_char, c_int, c_uint, c_void};
 use std::ptr;
@@ -12,6 +12,7 @@ use malloc_buf::MallocBuffer;
 
 use encode;
 use {Encode, Encoding};
+use {from_c_str, to_c_str};
 
 /// The Objective-C `BOOL` type.
 ///
@@ -158,14 +159,14 @@ impl Sel {
     pub fn register(name: &str) -> Sel {
         let name = CString::new(name).unwrap();
         unsafe {
-            sel_registerName(name.as_ptr())
+            sel_registerName(to_c_str(&name))
         }
     }
 
     /// Returns the name of the method specified by self.
     pub fn name(&self) -> &str {
         let name = unsafe {
-            CStr::from_ptr(sel_getName(*self))
+            from_c_str(sel_getName(*self))
         };
         str::from_utf8(name.to_bytes()).unwrap()
     }
@@ -195,7 +196,7 @@ impl Ivar {
     /// Returns the name of self.
     pub fn name(&self) -> &str {
         let name = unsafe {
-            CStr::from_ptr(ivar_getName(self))
+            from_c_str(ivar_getName(self))
         };
         str::from_utf8(name.to_bytes()).unwrap()
     }
@@ -211,7 +212,7 @@ impl Ivar {
     /// Returns the `Encoding` of self.
     pub fn type_encoding(&self) -> Encoding {
         let encoding = unsafe {
-            CStr::from_ptr(ivar_getTypeEncoding(self))
+            from_c_str(ivar_getTypeEncoding(self))
         };
         let s = str::from_utf8(encoding.to_bytes()).unwrap();
         encode::from_str(s)
@@ -268,7 +269,7 @@ impl Class {
     pub fn get(name: &str) -> Option<&'static Class> {
         let name = CString::new(name).unwrap();
         unsafe {
-            let cls = objc_getClass(name.as_ptr());
+            let cls = objc_getClass(to_c_str(&name));
             if cls.is_null() { None } else { Some(&*cls) }
         }
     }
@@ -292,7 +293,7 @@ impl Class {
     /// Returns the name of self.
     pub fn name(&self) -> &str {
         let name = unsafe {
-            CStr::from_ptr(class_getName(self))
+            from_c_str(class_getName(self))
         };
         str::from_utf8(name.to_bytes()).unwrap()
     }
@@ -335,7 +336,7 @@ impl Class {
     pub fn instance_variable(&self, name: &str) -> Option<&Ivar> {
         let name = CString::new(name).unwrap();
         unsafe {
-            let ivar = class_getInstanceVariable(self, name.as_ptr());
+            let ivar = class_getInstanceVariable(self, to_c_str(&name));
             if ivar.is_null() { None } else { Some(&*ivar) }
         }
     }