Revert to opaque error type

Author: jakelishman

CHANGELOG.md

@@ -2,6 +2,7 @@
 - v0.28.0
   - Fix mismatched behavior between `PyArrayLike1` and `PyArrayLike2` when used with floats ([#520](https://github.com/PyO3/rust-numpy/pull/520))
   - Add ownership-moving conversions into `PyReadonlyArray` and `PyReadwriteArray` ([#524](https://github.com/PyO3/rust-numpy/pull/524))
+  - Fix UB when calling `PyArray::as_slice` and `as_slice_mut` on misaligned arrays ([#525](https://github.com/PyO3/rust-numpy/pull/525))
 
 - v0.27.1
   - Bump ndarray dependency to v0.17. ([#516](https://github.com/PyO3/rust-numpy/pull/516))

src/array.rs

@@ -749,12 +749,10 @@ pub trait PyArrayMethods<'py, T, D>: PyUntypedArrayMethods<'py> + Sized {
             // We can still produce a slice over zero objects regardless of whether
             // the underlying pointer is aligned or not.
             Ok(&[])
-        } else if !self.is_aligned() {
-            Err(AsSliceError::NotAligned)
-        } else if !self.is_contiguous() {
-            Err(AsSliceError::NotContiguous)
-        } else {
+        } else if self.is_aligned() && self.is_contiguous() {
             Ok(slice::from_raw_parts(self.data(), len))
+        } else {
+            Err(AsSliceError)
         }
     }
 
@@ -778,12 +776,10 @@ pub trait PyArrayMethods<'py, T, D>: PyUntypedArrayMethods<'py> + Sized {
             // We can still produce a slice over zero objects regardless of whether
             // the underlying pointer is aligned or not.
             Ok(&mut [])
-        } else if !self.is_aligned() {
-            Err(AsSliceError::NotAligned)
-        } else if !self.is_contiguous() {
-            Err(AsSliceError::NotContiguous)
-        } else {
+        } else if self.is_aligned() && self.is_contiguous() {
             Ok(slice::from_raw_parts_mut(self.data(), len))
+        } else {
+            Err(AsSliceError)
         }
     }
 

src/error.rs

@@ -142,25 +142,13 @@ impl fmt::Display for FromVecError {
 impl_pyerr!(FromVecError);
 
 /// Represents that the given array is not compatible with viewing as a Rust slice.
-///
-/// If an array fails for more than one reason, it is not guaranteed which variant is returned.
 #[derive(Debug)]
-pub enum AsSliceError {
-    /// The array is not backed by an aligned pointer.
-    NotAligned,
-    /// The array is not contiguous in memory.
-    NotContiguous,
-}
-
+pub struct AsSliceError;
 impl fmt::Display for AsSliceError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::NotAligned => write!(f, "The given array is not aligned"),
-            Self::NotContiguous => write!(f, "The given array is not contiguous"),
-        }
+        write!(f, "The given array is not contiguous or is misaligned.")
     }
 }
-
 impl_pyerr!(AsSliceError);
 
 /// Inidcates why borrowing an array failed.

src/lib.rs

@@ -130,6 +130,11 @@ pub mod prelude {
     pub use crate::untyped_array::PyUntypedArrayMethods;
 }
 
+/// Deprecated type alias to [`AsSliceError`].  The new name is preferred because arrays might also
+/// fail to view as a slice due to misalignment.
+#[deprecated(note = "use AsSliceError instead")]
+pub type NonContiguousError = AsSliceError;
+
 #[cfg(doctest)]
 mod doctest {
     macro_rules! doc_comment {

tests/array.rs

@@ -192,12 +192,28 @@ fn as_slice() {
 
         let not_contiguous = not_contiguous_array(py);
         let err = not_contiguous.readonly().as_slice().unwrap_err();
-        assert_eq!(err.to_string(), "The given array is not contiguous");
+        assert_eq!(
+            err.to_string(),
+            "The given array is not contiguous or is misaligned."
+        );
+        let err = not_contiguous.readwrite().as_slice_mut().unwrap_err();
+        assert_eq!(
+            err.to_string(),
+            "The given array is not contiguous or is misaligned."
+        );
 
         let not_aligned = not_aligned_array(py);
         assert!(!not_aligned.is_aligned());
         let err = not_aligned.readonly().as_slice().unwrap_err();
-        assert_eq!(err.to_string(), "The given array is not aligned");
+        assert_eq!(
+            err.to_string(),
+            "The given array is not contiguous or is misaligned."
+        );
+        let err = not_aligned.readwrite().as_slice_mut().unwrap_err();
+        assert_eq!(
+            err.to_string(),
+            "The given array is not contiguous or is misaligned."
+        );
 
         let misaligned_empty: Bound<'_, PyArray1<u16>> = {
             let arr = not_aligned_array(py);
@@ -214,6 +230,10 @@ fn as_slice() {
             misaligned_empty.readonly().as_slice().unwrap(),
             &[] as &[u16]
         );
+        assert_eq!(
+            misaligned_empty.readwrite().as_slice().unwrap(),
+            &mut [] as &mut [u16]
+        );
     });
 }