Move BorrowDatum interfaces to ptr::NonNull

Author: workingjubilee

pgrx/src/array.rs

@@ -77,7 +77,7 @@ where
         let nulls =
             raw.nulls_bitptr().map(|p| unsafe { bitslice::from_raw_parts(p, nelems).unwrap() });
 
-        let data = raw.data_ptr();
+        let data = unsafe { NonNull::new_unchecked(raw.data_ptr().cast_mut()) };
         let arr = self;
         let index = 0;
         let offset = 0;
@@ -164,10 +164,13 @@ trait BuiltinRepr {
 
 unsafe impl<T: ?Sized> BorrowDatum for FlatArray<'_, T> {
     const PASS: layout::PassBy = layout::PassBy::Ref;
-    unsafe fn point_from(ptr: *mut u8) -> *mut Self {
+    unsafe fn point_from(ptr: ptr::NonNull<u8>) -> ptr::NonNull<Self> {
         unsafe {
-            let len = varlena::varsize_any(ptr.cast()) - mem::size_of::<pg_sys::ArrayType>();
-            ptr::slice_from_raw_parts_mut(ptr, len) as *mut Self
+            let len =
+                varlena::varsize_any(ptr.as_ptr().cast()) - mem::size_of::<pg_sys::ArrayType>();
+            ptr::NonNull::new_unchecked(
+                ptr::slice_from_raw_parts_mut(ptr.as_ptr(), len) as *mut Self
+            )
         }
     }
 }
@@ -217,7 +220,7 @@ where
     T: ?Sized + BorrowDatum,
 {
     arr: &'arr FlatArray<'arr, T>,
-    data: *const u8,
+    data: ptr::NonNull<u8>,
     nulls: Option<&'arr BitSlice<u8>>,
     nelems: usize,
     index: usize,

pgrx/src/callconv.rs

@@ -277,18 +277,20 @@ where
             PassBy::Ref => arg.2.value.cast_mut_ptr(),
             PassBy::Value => ptr::addr_of!(arg.0.raw_args()[arg.1].value).cast_mut().cast(),
         };
-        unsafe { T::borrow_unchecked(ptr) }
+        unsafe {
+            let ptr = ptr::NonNull::new_unchecked(ptr);
+            T::borrow_unchecked(ptr)
+        }
     }
 
     unsafe fn unbox_nullable_arg(arg: Arg<'_, 'fcx>) -> Nullable<Self> {
-        let ptr: *mut u8 = match T::PASS {
+        let ptr: Option<ptr::NonNull<u8>> = NonNull::new(match T::PASS {
             PassBy::Ref => arg.2.value.cast_mut_ptr(),
             PassBy::Value => ptr::addr_of!(arg.0.raw_args()[arg.1].value).cast_mut().cast(),
-        };
-        if arg.is_null() || ptr.is_null() {
-            Nullable::Null
-        } else {
-            unsafe { Nullable::Valid(T::borrow_unchecked(ptr)) }
+        });
+        match (arg.is_null(), ptr) {
+            (true, _) | (false, None) => Nullable::Null,
+            (false, Some(ptr)) => unsafe { Nullable::Valid(T::borrow_unchecked(ptr)) },
         }
     }
 }

pgrx/src/datum/borrow.rs

@@ -41,7 +41,7 @@ pub unsafe trait BorrowDatum {
     ///
     /// Do not attempt to handle pass-by-value versus pass-by-ref in this fn's body!
     /// A caller may be in a context where all types are handled by-reference, for instance.
-    unsafe fn point_from(ptr: *mut u8) -> *mut Self;
+    unsafe fn point_from(ptr: ptr::NonNull<u8>) -> ptr::NonNull<Self>;
 
     /// Cast a pointer to aligned varlena headers to this type
     ///
@@ -52,14 +52,14 @@ pub unsafe trait BorrowDatum {
     /// # Safety
     /// - This must be correctly invoked for the pointee type, as it may deref.
     /// - This must be 4-byte aligned!
-    unsafe fn point_from_align4(ptr: *mut u32) -> *mut Self {
+    unsafe fn point_from_align4(ptr: ptr::NonNull<u32>) -> ptr::NonNull<Self> {
         debug_assert!(ptr.is_aligned());
         unsafe { <Self as BorrowDatum>::point_from(ptr.cast()) }
     }
 
     /// Optimization for borrowing the referent
-    unsafe fn borrow_unchecked<'dat>(ptr: *const u8) -> &'dat Self {
-        unsafe { &*Self::point_from(ptr.cast_mut()) }
+    unsafe fn borrow_unchecked<'dat>(ptr: ptr::NonNull<u8>) -> &'dat Self {
+        unsafe { Self::point_from(ptr).as_ref() }
     }
 }
 
@@ -73,7 +73,7 @@ macro_rules! borrow_by_value {
                     PassBy::Ref
                 };
 
-                unsafe fn point_from(ptr: *mut u8) -> *mut Self {
+                unsafe fn point_from(ptr: ptr::NonNull<u8>) -> ptr::NonNull<Self> {
                     ptr.cast()
                 }
             }
@@ -89,14 +89,16 @@ borrow_by_value! {
 unsafe impl BorrowDatum for ffi::CStr {
     const PASS: PassBy = PassBy::Ref;
 
-    unsafe fn point_from(ptr: *mut u8) -> *mut Self {
-        let char_ptr: *mut ffi::c_char = ptr.cast();
-        let len = unsafe { ffi::CStr::from_ptr(char_ptr).to_bytes_with_nul().len() };
-        ptr::slice_from_raw_parts_mut(char_ptr, len) as *mut Self
+    unsafe fn point_from(ptr: ptr::NonNull<u8>) -> ptr::NonNull<Self> {
+        let char_ptr: *mut ffi::c_char = ptr.as_ptr().cast();
+        unsafe {
+            let len = ffi::CStr::from_ptr(char_ptr).to_bytes_with_nul().len();
+            ptr::NonNull::new_unchecked(ptr::slice_from_raw_parts_mut(char_ptr, len) as *mut Self)
+        }
     }
 
-    unsafe fn borrow_unchecked<'dat>(ptr: *const u8) -> &'dat Self {
-        let char_ptr: *const ffi::c_char = ptr.cast();
+    unsafe fn borrow_unchecked<'dat>(ptr: ptr::NonNull<u8>) -> &'dat Self {
+        let char_ptr: *const ffi::c_char = ptr.as_ptr().cast();
         unsafe { ffi::CStr::from_ptr(char_ptr) }
     }
 }

pgrx/src/text.rs

@@ -115,10 +115,12 @@ impl Text {
 
 unsafe impl BorrowDatum for Text {
     const PASS: PassBy = PassBy::Ref;
-    unsafe fn point_from(ptr: *mut u8) -> *mut Self {
+    unsafe fn point_from(ptr: ptr::NonNull<u8>) -> ptr::NonNull<Self> {
         unsafe {
-            let len = varlena::varsize_any(ptr.cast());
-            ptr::slice_from_raw_parts_mut(ptr, len) as *mut Text
+            let len = varlena::varsize_any(ptr.as_ptr().cast());
+            ptr::NonNull::new_unchecked(
+                ptr::slice_from_raw_parts_mut(ptr.as_ptr(), len) as *mut Text
+            )
         }
     }
 }