Merge pull request RustPython#3772 from falsetru/fix-index-check

Saturate list index on usize.

Author: youknowone

Lib/test/list_tests.py

@@ -363,8 +363,6 @@ def __eq__(self, other):
             # verify that original order and values are retained.
             self.assertIs(x, y)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_index(self):
         super().test_index()
         a = self.type2test([-2, -1, 0, 0, 1, 2])

vm/src/builtins/list.rs

@@ -1,4 +1,4 @@
-use super::{PositionIterInternal, PyGenericAlias, PyTupleRef, PyType, PyTypeRef};
+use super::{PositionIterInternal, PyGenericAlias, PyIntRef, PyTupleRef, PyType, PyTypeRef};
 use crate::common::lock::{
     PyMappedRwLockReadGuard, PyMutex, PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard,
 };
@@ -10,7 +10,7 @@ use crate::{
     protocol::{PyIterReturn, PyMappingMethods, PySequence, PySequenceMethods},
     recursion::ReprGuard,
     sequence::{MutObjectSequenceOp, SequenceExt, SequenceMutExt},
-    sliceable::{saturate_index, SequenceIndex, SliceableSequenceMutOp, SliceableSequenceOp},
+    sliceable::{pyint_saturate_index, SequenceIndex, SliceableSequenceMutOp, SliceableSequenceOp},
     types::{
         AsMapping, AsSequence, Comparable, Constructor, Hashable, Initializer, IterNext,
         IterNextIterable, Iterable, PyComparisonOp, Unconstructible, Unhashable,
@@ -271,15 +271,17 @@ impl PyList {
     fn index(
         &self,
         needle: PyObjectRef,
-        start: OptionalArg<isize>,
-        stop: OptionalArg<isize>,
+        start: OptionalArg<PyObjectRef>,
+        stop: OptionalArg<PyObjectRef>,
         vm: &VirtualMachine,
     ) -> PyResult<usize> {
         let len = self.len();
-        let start = start.map(|i| saturate_index(i, len)).unwrap_or(0);
-        let stop = stop
-            .map(|i| saturate_index(i, len))
-            .unwrap_or(isize::MAX as usize);
+        let saturate = |obj: PyObjectRef, len| -> PyResult<_> {
+            obj.try_into_value(vm)
+                .map(|int: PyIntRef| pyint_saturate_index(int, len))
+        };
+        let start = start.map_or(Ok(0), |obj| saturate(obj, len))?;
+        let stop = stop.map_or(Ok(len), |obj| saturate(obj, len))?;
         let index = self.mut_index_range(vm, &needle, start..stop)?;
         if let Some(index) = index.into() {
             Ok(index)

vm/src/sliceable.rs

@@ -1,6 +1,6 @@
 // export through slicable module, not slice.
 use crate::{
-    builtins::{int::PyInt, slice::PySlice},
+    builtins::{int::PyInt, slice::PySlice, PyIntRef},
     AsObject, PyObject, PyResult, VirtualMachine,
 };
 use num_traits::{Signed, ToPrimitive};
@@ -320,6 +320,19 @@ pub fn saturate_index(p: isize, len: usize) -> usize {
     p as usize
 }
 
+// Saturate p in range [0, len] inclusive
+pub fn pyint_saturate_index(p: PyIntRef, len: usize) -> usize {
+    let bigint = p.as_bigint();
+    if bigint.is_negative() {
+        bigint
+            .abs()
+            .try_into()
+            .map_or(0, |abs| len.saturating_sub(abs))
+    } else {
+        bigint.try_into().unwrap_or(len)
+    }
+}
+
 /// A saturated slice with values ranging in [isize::MIN, isize::MAX]. Used for
 /// slicable sequences that require indices in the aforementioned range.
 ///