FIX: Use NonNull internal constructors for Raw/ArrayView/Mut

This saves som unwrapping/rewrapping in NonNull, by simpliy copying
`self.ptr` along.

This requires *some* scrutiny, because when we remove calls to
.as_ptr_mut(), we also remove the check for breaking sharing in copy on
write arrays (Cow and Arc). However all instances of this, in this
commit, should already be from uniquely owned arrays or are covered by
`ensure_unique` already (view_mut).

For the array views, the old new_ constructor also remains for use in
all places we make array views directly from raw pointers.

Author: bluss

src/impl_methods.rs

@@ -139,7 +139,7 @@ where
         S: Data,
     {
         debug_assert!(self.pointer_is_inbounds());
-        unsafe { ArrayView::new_(self.ptr.as_ptr(), self.dim.clone(), self.strides.clone()) }
+        unsafe { ArrayView::new(self.ptr, self.dim.clone(), self.strides.clone()) }
     }
 
     /// Return a read-write view of the array
@@ -148,7 +148,7 @@ where
         S: DataMut,
     {
         self.ensure_unique();
-        unsafe { ArrayViewMut::new_(self.ptr.as_ptr(), self.dim.clone(), self.strides.clone()) }
+        unsafe { ArrayViewMut::new(self.ptr, self.dim.clone(), self.strides.clone()) }
     }
 
     /// Return an uniquely owned copy of the array.
@@ -1313,7 +1313,7 @@ where
     /// Return a raw view of the array.
     #[inline]
     pub fn raw_view(&self) -> RawArrayView<A, D> {
-        unsafe { RawArrayView::new_(self.ptr.as_ptr(), self.dim.clone(), self.strides.clone()) }
+        unsafe { RawArrayView::new(self.ptr, self.dim.clone(), self.strides.clone()) }
     }
 
     /// Return a raw mutable view of the array.
@@ -1323,7 +1323,7 @@ where
         S: RawDataMut,
     {
         self.try_ensure_unique(); // for RcArray
-        unsafe { RawArrayViewMut::new_(self.ptr.as_ptr(), self.dim.clone(), self.strides.clone()) }
+        unsafe { RawArrayViewMut::new(self.ptr, self.dim.clone(), self.strides.clone()) }
     }
 
     /// Return the array’s data as a slice, if it is contiguous and in standard order.
@@ -1620,7 +1620,7 @@ where
             Some(st) => st,
             None => return None,
         };
-        unsafe { Some(ArrayView::new_(self.ptr.as_ptr(), dim, broadcast_strides)) }
+        unsafe { Some(ArrayView::new(self.ptr, dim, broadcast_strides)) }
     }
 
     /// Swap axes `ax` and `bx`.

src/impl_raw_views.rs

@@ -1,3 +1,5 @@
+use std::ptr::NonNull;
+
 use crate::dimension::{self, stride_offset};
 use crate::extension::nonnull::nonnull_debug_checked_from_ptr;
 use crate::imp_prelude::*;
@@ -11,16 +13,20 @@ where
     ///
     /// Unsafe because caller is responsible for ensuring that the array will
     /// meet all of the invariants of the `ArrayBase` type.
-    #[inline(always)]
-    pub(crate) unsafe fn new_(ptr: *const A, dim: D, strides: D) -> Self {
+    #[inline]
+    pub(crate) unsafe fn new(ptr: NonNull<A>, dim: D, strides: D) -> Self {
         RawArrayView {
             data: RawViewRepr::new(),
-            ptr: nonnull_debug_checked_from_ptr(ptr as *mut _),
+            ptr,
             dim,
             strides,
         }
     }
 
+    unsafe fn new_(ptr: *const A, dim: D, strides: D) -> Self {
+        Self::new(nonnull_debug_checked_from_ptr(ptr as *mut A), dim, strides)
+    }
+
     /// Create an `RawArrayView<A, D>` from shape information and a raw pointer
     /// to the elements.
     ///
@@ -76,7 +82,7 @@ where
     /// ensure that all of the data is valid and choose the correct lifetime.
     #[inline]
     pub unsafe fn deref_into_view<'a>(self) -> ArrayView<'a, A, D> {
-        ArrayView::new_(self.ptr.as_ptr(), self.dim, self.strides)
+        ArrayView::new(self.ptr, self.dim, self.strides)
     }
 
     /// Split the array view along `axis` and return one array pointer strictly
@@ -115,16 +121,20 @@ where
     ///
     /// Unsafe because caller is responsible for ensuring that the array will
     /// meet all of the invariants of the `ArrayBase` type.
-    #[inline(always)]
-    pub(crate) unsafe fn new_(ptr: *mut A, dim: D, strides: D) -> Self {
+    #[inline]
+    pub(crate) unsafe fn new(ptr: NonNull<A>, dim: D, strides: D) -> Self {
         RawArrayViewMut {
             data: RawViewRepr::new(),
-            ptr: nonnull_debug_checked_from_ptr(ptr),
+            ptr,
             dim,
             strides,
         }
     }
 
+    unsafe fn new_(ptr: *mut A, dim: D, strides: D) -> Self {
+        Self::new(nonnull_debug_checked_from_ptr(ptr), dim, strides)
+    }
+
     /// Create an `RawArrayViewMut<A, D>` from shape information and a raw
     /// pointer to the elements.
     ///
@@ -176,7 +186,7 @@ where
     /// Converts to a non-mutable `RawArrayView`.
     #[inline]
     pub(crate) fn into_raw_view(self) -> RawArrayView<A, D> {
-        unsafe { RawArrayView::new_(self.ptr.as_ptr(), self.dim, self.strides) }
+        unsafe { RawArrayView::new(self.ptr, self.dim, self.strides) }
     }
 
     /// Converts to a read-only view of the array.
@@ -186,7 +196,7 @@ where
     /// ensure that all of the data is valid and choose the correct lifetime.
     #[inline]
     pub unsafe fn deref_into_view<'a>(self) -> ArrayView<'a, A, D> {
-        ArrayView::new_(self.ptr.as_ptr(), self.dim, self.strides)
+        ArrayView::new(self.ptr, self.dim, self.strides)
     }
 
     /// Converts to a mutable view of the array.
@@ -196,7 +206,7 @@ where
     /// ensure that all of the data is valid and choose the correct lifetime.
     #[inline]
     pub unsafe fn deref_into_view_mut<'a>(self) -> ArrayViewMut<'a, A, D> {
-        ArrayViewMut::new_(self.ptr.as_ptr(), self.dim, self.strides)
+        ArrayViewMut::new(self.ptr, self.dim, self.strides)
     }
 
     /// Split the array view along `axis` and return one array pointer strictly
@@ -207,8 +217,8 @@ where
         let (left, right) = self.into_raw_view().split_at(axis, index);
         unsafe {
             (
-                Self::new_(left.ptr.as_ptr(), left.dim, left.strides),
-                Self::new_(right.ptr.as_ptr(), right.dim, right.strides),
+                Self::new(left.ptr, left.dim, left.strides),
+                Self::new(right.ptr, right.dim, right.strides),
             )
         }
     }

src/impl_views/constructors.rs

@@ -6,6 +6,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use std::ptr::NonNull;
+
 use crate::dimension;
 use crate::error::ShapeError;
 use crate::extension::nonnull::nonnull_debug_checked_from_ptr;
@@ -200,11 +202,11 @@ where
 
     /// Convert the view into an `ArrayViewMut<'b, A, D>` where `'b` is a lifetime
     /// outlived by `'a'`.
-    pub fn reborrow<'b>(mut self) -> ArrayViewMut<'b, A, D>
+    pub fn reborrow<'b>(self) -> ArrayViewMut<'b, A, D>
     where
         'a: 'b,
     {
-        unsafe { ArrayViewMut::new_(self.as_mut_ptr(), self.dim, self.strides) }
+        unsafe { ArrayViewMut::new(self.ptr, self.dim, self.strides) }
     }
 }
 
@@ -217,14 +219,24 @@ where
     ///
     /// Unsafe because: `ptr` must be valid for the given dimension and strides.
     #[inline(always)]
-    pub(crate) unsafe fn new_(ptr: *const A, dim: D, strides: D) -> Self {
+    pub(crate) unsafe fn new(ptr: NonNull<A>, dim: D, strides: D) -> Self {
+        if cfg!(debug_assertions) {
+            assert!(is_aligned(ptr.as_ptr()), "The pointer must be aligned.");
+            dimension::max_abs_offset_check_overflow::<A, _>(&dim, &strides).unwrap();
+        }
         ArrayView {
             data: ViewRepr::new(),
-            ptr: nonnull_debug_checked_from_ptr(ptr as *mut A),
+            ptr,
             dim,
             strides,
         }
     }
+
+    /// Unsafe because: `ptr` must be valid for the given dimension and strides.
+    #[inline]
+    pub(crate) unsafe fn new_(ptr: *const A, dim: D, strides: D) -> Self {
+        Self::new(nonnull_debug_checked_from_ptr(ptr as *mut A), dim, strides)
+    }
 }
 
 impl<'a, A, D> ArrayViewMut<'a, A, D>
@@ -235,17 +247,24 @@ where
     ///
     /// Unsafe because: `ptr` must be valid for the given dimension and strides.
     #[inline(always)]
-    pub(crate) unsafe fn new_(ptr: *mut A, dim: D, strides: D) -> Self {
+    pub(crate) unsafe fn new(ptr: NonNull<A>, dim: D, strides: D) -> Self {
         if cfg!(debug_assertions) {
-            assert!(!ptr.is_null(), "The pointer must be non-null.");
-            assert!(is_aligned(ptr), "The pointer must be aligned.");
+            assert!(is_aligned(ptr.as_ptr()), "The pointer must be aligned.");
             dimension::max_abs_offset_check_overflow::<A, _>(&dim, &strides).unwrap();
         }
         ArrayViewMut {
             data: ViewRepr::new(),
-            ptr: nonnull_debug_checked_from_ptr(ptr),
+            ptr,
             dim,
             strides,
         }
     }
+
+    /// Create a new `ArrayView`
+    ///
+    /// Unsafe because: `ptr` must be valid for the given dimension and strides.
+    #[inline(always)]
+    pub(crate) unsafe fn new_(ptr: *mut A, dim: D, strides: D) -> Self {
+        Self::new(nonnull_debug_checked_from_ptr(ptr), dim, strides)
+    }
 }

src/impl_views/conversions.rs

@@ -26,7 +26,7 @@ where
     where
         'a: 'b,
     {
-        unsafe { ArrayView::new_(self.as_ptr(), self.dim, self.strides) }
+        unsafe { ArrayView::new(self.ptr, self.dim, self.strides) }
     }
 
     /// Return the array’s data as a slice, if it is contiguous and in standard order.
@@ -53,7 +53,7 @@ where
 
     /// Converts to a raw array view.
     pub(crate) fn into_raw_view(self) -> RawArrayView<A, D> {
-        unsafe { RawArrayView::new_(self.ptr.as_ptr(), self.dim, self.strides) }
+        unsafe { RawArrayView::new(self.ptr, self.dim, self.strides) }
     }
 }
 
@@ -161,12 +161,12 @@ where
 {
     // Convert into a read-only view
     pub(crate) fn into_view(self) -> ArrayView<'a, A, D> {
-        unsafe { ArrayView::new_(self.ptr.as_ptr(), self.dim, self.strides) }
+        unsafe { ArrayView::new(self.ptr, self.dim, self.strides) }
     }
 
     /// Converts to a mutable raw array view.
     pub(crate) fn into_raw_view_mut(self) -> RawArrayViewMut<A, D> {
-        unsafe { RawArrayViewMut::new_(self.ptr.as_ptr(), self.dim, self.strides) }
+        unsafe { RawArrayViewMut::new(self.ptr, self.dim, self.strides) }
     }
 
     #[inline]

src/lib.rs

@@ -1517,7 +1517,7 @@ where
         let ptr = self.ptr;
         let mut strides = dim.clone();
         strides.slice_mut().copy_from_slice(self.strides.slice());
-        unsafe { ArrayView::new_(ptr.as_ptr(), dim, strides) }
+        unsafe { ArrayView::new(ptr, dim, strides) }
     }
 
     fn raw_strides(&self) -> D {

src/zip/mod.rs

@@ -73,7 +73,7 @@ where
     type Output = ArrayView<'a, A, E::Dim>;
     fn broadcast_unwrap(self, shape: E) -> Self::Output {
         let res: ArrayView<'_, A, E::Dim> = (&self).broadcast_unwrap(shape.into_dimension());
-        unsafe { ArrayView::new_(res.ptr.as_ptr(), res.dim, res.strides) }
+        unsafe { ArrayView::new(res.ptr, res.dim, res.strides) }
     }
     private_impl! {}
 }