It seems we do not need specific Nullable types

According to rust-lang/rust#60300

Author: vincentisambart

src/avfoundation.rs

@@ -42,7 +42,7 @@ extern "C" {
     fn choco_AVFoundation_AVAsynchronousKeyValueLoadingProtocol_instance_statusOfValueForKey_error(
         self_: ptr::objc::RawPtr,
         key: ptr::objc::RawPtr,
-        error: *mut ptr::objc::NullableRawPtr,
+        error: *mut Option<ptr::objc::RawPtr>,
     ) -> AVKeyValueStatus;
 
     fn choco_AVFoundation_AVAsynchronousKeyValueLoadingProtocol_instance_loadValuesAsynchronouslyForKeys_completionHandler(
@@ -58,7 +58,7 @@ pub trait AVAsynchronousKeyValueLoadingProtocol: NSObjectProtocol {
         key: &impl NSStringInterface,
     ) -> Result<AVKeyValueStatus, NSError> {
         let self_raw = self.as_raw_ptr();
-        let mut raw_unowned_error = ptr::objc::NullableRawPtr::default();
+        let mut raw_unowned_error: Option<ptr::objc::RawPtr> = None;
         unsafe {
             let status = choco_AVFoundation_AVAsynchronousKeyValueLoadingProtocol_instance_statusOfValueForKey_error(
                 self_raw,
@@ -97,7 +97,7 @@ extern "C" {
     fn choco_AVFoundation_AVAsset_class() -> ptr::objc::ClassPtr;
     fn choco_AVFoundation_AVAssetInterface_instance_tracks(
         self_: ptr::objc::RawPtr,
-    ) -> ptr::objc::NullableRawPtr;
+    ) -> Option<ptr::objc::RawPtr>;
     fn choco_AVFoundation_AVAssetInterface_instance_playable(self_: ptr::objc::RawPtr) -> BOOL;
 }
 
@@ -169,7 +169,7 @@ extern "C" {
         class: ptr::objc::ClassPtr,
         url: ptr::objc::RawPtr,
         options: ptr::objc::RawPtr,
-    ) -> ptr::objc::NullableRawPtr;
+    ) -> Option<ptr::objc::RawPtr>;
 }
 
 pub trait AVURLAssetInterface: AVAssetInterface {
@@ -356,10 +356,10 @@ extern "C" {
     fn choco_AVFoundation_AVAssetTrack_class() -> ptr::objc::ClassPtr;
     fn choco_AVFoundation_AVAssetTrackInterface_instance_mediaType(
         self_: ptr::objc::RawPtr,
-    ) -> ptr::objc::NullableRawPtr;
+    ) -> Option<ptr::objc::RawPtr>;
     fn choco_AVFoundation_AVAssetTrackInterface_instance_formatDescriptions(
         self_: ptr::objc::RawPtr,
-    ) -> ptr::objc::NullableRawPtr;
+    ) -> Option<ptr::objc::RawPtr>;
 }
 
 pub trait AVAssetTrackInterface: NSObjectInterface
@@ -430,13 +430,13 @@ extern "C" {
     fn choco_AVFoundation_AVAssetReaderInterface_class_newWithAsset_error(
         class: ptr::objc::ClassPtr,
         asset: ptr::objc::RawPtr,
-        error: *mut ptr::objc::NullableRawPtr,
-    ) -> ptr::objc::NullableRawPtr;
+        error: *mut Option<ptr::objc::RawPtr>,
+    ) -> Option<ptr::objc::RawPtr>;
 }
 
 pub trait AVAssetReaderInterface: NSObjectInterface {
     fn new_with_asset(asset: &impl AVAssetInterface) -> Result<Self::Owned, NSError> {
-        let mut raw_unowned_error = ptr::objc::NullableRawPtr::default();
+        let mut raw_unowned_error: Option<ptr::objc::RawPtr> = None;
         let raw_ptr = unsafe {
             choco_AVFoundation_AVAssetReaderInterface_class_newWithAsset_error(
                 Self::class(),
@@ -605,14 +605,14 @@ extern "C" {
     fn choco_AVFoundation_AVPlayerItemInterface_class_newWithURL(
         class: ptr::objc::ClassPtr,
         url: ptr::objc::RawPtr,
-    ) -> ptr::objc::NullableRawPtr;
+    ) -> Option<ptr::objc::RawPtr>;
     fn choco_AVFoundation_AVPlayerItemInterface_class_newWithAsset(
         class: ptr::objc::ClassPtr,
         asset: ptr::objc::RawPtr,
-    ) -> ptr::objc::NullableRawPtr;
+    ) -> Option<ptr::objc::RawPtr>;
     fn choco_AVFoundation_AVPlayerItemInterface_instance_error(
         self_: ptr::objc::RawPtr,
-    ) -> ptr::objc::NullableRawPtr;
+    ) -> Option<ptr::objc::RawPtr>;
 }
 
 pub trait AVPlayerItemInterface: NSObjectInterface
@@ -647,7 +647,6 @@ where
         let self_raw = self.as_raw_ptr();
         unsafe {
             choco_AVFoundation_AVPlayerItemInterface_instance_error(self_raw)
-                .into_opt()
                 .map(|raw| NSError::from_owned_ptr_unchecked(raw.consider_owned()))
         }
     }
@@ -694,20 +693,20 @@ extern "C" {
     fn choco_AVFoundation_AVPlayerInterface_class_newWithURL(
         class: ptr::objc::ClassPtr,
         url: ptr::objc::RawPtr,
-    ) -> ptr::objc::NullableRawPtr;
+    ) -> Option<ptr::objc::RawPtr>;
     fn choco_AVFoundation_AVPlayerInterface_class_newWithPlayerItem(
         class: ptr::objc::ClassPtr,
         item: ptr::objc::RawPtr,
-    ) -> ptr::objc::NullableRawPtr;
+    ) -> Option<ptr::objc::RawPtr>;
     fn choco_AVFoundation_AVPlayerInterface_instance_play(self_: ptr::objc::RawPtr);
     fn choco_AVFoundation_AVPlayerInterface_instance_pause(self_: ptr::objc::RawPtr);
     fn choco_AVFoundation_AVPlayerInterface_instance_rate(self_: ptr::objc::RawPtr) -> f32;
     fn choco_AVFoundation_AVPlayerInterface_instance_currentItem(
         self_: ptr::objc::RawPtr,
-    ) -> ptr::objc::NullableRawPtr;
+    ) -> Option<ptr::objc::RawPtr>;
     fn choco_AVFoundation_AVPlayerInterface_instance_error(
         self_: ptr::objc::RawPtr,
-    ) -> ptr::objc::NullableRawPtr;
+    ) -> Option<ptr::objc::RawPtr>;
 }
 
 pub trait AVPlayerInterface: NSObjectInterface {
@@ -739,7 +738,6 @@ pub trait AVPlayerInterface: NSObjectInterface {
         let self_raw = self.as_raw_ptr();
         unsafe {
             choco_AVFoundation_AVPlayerInterface_instance_error(self_raw)
-                .into_opt()
                 .map(|raw| NSError::from_owned_ptr_unchecked(raw.consider_owned()))
         }
     }
@@ -748,7 +746,6 @@ pub trait AVPlayerInterface: NSObjectInterface {
         let self_raw = self.as_raw_ptr();
         unsafe {
             choco_AVFoundation_AVPlayerInterface_instance_currentItem(self_raw)
-                .into_opt()
                 .map(|raw| AVPlayerItem::from_owned_ptr_unchecked(raw.consider_owned()))
         }
     }
@@ -808,8 +805,8 @@ extern "C" {
     fn choco_AVFoundation_AVAudioPlayerInterface_class_newWithContentsOfURL_error(
         class: ptr::objc::ClassPtr,
         url: ptr::objc::RawPtr,
-        error: *mut ptr::objc::NullableRawPtr,
-    ) -> ptr::objc::NullableRawPtr;
+        error: *mut Option<ptr::objc::RawPtr>,
+    ) -> Option<ptr::objc::RawPtr>;
     fn choco_AVFoundation_AVAudioPlayerInterface_instance_play(self_: ptr::objc::RawPtr) -> BOOL;
     fn choco_AVFoundation_AVAudioPlayerInterface_instance_pause(self_: ptr::objc::RawPtr);
     fn choco_AVFoundation_AVAudioPlayerInterface_instance_stop(self_: ptr::objc::RawPtr);
@@ -818,7 +815,7 @@ extern "C" {
 
 pub trait AVAudioPlayerInterface: NSObjectInterface {
     fn new_with_contents_of_url(url: &impl NSURLInterface) -> Result<Self::Owned, NSError> {
-        let mut raw_unowned_error = ptr::objc::NullableRawPtr::default();
+        let mut raw_unowned_error: Option<ptr::objc::RawPtr> = None;
         let raw_ptr = unsafe {
             choco_AVFoundation_AVAudioPlayerInterface_class_newWithContentsOfURL_error(
                 Self::class(),

src/base/core_foundation.rs

@@ -35,7 +35,7 @@ pub struct CFTypeID(usize);
 #[link(name = "CoreFoundation", kind = "framework")]
 extern "C" {
     fn CFRelease(cf: ptr::cf::RawRef);
-    fn CFRetain(cf: ptr::cf::RawRef) -> ptr::cf::NullableRawRef;
+    fn CFRetain(cf: ptr::cf::RawRef) -> Option<ptr::cf::RawRef>;
     fn CFShow(cf: ptr::cf::RawRef);
     fn CFGetRetainCount(cf: ptr::cf::RawRef) -> CFIndex;
     fn CFHash(cf: ptr::cf::RawRef) -> CFHashCode;

src/base/objc.rs

@@ -25,23 +25,23 @@ extern "C" {
     fn choco_base_NSObjectProtocol_instance_hash(self_: ptr::objc::RawPtr) -> NSUInteger;
     fn choco_base_NSObjectProtocol_instance_isEqual(
         self_: ptr::objc::RawPtr,
-        other: ptr::objc::NullableRawPtr,
+        other: Option<ptr::objc::RawPtr>,
     ) -> BOOL;
     fn choco_base_NSObjectProtocol_instance_isKindOfClass(
         self_: ptr::objc::RawPtr,
         class: ptr::objc::ClassPtr,
     ) -> BOOL;
     fn choco_base_NSObjectProtocol_instance_description(
         self_: ptr::objc::RawPtr,
-    ) -> ptr::objc::NullableRawPtr;
+    ) -> Option<ptr::objc::RawPtr>;
     fn choco_base_NSObjectProtocol_instance_debugDescription(
         self_: ptr::objc::RawPtr,
-    ) -> ptr::objc::NullableRawPtr;
+    ) -> Option<ptr::objc::RawPtr>;
 
     fn choco_base_NSObject_class() -> ptr::objc::ClassPtr;
     fn choco_base_NSObjectInterface_class_new(
         class: ptr::objc::ClassPtr,
-    ) -> ptr::objc::NullableRawPtr;
+    ) -> Option<ptr::objc::RawPtr>;
 }
 
 impl<T> ptr::Retain for T

src/base/ptr.rs

@@ -35,7 +35,7 @@ pub(crate) mod objc {
     #[link(name = "objc", kind = "dylib")]
     extern "C" {
         fn objc_release(value: RawPtr);
-        fn objc_retain(value: RawPtr) -> NullableRawPtr;
+        fn objc_retain(value: RawPtr) -> Option<RawPtr>;
     }
 
     #[repr(C)]
@@ -64,30 +64,6 @@ pub(crate) mod objc {
         }
     }
 
-    // I would like to use Option<RawPtr> instead but I'm not sure
-    // if its memory layout is guaranted to be the same.
-    #[derive(Copy, Clone, Default)]
-    #[repr(transparent)]
-    pub struct NullableRawPtr {
-        ptr: Option<NonNull<OpaqueObject>>,
-    }
-
-    impl NullableRawPtr {
-        pub fn into_opt(self) -> Option<RawPtr> {
-            self.ptr.map(|ptr| RawPtr { ptr })
-        }
-
-        pub fn unwrap(self) -> RawPtr {
-            self.into_opt().expect("expecting a non null pointer")
-        }
-    }
-
-    impl From<RawPtr> for NullableRawPtr {
-        fn from(ptr: RawPtr) -> Self {
-            Self { ptr: Some(ptr.ptr) }
-        }
-    }
-
     pub struct OwnedPtr {
         raw: RawPtr,
     }
@@ -153,35 +129,11 @@ pub(crate) mod objc {
         _private: [u8; 0],
     }
 
-    // I would like to use Option<ClassPtr> instead but I'm not sure
-    // if its memory layout is guaranted to be the same.
-    #[derive(Copy, Clone)]
-    #[repr(transparent)]
-    pub struct NullableClassPtr {
-        ptr: Option<NonNull<OpaqueClass>>,
-    }
-
-    impl NullableClassPtr {
-        pub fn into_opt(self) -> Option<ClassPtr> {
-            self.ptr.map(|ptr| ClassPtr { ptr })
-        }
-
-        pub fn unwrap(self) -> ClassPtr {
-            self.into_opt().expect("expecting a non-null class")
-        }
-    }
-
     #[derive(Copy, Clone)]
     #[repr(transparent)]
     pub struct ClassPtr {
         ptr: NonNull<OpaqueClass>,
     }
-
-    impl From<ClassPtr> for NullableClassPtr {
-        fn from(ptr: ClassPtr) -> Self {
-            Self { ptr: Some(ptr.ptr) }
-        }
-    }
 }
 
 pub(crate) mod cf {
@@ -190,7 +142,7 @@ pub(crate) mod cf {
     #[link(name = "CoreFoundation", kind = "framework")]
     extern "C" {
         fn CFRelease(cf: RawRef);
-        fn CFRetain(cf: RawRef) -> NullableRawRef;
+        fn CFRetain(cf: RawRef) -> Option<RawRef>;
     }
 
     #[repr(C)]
@@ -204,24 +156,6 @@ pub(crate) mod cf {
         pub(super) ptr: NonNull<OpaqueCFType>,
     }
 
-    // I would like to use Option<RawRef> instead but I'm not sure
-    // if its memory layout is guaranted to be the same.
-    #[derive(Copy, Clone)]
-    #[repr(transparent)]
-    pub struct NullableRawRef {
-        ptr: Option<NonNull<OpaqueCFType>>,
-    }
-
-    impl NullableRawRef {
-        fn into_opt(self) -> Option<RawRef> {
-            self.ptr.map(|ptr| RawRef { ptr })
-        }
-
-        pub fn unwrap(self) -> RawRef {
-            self.into_opt().expect("expecting a non-null pointer")
-        }
-    }
-
     pub struct OwnedRef {
         pub(super) raw: RawRef,
     }