youknowone · Oct 10, 2026 · Oct 9, 2026
diff --git a/crates/stdlib/src/array.rs b/crates/stdlib/src/array.rs
@@ -18,8 +18,8 @@ pub mod array {
             atomic_func,
             builtins::{
                 PositionIterInternal, PyByteArray, PyBytes, PyBytesRef, PyDictRef, PyFloat,
-                PyGenericAlias, PyInt, PyList, PyListRef, PyStr, PyStrRef, PyTupleRef, PyType,
-                PyTypeRef, PyUtf8Str, PyUtf8StrRef, builtins_iter, locked_next,
+                PyGenericAlias, PyInt, PyListRef, PyStr, PyStrRef, PyTupleRef, PyType, PyTypeRef,
+                PyUtf8Str, PyUtf8StrRef, builtins_iter, locked_next,
             },
             class_or_notimplemented,
             convert::{ToPyObject, ToPyResult, TryFromBorrowedObject, TryFromObject},
@@ -235,20 +235,29 @@ pub mod array {
                     }
                 }
 
-                fn fromlist(&mut self, list: &Py<PyList>, vm: &VirtualMachine) -> PyResult<()> {
+                // The caller must rule out conversion callbacks before taking locks.
+                fn extend_builtin_list(&mut self, list: &[PyObjectRef], vm: &VirtualMachine) -> PyResult<()> {
                     match self {
                         $(ArrayContentType::$n(v) => {
                             // convert list before modify self
-                            let mut list: Vec<$t> = list
-                                .borrow_vec()
-                                .iter()
-                                .cloned()
+                            let mut items: Vec<$t> = list.iter().cloned()
                                 .map(|value| <$t>::try_into_from_object(vm, value))
                                 .try_collect()?;
-                            v.append(&mut list);
-                            Ok(())
+                            v.append(&mut items);
                         })*
                     }
+                    Ok(())
+                }
+
+                fn resize(&mut self, len: usize, vm: &VirtualMachine) -> PyResult<()> {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            v.try_reserve(len.saturating_sub(v.len()))
+                                .map_err(|_| vm.no_memory_error())?;
+                            v.resize(len, <$t>::default());
+                        })*
+                    }
+                    Ok(())
                 }
 
                 fn get_bytes(&self) -> &[u8] {
@@ -506,12 +515,12 @@ pub mod array {
         (Double, f64, 'd', "d"),
     );
 
-    #[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug)]
+    #[derive(Copy, Clone, Default, Ord, PartialOrd, Eq, PartialEq, Debug)]
     pub struct WideChar(wchar_t);
 
     /// Element type for the 'w' typecode: always a 4-byte unicode code point
     /// (Py_UCS4), unlike 'u' which is platform-dependent `wchar_t`.
-    #[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug)]
+    #[derive(Copy, Clone, Default, Ord, PartialOrd, Eq, PartialEq, Debug)]
     pub struct Ucs4Char(u32);
 
     trait ArrayElement: Sized {
@@ -1186,7 +1195,55 @@ pub mod array {
 
         #[pymethod]
         fn fromlist(zelf: &Py<Self>, list: PyListRef, vm: &VirtualMachine) -> PyResult<()> {
-            zelf.try_resizable(vm)?.fromlist(&list, vm)
+            let n = list.borrow_vec().len();
+            if n == 0 {
+                return Ok(());
+            }
+            {
+                let items = list.borrow_vec();
+                if items.iter().all(|item| {
+                    let class = item.class();
+                    class.is(vm.ctx.types.int_type)
+                        || class.is(vm.ctx.types.float_type)
+                        || class.is(vm.ctx.types.bool_type)
+                        || class.is(vm.ctx.types.str_type)
+                }) {
+                    return zelf.try_resizable(vm)?.extend_builtin_list(&items, vm);
+                }
+            }
+            let (old_size, typecode) = {
+                let mut array = zelf.try_resizable(vm)?;
+                let old_size = array.len();
+                let new_size = old_size
+                    .checked_add(n)
+                    .ok_or_else(|| vm.no_memory_error())?;
+                // Callbacks can observe the new size, so initialize the new elements.
+                array.resize(new_size, vm)?;
+                (old_size, array.typecode())
+            };
+            let result = (|| {
+                for i in 0..n {
+                    let value = list.borrow_vec().get(i).cloned().ok_or_else(|| {
+                        vm.new_runtime_error("list changed size during iteration")
+                    })?;
+                    let index = zelf.read().len() as isize - n as isize + i as isize;
+                    let item = ArrayContentType::item_from_object(typecode, value, vm)?;
+                    // Conversion can resize the array. Check the saved index afterwards;
+                    // a negative index is the conversion-only sentinel used by CPython.
+                    if index >= 0 {
+                        zelf.write().setitem_by_item(index, item, vm)?;
+                    }
+                    if list.borrow_vec().len() != n {
+                        return Err(vm.new_runtime_error("list changed size during iteration"));
+                    }
+                }
+                Ok(())
+            })();
+            if result.is_err() && zelf.read().len() != old_size {
+                // A callback may have exported a buffer, preventing even the rollback.
+                zelf.try_resizable(vm)?.resize(old_size, vm)?;
+            }
+            result
         }
 
         #[pymethod]

diff --git a/extra_tests/snippets/stdlib_array.py b/extra_tests/snippets/stdlib_array.py
@@ -346,3 +346,102 @@ def source():
 test_array_search_sees_appended_items()
 test_array_insert_converts_without_lock()
 test_array_extend_callbacks_and_partial_progress()
+
+
+def test_array_fromlist_callbacks():
+    for code in ("i", "d"):
+        values = array(code, [1])
+        source = []
+
+        class Number:
+            def __index__(self):
+                assert len(values) == 3
+                values[0] = 9
+                source[1] = 8
+                return 7
+
+            def __float__(self):
+                return float(self.__index__())
+
+        source[:] = [Number(), 2]
+        values.fromlist(source)
+        assert list(values) == [9, 7, 8]
+
+    values = array("i", [1])
+
+    class Append:
+        def __index__(self):
+            values.append(9)
+            return 7
+
+    values.fromlist([Append()])
+    assert list(values) == [1, 7, 9]
+
+
+def test_array_fromlist_rollback():
+    for mutate in (lambda source: source.clear(), lambda source: source.append(3)):
+        values = array("i", [1])
+
+        class ChangeList:
+            def __index__(self):
+                values[0] = 9
+                mutate(source)
+                return 7
+
+        source = [ChangeList(), 2]
+        with assert_raises(RuntimeError):
+            values.fromlist(source)
+        assert list(values) == [9]
+
+    values = array("i", [1])
+
+    class Fail:
+        def __index__(self):
+            assert values[1] == 2
+            raise ValueError("conversion failed")
+
+    with assert_raises(ValueError):
+        values.fromlist([2, Fail()])
+    assert list(values) == [1]
+
+    class Clear:
+        def __index__(self):
+            values.clear()
+            return 7
+
+    with assert_raises(IndexError):
+        values.fromlist([Clear()])
+    assert len(values) == 1
+
+
+def test_array_fromlist_exports():
+    values = array("i", [1])
+    with memoryview(values):
+        values.fromlist([])
+        with assert_raises(BufferError):
+            values.fromlist([2])
+
+    views = []
+
+    class Export:
+        def __index__(self):
+            views.append(memoryview(values))
+            return 7
+
+    values.fromlist([Export()])
+    assert list(views.pop()) == [1, 7]
+
+    class ExportAndFail:
+        def __index__(self):
+            views.append(memoryview(values))
+            raise ValueError("conversion failed")
+
+    with assert_raises(BufferError):
+        values.fromlist([ExportAndFail()])
+    assert len(values) == len(views[0]) == 3
+    views.pop().release()
+
+
+test_array_fromlist_callbacks()
+test_array_fromlist_rollback()
+test_array_fromlist_exports()