Use newtype structs.

Author: zummenix

src/base.rs

@@ -36,7 +36,6 @@ impl CFIndexConvertible for usize {
 
 pub type CFOptionFlags = u32;
 
-#[allow(dead_code)]
 #[repr(C)]
 #[derive(Copy)]
 pub struct CFRange {
@@ -73,23 +72,21 @@ struct __CFType;
 pub type CFTypeRef = *const __CFType;
 
 /// Superclass of all Core Foundation objects.
-pub struct CFType {
-    obj: CFTypeRef,
-}
+pub struct CFType(CFTypeRef);
 
 impl Clone for CFType {
     #[inline]
     fn clone(&self) -> CFType {
         unsafe {
-            TCFType::wrap_under_get_rule(self.obj)
+            TCFType::wrap_under_get_rule(self.as_concrete_TypeRef())
         }
     }
 }
 
 impl Drop for CFType {
     fn drop(&mut self) {
         unsafe {
-            CFRelease(self.obj)
+            CFRelease(self.as_CFTypeRef())
         }
     }
 }
@@ -157,7 +154,8 @@ pub trait TCFType<ConcreteTypeRef> {
 impl TCFType<CFTypeRef> for CFType {
     #[inline]
     fn as_concrete_TypeRef(&self) -> CFTypeRef {
-        self.obj
+        let CFType(obj) = *self;
+        obj
     }
 
     #[inline]
@@ -173,9 +171,7 @@ impl TCFType<CFTypeRef> for CFType {
 
     #[inline]
     unsafe fn wrap_under_create_rule(obj: CFTypeRef) -> CFType {
-        CFType {
-            obj: obj,
-        }
+        CFType(obj)
     }
 
     #[inline]

src/boolean.rs

@@ -20,11 +20,7 @@ struct __CFBoolean;
 pub type CFBooleanRef = *const __CFBoolean;
 
 /// A Boolean type.
-///
-/// FIXME(pcwalton): Should be a newtype struct, but that fails due to a Rust compiler bug.
-pub struct CFBoolean {
-    obj: CFBooleanRef,
-}
+pub struct CFBoolean(CFBooleanRef);
 
 impl Drop for CFBoolean {
     fn drop(&mut self) {
@@ -37,7 +33,8 @@ impl Drop for CFBoolean {
 impl TCFType<CFBooleanRef> for CFBoolean {
     #[inline]
     fn as_concrete_TypeRef(&self) -> CFBooleanRef {
-        self.obj
+        let CFBoolean(obj) = *self;
+        obj
     }
 
     #[inline]
@@ -54,9 +51,7 @@ impl TCFType<CFBooleanRef> for CFBoolean {
     }
 
     unsafe fn wrap_under_create_rule(obj: CFBooleanRef) -> CFBoolean {
-        CFBoolean {
-            obj: obj,
-        }
+        CFBoolean(obj)
     }
 
     #[inline]

src/bundle.rs

@@ -21,11 +21,7 @@ struct __CFBundle;
 pub type CFBundleRef = *const __CFBundle;
 
 /// A Bundle type.
-///
-/// FIXME(pcwalton): Should be a newtype struct, but that fails due to a Rust compiler bug.
-pub struct CFBundle {
-    obj: CFBundleRef,
-}
+pub struct CFBundle(CFBundleRef);
 
 impl Drop for CFBundle {
     fn drop(&mut self) {
@@ -38,7 +34,8 @@ impl Drop for CFBundle {
 impl TCFType<CFBundleRef> for CFBundle {
     #[inline]
     fn as_concrete_TypeRef(&self) -> CFBundleRef {
-        self.obj
+        let CFBundle(obj) = *self;
+        obj
     }
 
     #[inline]
@@ -55,9 +52,7 @@ impl TCFType<CFBundleRef> for CFBundle {
     }
 
     unsafe fn wrap_under_create_rule(obj: CFBundleRef) -> CFBundle {
-        CFBundle {
-            obj: obj,
-        }
+        CFBundle(obj)
     }
 
     #[inline]

src/data.rs

@@ -20,11 +20,7 @@ struct __CFData;
 pub type CFDataRef = *const __CFData;
 
 /// A byte buffer.
-///
-/// FIXME(pcwalton): Should be a newtype struct, but that fails due to a Rust compiler bug.
-pub struct CFData {
-    obj: CFDataRef,
-}
+pub struct CFData(CFDataRef);
 
 impl Drop for CFData {
     fn drop(&mut self) {
@@ -37,7 +33,8 @@ impl Drop for CFData {
 impl TCFType<CFDataRef> for CFData {
     #[inline]
     fn as_concrete_TypeRef(&self) -> CFDataRef {
-        self.obj
+        let CFData(obj) = *self;
+        obj
     }
 
     #[inline]
@@ -54,9 +51,7 @@ impl TCFType<CFDataRef> for CFData {
     }
 
     unsafe fn wrap_under_create_rule(obj: CFDataRef) -> CFData {
-        CFData {
-            obj: obj,
-        }
+        CFData(obj)
     }
 
     #[inline]
@@ -82,15 +77,17 @@ impl CFData {
     #[inline]
     pub fn bytes<'a>(&'a self) -> &'a [u8] {
         unsafe {
-            mem::transmute((CFDataGetBytePtr(self.obj), self.len() as usize))
+            mem::transmute(
+                (CFDataGetBytePtr(self.as_concrete_TypeRef()), self.len() as usize)
+            )
         }
     }
 
     /// Returns the length of this byte buffer.
     #[inline]
     pub fn len(&self) -> CFIndex {
         unsafe {
-            CFDataGetLength(self.obj)
+            CFDataGetLength(self.as_concrete_TypeRef())
         }
     }
 }

src/dictionary.rs

@@ -23,7 +23,6 @@ pub type CFDictionaryHashCallBack = *const u8;
 pub type CFDictionaryReleaseCallBack = *const u8;
 pub type CFDictionaryRetainCallBack = *const u8;
 
-#[allow(dead_code)]
 #[repr(C)]
 #[derive(Copy)]
 pub struct CFDictionaryKeyCallBacks {
@@ -35,7 +34,6 @@ pub struct CFDictionaryKeyCallBacks {
     hash: CFDictionaryHashCallBack
 }
 
-#[allow(dead_code)]
 #[repr(C)]
 #[derive(Copy)]
 pub struct CFDictionaryValueCallBacks {
@@ -52,11 +50,7 @@ struct __CFDictionary;
 pub type CFDictionaryRef = *const __CFDictionary;
 
 /// An immutable dictionary of key-value pairs.
-///
-/// FIXME(pcwalton): Should be a newtype struct, but that panics due to a Rust compiler bug.
-pub struct CFDictionary {
-    obj: CFDictionaryRef,
-}
+pub struct CFDictionary(CFDictionaryRef);
 
 impl Drop for CFDictionary {
     fn drop(&mut self) {
@@ -69,7 +63,8 @@ impl Drop for CFDictionary {
 impl TCFType<CFDictionaryRef> for CFDictionary {
     #[inline]
     fn as_concrete_TypeRef(&self) -> CFDictionaryRef {
-        self.obj
+        let CFDictionary(obj) = *self;
+        obj
     }
 
     #[inline]
@@ -86,9 +81,7 @@ impl TCFType<CFDictionaryRef> for CFDictionary {
     }
 
     unsafe fn wrap_under_create_rule(obj: CFDictionaryRef) -> CFDictionary {
-        CFDictionary {
-            obj: obj,
-        }
+        CFDictionary(obj)
     }
 
     #[inline]
@@ -120,7 +113,7 @@ impl CFDictionary {
     #[inline]
     pub fn len(&self) -> usize {
         unsafe {
-            CFDictionaryGetCount(self.obj) as usize
+            CFDictionaryGetCount(self.as_concrete_TypeRef()) as usize
         }
     }
 
@@ -132,15 +125,15 @@ impl CFDictionary {
     #[inline]
     pub fn contains_key(&self, key: *const c_void) -> bool {
         unsafe {
-            CFDictionaryContainsKey(self.obj, key) != 0
+            CFDictionaryContainsKey(self.as_concrete_TypeRef(), key) != 0
         }
     }
 
     #[inline]
     pub fn find(&self, key: *const c_void) -> Option<*const c_void> {
         unsafe {
             let mut value: *const c_void = ptr::null();
-            if CFDictionaryGetValueIfPresent(self.obj, key, &mut value) != 0 {
+            if CFDictionaryGetValueIfPresent(self.as_concrete_TypeRef(), key, &mut value) != 0 {
                 Some(value)
             } else {
                 None

src/number.rs

@@ -45,11 +45,7 @@ struct __CFNumber;
 pub type CFNumberRef = *const __CFNumber;
 
 /// An immutable numeric value.
-///
-/// FIXME(pcwalton): Should be a newtype struct, but that fails due to a Rust compiler bug.
-pub struct CFNumber {
-    obj: CFNumberRef,
-}
+pub struct CFNumber(CFNumberRef);
 
 impl Drop for CFNumber {
     fn drop(&mut self) {
@@ -62,7 +58,8 @@ impl Drop for CFNumber {
 impl TCFType<CFNumberRef> for CFNumber {
     #[inline]
     fn as_concrete_TypeRef(&self) -> CFNumberRef {
-        self.obj
+        let CFNumber(obj) = *self;
+        obj
     }
 
     #[inline]
@@ -79,9 +76,7 @@ impl TCFType<CFNumberRef> for CFNumber {
     }
 
     unsafe fn wrap_under_create_rule(obj: CFNumberRef) -> CFNumber {
-        CFNumber {
-            obj: obj,
-        }
+        CFNumber(obj)
     }
 
     #[inline]
@@ -98,7 +93,8 @@ impl ToPrimitive for CFNumber {
     fn to_i64(&self) -> Option<i64> {
         unsafe {
             let mut value: i64 = 0;
-            let ok = CFNumberGetValue(self.obj, kCFNumberSInt64Type, mem::transmute(&mut value));
+            let obj = self.as_concrete_TypeRef();
+            let ok = CFNumberGetValue(obj, kCFNumberSInt64Type, mem::transmute(&mut value));
             assert!(ok);
             Some(value)
         }
@@ -114,7 +110,8 @@ impl ToPrimitive for CFNumber {
     fn to_f64(&self) -> Option<f64> {
         unsafe {
             let mut value: f64 = 0.0;
-            let ok = CFNumberGetValue(self.obj, kCFNumberFloat64Type, mem::transmute(&mut value));
+            let obj = self.as_concrete_TypeRef();
+            let ok = CFNumberGetValue(obj, kCFNumberFloat64Type, mem::transmute(&mut value));
             assert!(ok);
             Some(value)
         }