Handle misaligned arrays in as_slice

Previously, `as_slice` would only check that arrays are contiguous.
While misaligned non-empty arrays remain problematic across the library
(`get`, for example, would still be invalid), this change begins
handling this situation in a function that already returns `Result`.

As a convenience, the empty slice is returned for zero-length arrays,
regardless of the alignment of the underlying pointer.  Misaligned
zero-length pointers can fairly easily arise from allocator
optimisations. For example, CPython reliably returned an odd-address
pointer in `bytearray()` in (at least) CPython 3.14.0 on Linux x86-64,
which caused empty Numpy arrays passing through Pickle protocol 5 (with
the default handling of its `PickleBuffer`s) to be backed by a
misaligned pointer for multi-byte aligned dtypes.

Author: jakelishman

src/array.rs

@@ -744,8 +744,13 @@ pub trait PyArrayMethods<'py, T, D>: PyUntypedArrayMethods<'py> {
         T: Element,
         D: Dimension,
     {
-        if self.is_contiguous() {
-            Ok(slice::from_raw_parts(self.data(), self.len()))
+        let len = self.len();
+        if len == 0 {
+            // 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() && self.is_contiguous() {
+            Ok(slice::from_raw_parts(self.data(), len))
         } else {
             Err(NotContiguousError)
         }
@@ -766,8 +771,13 @@ pub trait PyArrayMethods<'py, T, D>: PyUntypedArrayMethods<'py> {
         T: Element,
         D: Dimension,
     {
-        if self.is_contiguous() {
-            Ok(slice::from_raw_parts_mut(self.data(), self.len()))
+        let len = self.len();
+        if len == 0 {
+            // 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() && self.is_contiguous() {
+            Ok(slice::from_raw_parts_mut(self.data(), len))
         } else {
             Err(NotContiguousError)
         }

src/untyped_array.rs

@@ -102,6 +102,39 @@ pub trait PyUntypedArrayMethods<'py>: Sealed {
     /// [PyArray_DTYPE]: https://numpy.org/doc/stable/reference/c-api/array.html#c.PyArray_DTYPE
     fn dtype(&self) -> Bound<'py, PyArrayDescr>;
 
+    /// Returns `true` if the internal data of the array is aligned for the dtype.
+    ///
+    /// Note that NumPy considers zero-length data to be aligned regardless of the base pointer,
+    /// which is a weaker condition than Rust's slice guarantees.  [PyArrayMethods::as_slice] will
+    /// safely handle the case of a misaligned zero-length array.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use numpy::{PyArray1, PyUntypedArrayMethods};
+    /// use pyo3::{types::{IntoPyDict, PyAnyMethods}, Python, ffi::c_str};
+    ///
+    /// # fn main() -> pyo3::PyResult<()> {
+    /// Python::attach(|py| {
+    ///     let array = PyArray1::<u16>::zeros(py, 8, false);
+    ///     assert!(array.is_aligned());
+    ///
+    ///     let view = py
+    ///         .eval(
+    ///             c_str!("array.view('u1')[1:-1].view('u2')"),
+    ///             None,
+    ///             Some(&[("array", array)].into_py_dict(py)?),
+    ///         )?
+    ///         .cast_into::<PyArray1<u16>>()?;
+    ///     assert!(!view.is_aligned());
+    /// #   Ok(())
+    /// })
+    /// # }
+    /// ```
+    fn is_aligned(&self) -> bool {
+        unsafe { check_flags(&*self.as_array_ptr(), npyffi::NPY_ARRAY_ALIGNED) }
+    }
+
     /// Returns `true` if the internal data of the array is contiguous,
     /// indepedently of whether C-style/row-major or Fortran-style/column-major.
     ///

tests/array.rs

@@ -32,6 +32,17 @@ fn not_contiguous_array(py: Python<'_>) -> Bound<'_, PyArray1<i32>> {
     .unwrap()
 }
 
+fn not_aligned_array(py: Python<'_>) -> Bound<'_, PyArray1<u16>> {
+    py.eval(
+        c_str!("np.zeros(8, dtype='u2').view('u1')[1:-1].view('u2')"),
+        None,
+        Some(&get_np_locals(py)),
+    )
+    .unwrap()
+    .cast_into()
+    .unwrap()
+}
+
 #[test]
 fn new_c_order() {
     Python::attach(|py| {
@@ -51,6 +62,7 @@ fn new_c_order() {
         assert!(arr.is_contiguous());
         assert!(arr.is_c_contiguous());
         assert!(!arr.is_fortran_contiguous());
+        assert!(arr.is_aligned());
     });
 }
 
@@ -73,6 +85,7 @@ fn new_fortran_order() {
         assert!(arr.is_contiguous());
         assert!(!arr.is_c_contiguous());
         assert!(arr.is_fortran_contiguous());
+        assert!(arr.is_aligned());
     });
 }
 
@@ -180,6 +193,23 @@ 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");
+
+        let not_aligned = not_aligned_array(py);
+        assert!(!not_aligned.is_aligned());
+        assert!(not_aligned.readonly().as_slice().is_err());
+
+        let misaligned_empty: Bound<'_, PyArray1<u16>> = {
+            let arr = not_aligned_array(py);
+            py.eval(
+                c_str!("arr[0:0]"),
+                None,
+                Some(&[("arr", arr)].into_py_dict(py).unwrap()),
+            )
+            .unwrap()
+            .cast_into()
+            .unwrap()
+        };
+        assert_eq!(misaligned_empty.readonly().as_slice().unwrap(), &[] as &[u16]);
     });
 }