deprecated warnings for int

Author: qingshi163

Lib/test/test_int.py

@@ -458,8 +458,6 @@ def __int__(self):
         self.assertEqual(my_int, 7)
         self.assertRaises(TypeError, int, my_int)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_int_returns_int_subclass(self):
         class BadIndex:
             def __index__(self):

vm/src/protocol/number.rs

@@ -4,6 +4,7 @@ use crate::{
     builtins::{int, PyByteArray, PyBytes, PyComplex, PyFloat, PyInt, PyIntRef, PyStr},
     common::lock::OnceCell,
     function::ArgBytesLike,
+    stdlib::warnings,
     AsObject, PyObject, PyPayload, PyRef, PyResult, TryFromBorrowedObject, VirtualMachine,
 };
 
@@ -119,15 +120,34 @@ impl PyNumber<'_> {
         }
 
         if self.obj.class().is(PyInt::class(vm)) {
-            Ok(unsafe { self.obj.downcast_unchecked_ref::<PyInt>() }.to_owned())
+            Ok(unsafe { self.obj.to_owned().downcast_unchecked::<PyInt>() })
         } else if let Some(f) = self.methods(vm).int {
-            f(self, vm)
-        } else if let Some(f) = self.methods(vm).index {
-            f(self, vm)
+            let ret = f(self, vm)?;
+            if !ret.class().is(PyInt::class(vm)) {
+                warnings::warn(
+                    vm.ctx.exceptions.deprecation_warning.clone(),
+                    format!("__int__ returned non-int (type {})", ret.class()),
+                    1,
+                    vm,
+                )?
+            }
+            Ok(ret)
+        } else if self.methods(vm).index.is_some() {
+            self.index(vm)
         } else if let Ok(Ok(f)) = vm.get_special_method(self.obj.to_owned(), "__trunc__") {
-            let r = f.invoke((), vm)?;
-            PyNumber::from(r.as_ref()).index(vm).map_err(|_| {
-                vm.new_type_error("__trunc__ returned non-Integral (type NonIntegral)".to_string())
+            // TODO: Deprecate in 3.11
+            // warnings::warn(
+            //     vm.ctx.exceptions.deprecation_warning.clone(),
+            //     "The delegation of int() to __trunc__ is deprecated.".to_owned(),
+            //     1,
+            //     vm,
+            // )?;
+            let ret = f.invoke((), vm)?;
+            PyNumber::from(ret.as_ref()).index(vm).map_err(|_| {
+                vm.new_type_error(format!(
+                    "__trunc__ returned non-Integral (type {})",
+                    ret.class()
+                ))
             })
         } else if let Some(s) = self.obj.payload::<PyStr>() {
             try_convert(self.obj, s.as_str().as_bytes(), vm)
@@ -148,9 +168,18 @@ impl PyNumber<'_> {
 
     pub fn index(&self, vm: &VirtualMachine) -> PyResult<PyIntRef> {
         if self.obj.class().is(PyInt::class(vm)) {
-            Ok(unsafe { self.obj.downcast_unchecked_ref::<PyInt>() }.to_owned())
+            Ok(unsafe { self.obj.to_owned().downcast_unchecked::<PyInt>() })
         } else if let Some(f) = self.methods(vm).index {
-            f(self, vm)
+            let ret = f(self, vm)?;
+            if !ret.class().is(PyInt::class(vm)) {
+                warnings::warn(
+                    vm.ctx.exceptions.deprecation_warning.clone(),
+                    format!("__index__ returned non-int (type {})", ret.class()),
+                    1,
+                    vm,
+                )?
+            }
+            Ok(ret)
         } else {
             Err(vm.new_type_error(format!(
                 "'{}' object cannot be interpreted as an integer",

vm/src/stdlib/mod.rs

@@ -21,7 +21,7 @@ mod sysconfigdata;
 #[cfg(feature = "threading")]
 mod thread;
 pub mod time;
-mod warnings;
+pub mod warnings;
 mod weakref;
 
 #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]

vm/src/stdlib/warnings.rs

@@ -1,5 +1,25 @@
 pub(crate) use _warnings::make_module;
 
+use crate::{builtins::PyTypeRef, PyResult, VirtualMachine};
+
+pub fn warn(
+    category: PyTypeRef,
+    message: String,
+    stack_level: usize,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    // let module = vm.import("warnings", None, 0)?;
+    // let func = module.get_attr("warn", vm)?;
+    // vm.invoke(&func, (message, category, stack_level))?;
+    // TODO
+    if let Ok(module) = vm.import("warnings", None, 0) {
+        if let Ok(func) = module.get_attr("warn", vm) {
+            let _ = vm.invoke(&func, (message, category, stack_level));
+        }
+    }
+    Ok(())
+}
+
 #[pymodule]
 mod _warnings {
     use crate::{

vm/src/types/slot.rs

@@ -344,30 +344,24 @@ fn as_number_wrapper(zelf: &PyObject, _vm: &VirtualMachine) -> Cow<'static, PyNu
     Cow::Owned(PyNumberMethods {
         int: then_some_closure!(zelf.class().has_attr("__int__"), |num, vm| {
             let ret = vm.call_special_method(num.obj.to_owned(), "__int__", ())?;
-            if let Some(i) = ret.downcast_ref::<PyInt>() {
-                Ok(i.to_owned())
-            } else {
-                // TODO
-                Err(vm.new_type_error("".to_string()))
-            }
+            ret.downcast::<PyInt>().map_err(|obj| {
+                vm.new_type_error(format!("__int__ returned non-int (type {})", obj.class()))
+            })
         }),
         float: then_some_closure!(zelf.class().has_attr("__float__"), |num, vm| {
             let ret = vm.call_special_method(num.obj.to_owned(), "__float__", ())?;
-            if let Some(f) = ret.downcast_ref::<PyFloat>() {
-                Ok(f.to_owned())
-            } else {
-                // TODO
-                Err(vm.new_type_error("".to_string()))
-            }
+            ret.downcast::<PyFloat>().map_err(|obj| {
+                vm.new_type_error(format!(
+                    "__float__ returned non-float (type {})",
+                    obj.class()
+                ))
+            })
         }),
         index: then_some_closure!(zelf.class().has_attr("__index__"), |num, vm| {
             let ret = vm.call_special_method(num.obj.to_owned(), "__index__", ())?;
-            if let Some(i) = ret.downcast_ref::<PyInt>() {
-                Ok(i.to_owned())
-            } else {
-                // TODO
-                Err(vm.new_type_error("".to_string()))
-            }
+            ret.downcast::<PyInt>().map_err(|obj| {
+                vm.new_type_error(format!("__index__ returned non-int (type {})", obj.class()))
+            })
         }),
         ..*PyNumberMethods::not_implemented()
     })