Validate memoryview.cast() arguments and export negative strides corr…

…ectly cast() accepted any struct format and any shape element. A zero-size format ('0s') and a 0 in the shape both reached a division by zero; cast() now takes only a native single character format, optionally '@'-prefixed, and shape elements that are ints greater than zero. A view with a negative stride starts at its last item, so the bytes it exported began there and its own offsets walked off the front of them. Such a view now exports the whole underlying buffer with `start` folded into the descriptor's offsets, and zip_eq() hands over a whole run only when both sides are contiguous in the last dimension. Assisted-by: Claude Assisted-by: Codex:GPT-5
youknowone · Aug 16, 2026 · Aug 14, 2026 · Aug 14, 2026 · Aug 14, 2026 · Aug 14, 2026
commit 6e4764653a942732b60c161a905a57145697743f
diff --git a/crates/vm/src/builtins/memory.rs b/crates/vm/src/builtins/memory.rs
@@ -1010,7 +1010,19 @@ impl PyMemoryView {
             let mut dim_descriptor = Vec::with_capacity(shape_ndim);
 
             for x in shape {
-                let x = usize::try_from_borrowed_object(vm, x)?;
+                let x = x
+                    .downcast_ref::<PyInt>()
+                    .ok_or_else(|| {
+                        vm.new_type_error("memoryview.cast(): elements of shape must be integers")
+                    })?
+                    .try_to_primitive::<usize>(vm)
+                    .ok()
+                    .filter(|x| *x > 0)
+                    .ok_or_else(|| {
+                        vm.new_value_error(
+                            "memoryview.cast(): elements of shape must be integers > 0",
+                        )
+                    })?;
 
                 if x > isize::MAX as usize / product_shape {
                     return Err(vm.new_value_error("memoryview.cast(): product(shape) > SSIZE_MAX"));

diff --git a/extra_tests/snippets/builtin_memoryview.py b/extra_tests/snippets/builtin_memoryview.py
@@ -514,3 +514,51 @@ def test_fortran_contiguity():
 
 
 test_fortran_contiguity()
+
+
+def test_cast_arguments():
+    # cast() takes a native single character format, optionally '@'-prefixed;
+    # a zero-size format used to reach a division by zero.
+    assert memoryview(b"abcd").cast("@i").itemsize == 4
+    for fmt in ("0s", "4s", "<i", "", "ss"):
+        assert_raises(ValueError, lambda fmt=fmt: memoryview(b"abcd").cast(fmt))
+
+    # every element of shape is an int > 0; a 0 used to divide by zero while
+    # checking the product against SSIZE_MAX
+    for shape in ([0], [0, 4], [4, 0], [-1, 4], [0, 0]):
+        assert_raises(
+            ValueError, lambda shape=shape: memoryview(b"abcd").cast("B", shape)
+        )
+
+    class Index:
+        def __index__(self):
+            return 4
+
+    for shape in ([2.0, 2], [Index()], ["4"]):
+        assert_raises(
+            TypeError, lambda shape=shape: memoryview(b"abcd").cast("B", shape)
+        )
+
+    assert memoryview(b"abcd").cast("B", [True, 4]).tolist() == [[97, 98, 99, 100]]
+
+
+test_cast_arguments()
+
+
+def test_negative_stride():
+    # A reversed view starts at its last byte, so walking it from there runs
+    # off the front of the exported slice.
+    assert memoryview(b"dcba") == memoryview(b"abcd")[::-1]
+    assert memoryview(b"abcd")[::-1] == memoryview(b"dcba")
+    assert not memoryview(b"abcd") == memoryview(b"abcd")[::-1]
+
+    b = bytearray(b"____")
+    memoryview(b)[0:4] = memoryview(b"abcd")[::-1]
+    assert b == bytearray(b"dcba"), b
+
+    a = array.array("i", [1, 2, 3])
+    assert memoryview(array.array("i", [3, 2, 1])) == memoryview(a)[::-1]
+    assert memoryview(a)[::-1].tolist() == [3, 2, 1]
+
+
+test_negative_stride()