Merge pull request RustPython#2079 from youknowone/small-int

youknowone · web-flow · commit 7d75c4eaa67a · 2020-08-09T11:43:10.000+09:00
small int cache for int.__new__
diff --git a/Lib/test/test_int.py b/Lib/test/test_int.py
@@ -233,7 +233,7 @@ def test_underscores(self):
         self.assertRaises(ValueError, int, "1__00")
         self.assertRaises(ValueError, int, "100_")
 
-    @support.cpython_only
+    # @support.cpython_only
     def test_small_ints(self):
         # Bug #3236: Return small longs from PyLong_FromString
         self.assertIs(int('10'), 10)
diff --git a/Lib/test/test_long.py b/Lib/test/test_long.py
@@ -976,7 +976,6 @@ def test_small_ints_in_huge_calculation(self):
         self.assertIs(a + b, 1)
         self.assertIs(c - a, 1)
 
-    @unittest.expectedFailure
     def test_small_ints(self):
         for i in range(-5, 257):
             self.assertIs(i, i + 0)
diff --git a/vm/src/obj/objint.rs b/vm/src/obj/objint.rs
@@ -9,6 +9,7 @@ use num_traits::{One, Pow, Signed, ToPrimitive, Zero};
 use super::objbool::IntoPyBool;
 use super::objbytearray::PyByteArray;
 use super::objbytes::PyBytes;
+use super::objdict::PyDictRef;
 use super::objfloat;
 use super::objmemory::PyMemoryView;
 use super::objstr::{PyString, PyStringRef};
@@ -17,9 +18,8 @@ use crate::bytesinner::PyBytesInner;
 use crate::format::FormatSpec;
 use crate::function::{OptionalArg, PyFuncArgs};
 use crate::pyobject::{
-    IdProtocol, IntoPyObject, IntoPyRef, IntoPyResult, PyArithmaticValue, PyClassImpl,
-    PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject,
-    TypeProtocol,
+    IdProtocol, IntoPyObject, IntoPyResult, PyArithmaticValue, PyClassImpl, PyComparisonValue,
+    PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol,
 };
 use crate::stdlib::array::PyArray;
 use crate::vm::VirtualMachine;
@@ -78,6 +78,23 @@ impl PyValue for PyInt {
     fn class(vm: &VirtualMachine) -> PyClassRef {
         vm.ctx.int_type()
     }
+
+    fn into_simple_object(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_int(self.value)
+    }
+
+    fn into_object(
+        self,
+        vm: &VirtualMachine,
+        cls: PyClassRef,
+        dict: Option<PyDictRef>,
+    ) -> PyObjectRef {
+        if cls.is(&Self::class(vm)) {
+            vm.ctx.new_int(self.value)
+        } else {
+            PyObject::new(self, cls, dict)
+        }
+    }
 }
 
 macro_rules! impl_into_pyobject_int {
@@ -223,10 +240,10 @@ fn inner_truediv(i1: &BigInt, i2: &BigInt, vm: &VirtualMachine) -> PyResult {
 impl PyInt {
     fn with_value<T>(cls: PyClassRef, value: T, vm: &VirtualMachine) -> PyResult<PyIntRef>
     where
-        T: Into<BigInt>,
+        T: Into<BigInt> + ToPrimitive,
     {
         if cls.is(&vm.ctx.int_type()) {
-            Ok(value.into().into_pyref(vm))
+            Ok(PyRef::from_obj_unchecked(vm.ctx.new_int(value)))
         } else {
             PyInt::from(value).into_ref_with_type(vm, cls)
         }
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
@@ -1191,7 +1191,7 @@ where
     T: PyValue + Sized,
 {
     fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        PyObject::new(self, T::class(vm), None)
+        PyValue::into_simple_object(self, vm)
     }
 }
 
@@ -1303,8 +1303,21 @@ pub trait PyValue: fmt::Debug + PyThreadingConstraint + Sized + 'static {
 
     fn class(vm: &VirtualMachine) -> PyClassRef;
 
+    fn into_simple_object(self, vm: &VirtualMachine) -> PyObjectRef {
+        self.into_object(vm, Self::class(vm), None)
+    }
+
+    fn into_object(
+        self,
+        _vm: &VirtualMachine,
+        cls: PyClassRef,
+        dict: Option<PyDictRef>,
+    ) -> PyObjectRef {
+        PyObject::new(self, cls, dict)
+    }
+
     fn into_ref(self, vm: &VirtualMachine) -> PyRef<Self> {
-        self.into_ref_with_type_unchecked(Self::class(vm), None)
+        PyRef::from_obj_unchecked(self.into_simple_object(vm))
     }
 
     fn into_ref_with_type(self, vm: &VirtualMachine, cls: PyClassRef) -> PyResult<PyRef<Self>> {
@@ -1315,17 +1328,13 @@ pub trait PyValue: fmt::Debug + PyThreadingConstraint + Sized + 'static {
             } else {
                 Some(vm.ctx.new_dict())
             };
-            PyRef::from_obj(PyObject::new(self, cls, dict), vm)
+            PyRef::from_obj(self.into_object(vm, cls, dict), vm)
         } else {
             let subtype = vm.to_str(&cls.obj)?;
             let basetype = vm.to_str(&class.obj)?;
             Err(vm.new_type_error(format!("{} is not a subtype of {}", subtype, basetype)))
         }
     }
-
-    fn into_ref_with_type_unchecked(self, cls: PyClassRef, dict: Option<PyDictRef>) -> PyRef<Self> {
-        PyRef::from_obj_unchecked(PyObject::new(self, cls, dict))
-    }
 }
 
 pub trait PyObjectPayload: Any + fmt::Debug + PyThreadingConstraint + 'static {
diff --git a/vm/src/vm.rs b/vm/src/vm.rs
@@ -40,8 +40,8 @@ use crate::obj::objstr::{PyString, PyStringRef};
 use crate::obj::objtuple::PyTuple;
 use crate::obj::objtype::{self, PyClassRef};
 use crate::pyobject::{
-    IdProtocol, ItemProtocol, PyContext, PyObject, PyObjectRef, PyResult, PyValue, TryFromObject,
-    TryIntoRef, TypeProtocol,
+    IdProtocol, ItemProtocol, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue,
+    TryFromObject, TryIntoRef, TypeProtocol,
 };
 use crate::scope::Scope;
 use crate::stdlib;
@@ -415,8 +415,10 @@ impl VirtualMachine {
     ) -> PyBaseExceptionRef {
         // TODO: add repr of args into logging?
         vm_trace!("New exception created: {}", exc_type.name);
-        PyBaseException::new(args, self)
-            .into_ref_with_type_unchecked(exc_type, Some(self.ctx.new_dict()))
+
+        let pyobj =
+            PyBaseException::new(args, self).into_object(self, exc_type, Some(self.ctx.new_dict()));
+        PyRef::from_obj_unchecked(pyobj)
     }
 
     /// Instantiate an exception with no arguments.
