RustPython
diff --git a/‎vm/src/builtins/int.rs‎
Lines changed: 1 addition & 7 deletions b/‎vm/src/builtins/int.rs‎
Lines changed: 1 addition & 7 deletions
diff --git a/‎vm/src/builtins/slice.rs‎
Lines changed: 1 addition & 1 deletion b/‎vm/src/builtins/slice.rs‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎vm/src/bytesinner.rs‎
Lines changed: 1 addition & 9 deletions b/‎vm/src/bytesinner.rs‎
Lines changed: 1 addition & 9 deletions
diff --git a/‎vm/src/stdlib/math.rs‎
Lines changed: 2 additions & 9 deletions b/‎vm/src/stdlib/math.rs‎
Lines changed: 2 additions & 9 deletions
diff --git a/‎vm/src/stdlib/pystruct.rs‎
Lines changed: 1 addition & 1 deletion b/‎vm/src/stdlib/pystruct.rs‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎vm/src/vm.rs‎
Lines changed: 19 additions & 18 deletions b/‎vm/src/vm.rs‎
Lines changed: 19 additions & 18 deletions
@@ -253,13 +253,7 @@ impl PyInt {
         let value = if let OptionalArg::Present(val) = options.val_options {
             if let OptionalArg::Present(base) = options.base {
                 let base = vm
-                    .to_index(&base)
-                    .unwrap_or_else(|| {
-                        Err(vm.new_type_error(format!(
-                            "'{}' object cannot be interpreted as an integer",
-                            base.class().name
-                        )))
-                    })?
+                    .to_index(&base)?
                     .borrow_value()
                     .to_u32()
                     .filter(|&v| v == 0 || (2..=36).contains(&v))
 
@@ -274,7 +274,7 @@ fn to_index_value(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<Option<Big
         return Ok(None);
     }
 
-    let result = vm.to_index(obj).unwrap_or_else(|| {
+    let result = vm.to_index_opt(obj.clone()).unwrap_or_else(|| {
         Err(vm.new_type_error(
             "slice indices must be integers or None or have an __index__ method".to_owned(),
         ))
 
@@ -1189,15 +1189,7 @@ pub fn bytes_from_object(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<Vec
 }
 
 pub fn value_from_object(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<u8> {
-    let value = vm.to_index(obj).ok_or_else(|| {
-        vm.new_type_error(format!(
-            "'{}' object cannot be interpreted as an integer",
-            obj.class().name
-        ))
-    })?;
-    // __index__ returned non-int type
-    let value = value?;
-    value
+    vm.to_index(obj)?
         .borrow_value()
         .to_u8()
         .ok_or_else(|| vm.new_value_error("byte must be in range(0, 256)".to_owned()))
 
@@ -131,15 +131,8 @@ fn math_sqrt(value: IntoPyFloat, vm: &VirtualMachine) -> PyResult<f64> {
 }
 
 fn math_isqrt(x: PyObjectRef, vm: &VirtualMachine) -> PyResult<BigInt> {
-    let index = vm.to_index(&x).ok_or_else(|| {
-        vm.new_type_error(format!(
-            "'{}' object cannot be interpreted as an integer",
-            x.class().name
-        ))
-    })?;
-    // __index__ may have returned non-int type
-    let python_value = index?;
-    let value = python_value.borrow_value();
+    let index = vm.to_index(&x)?;
+    let value = index.borrow_value();
 
     if value.is_negative() {
         return Err(vm.new_value_error("isqrt() argument must be nonnegative".to_owned()));
 
@@ -444,7 +444,7 @@ pub(crate) mod _struct {
     where
         T: num_traits::PrimInt + for<'a> std::convert::TryFrom<&'a BigInt>,
     {
-        match vm.to_index(&arg) {
+        match vm.to_index_opt(arg.clone()) {
             Some(index) => try_to_primitive(index?.borrow_value(), vm),
             None => Err(new_struct_error(
                 vm,
 
@@ -783,25 +783,26 @@ impl VirtualMachine {
         TryFromObject::try_from_object(self, repr)
     }
 
-    pub fn to_index(&self, obj: &PyObjectRef) -> Option<PyResult<PyIntRef>> {
-        Some(
-            if let Ok(val) = TryFromObject::try_from_object(self, obj.clone()) {
-                Ok(val)
-            } else if obj.class().has_attr("__index__") {
-                self.call_method(obj, "__index__", ()).and_then(|r| {
-                    if let Ok(val) = TryFromObject::try_from_object(self, r) {
-                        Ok(val)
-                    } else {
-                        Err(self.new_type_error(format!(
-                            "__index__ returned non-int (type {})",
-                            obj.class().name
-                        )))
-                    }
+    pub fn to_index_opt(&self, obj: PyObjectRef) -> Option<PyResult<PyIntRef>> {
+        match obj.downcast() {
+            Ok(val) => Some(Ok(val)),
+            Err(obj) => self.get_method(obj, "__index__").map(|index| {
+                self.invoke(&index?, ())?.downcast().map_err(|bad| {
+                    self.new_type_error(format!(
+                        "__index__ returned non-int (type {})",
+                        bad.class().name
+                    ))
                 })
-            } else {
-                return None;
-            },
-        )
+            }),
+        }
+    }
+    pub fn to_index(&self, obj: &PyObjectRef) -> PyResult<PyIntRef> {
+        self.to_index_opt(obj.clone()).unwrap_or_else(|| {
+            Err(self.new_type_error(format!(
+                "'{}' object cannot be interpreted as an integer",
+                obj.class().name
+            )))
+        })
     }
 
     pub fn import(&self, module: &str, from_list: &[String], level: usize) -> PyResult {
Original file line number	Diff line number	Diff line change
`@@ -274,7 +274,7 @@ fn to_index_value(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<Option<Big`
`274`	`274`	`return Ok(None);`
`275`	`275`	`}`
`276`	`276`
`277`		`- let result = vm.to_index(obj).unwrap_or_else(\|\| {`
	`277`	`+ let result = vm.to_index_opt(obj.clone()).unwrap_or_else(\|\| {`
`278`	`278`	`Err(vm.new_type_error(`
`279`	`279`	`"slice indices must be integers or None or have an __index__ method".to_owned(),`
`280`	`280`	`))`
Original file line number	Diff line number	Diff line change
`@@ -444,7 +444,7 @@ pub(crate) mod _struct {`
`444`	`444`	`where`
`445`	`445`	`T: num_traits::PrimInt + for<'a> std::convert::TryFrom<&'a BigInt>,`
`446`	`446`	`{`
`447`		`- match vm.to_index(&arg) {`
	`447`	`+ match vm.to_index_opt(arg.clone()) {`
`448`	`448`	`Some(index) => try_to_primitive(index?.borrow_value(), vm),`
`449`	`449`	`None => Err(new_struct_error(`
`450`	`450`	`vm,`