Replace IntoPyRef with VirtualMachine::new_pyref

youknowone · youknowone · commit 947c1cc02b63 · 2022-04-18T06:22:09.000+09:00
diff --git a/stdlib/src/zlib.rs b/stdlib/src/zlib.rs
@@ -5,7 +5,7 @@ mod zlib {
     use crate::common::lock::PyMutex;
     use crate::vm::{
         builtins::{PyBaseExceptionRef, PyBytes, PyBytesRef, PyIntRef, PyTypeRef},
-        function::{ArgBytesLike, IntoPyRef, OptionalArg, OptionalOption},
+        function::{ArgBytesLike, OptionalArg, OptionalOption},
         PyResult, PyValue, VirtualMachine,
     };
     use adler32::RollingAdler32 as Adler32;
@@ -321,7 +321,7 @@ mod zlib {
                     .chain(leftover)
                     .copied()
                     .collect();
-                *unused_data = unused.into_pyref(vm);
+                *unused_data = vm.new_pyref(unused);
             }
         }
 
diff --git a/vm/src/builtins/range.rs b/vm/src/builtins/range.rs
@@ -2,7 +2,7 @@ use super::{PyInt, PyIntRef, PySlice, PyTupleRef, PyTypeRef};
 use crate::common::hash::PyHash;
 use crate::{
     builtins::builtins_iter,
-    function::{FuncArgs, IntoPyRef, OptionalArg, PyComparisonValue},
+    function::{FuncArgs, OptionalArg, PyComparisonValue},
     protocol::{PyIterReturn, PyMappingMethods, PySequenceMethods},
     pyclass::PyClassImpl,
     types::{
@@ -183,9 +183,9 @@ pub fn init(context: &PyContext) {
 impl PyRange {
     fn new(cls: PyTypeRef, stop: PyIntRef, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         PyRange {
-            start: (0).into_pyref(vm),
+            start: vm.new_pyref(0),
             stop,
-            step: (1).into_pyref(vm),
+            step: vm.new_pyref(1),
         }
         .into_ref_with_type(vm, cls)
     }
@@ -197,7 +197,7 @@ impl PyRange {
         step: OptionalArg<PyIntRef>,
         vm: &VirtualMachine,
     ) -> PyResult<PyRef<Self>> {
-        let step = step.unwrap_or_else(|| (1).into_pyref(vm));
+        let step = step.unwrap_or_else(|| vm.new_pyref(1));
         if step.as_bigint().is_zero() {
             return Err(vm.new_value_error("range() arg 3 must not be zero".to_owned()));
         }
@@ -350,9 +350,9 @@ impl PyRange {
                 substop = (substop * range_step.as_bigint()) + range_start.as_bigint();
 
                 Ok(PyRange {
-                    start: substart.into_pyref(vm),
-                    stop: substop.into_pyref(vm),
-                    step: substep.into_pyref(vm),
+                    start: vm.new_pyref(substart),
+                    stop: vm.new_pyref(substop),
+                    step: vm.new_pyref(substep),
                 }
                 .into_ref(vm)
                 .into())
diff --git a/vm/src/function.rs b/vm/src/function.rs
@@ -6,7 +6,7 @@ mod number;
 use crate::{
     builtins::{PyBaseExceptionRef, PyTupleRef, PyTypeRef},
     convert::{ToPyObject, ToPyResult},
-    pyobject::{PyObjectPayload, PyThreadingConstraint},
+    pyobject::PyThreadingConstraint,
     AsPyObject, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, VirtualMachine,
 };
 use indexmap::IndexMap;
@@ -18,10 +18,6 @@ pub use arithmetic::{PyArithmeticValue, PyComparisonValue};
 pub use buffer::{ArgAsciiBuffer, ArgBytesLike, ArgMemoryBuffer, ArgStrOrBytesLike};
 pub use number::{ArgIntoBool, ArgIntoComplex, ArgIntoFloat};
 
-pub trait IntoPyRef<T: PyObjectPayload> {
-    fn into_pyref(self, vm: &VirtualMachine) -> PyRef<T>;
-}
-
 pub trait IntoFuncArgs: Sized {
     fn into_args(self, vm: &VirtualMachine) -> FuncArgs;
     fn into_method_args(self, obj: PyObjectRef, vm: &VirtualMachine) -> FuncArgs {
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
@@ -14,7 +14,7 @@ use crate::{
     convert::{ToPyObject, ToPyResult},
     dictdatatype::Dict,
     exceptions,
-    function::{IntoFuncArgs, IntoPyNativeFunc, IntoPyRef},
+    function::{IntoFuncArgs, IntoPyNativeFunc},
     pyclass::{PyClassImpl, StaticType},
     types::{PyTypeFlags, PyTypeSlots, TypeZoo},
     VirtualMachine,
@@ -497,16 +497,6 @@ where
     }
 }
 
-impl<T, P> IntoPyRef<P> for T
-where
-    P: PyValue + ToPyObject + From<T>,
-{
-    #[inline(always)]
-    fn into_pyref(self, vm: &VirtualMachine) -> PyRef<P> {
-        P::from(self).into_ref(vm)
-    }
-}
-
 impl<T: PyObjectPayload> ToPyObject for PyRef<T> {
     #[inline(always)]
     fn to_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
diff --git a/vm/src/stdlib/os.rs b/vm/src/stdlib/os.rs
@@ -436,7 +436,7 @@ pub(super) mod _os {
         },
         convert::{ToPyException, ToPyObject},
         crt_fd::{Fd, Offset},
-        function::{ArgBytesLike, FuncArgs, IntoPyRef, OptionalArg},
+        function::{ArgBytesLike, FuncArgs, OptionalArg},
         protocol::PyIterReturn,
         suppress_iph,
         types::{IterNext, IterNextIterable},
@@ -1033,13 +1033,13 @@ pub(super) mod _os {
             let to_f64 = |(s, ns)| (s as f64) + (ns as f64) / (NANOS_PER_SEC as f64);
             let to_ns = |(s, ns)| s as i128 * NANOS_PER_SEC as i128 + ns as i128;
             StatResult {
-                st_mode: stat.st_mode.into_pyref(vm),
-                st_ino: stat.st_ino.into_pyref(vm),
-                st_dev: stat.st_dev.into_pyref(vm),
-                st_nlink: stat.st_nlink.into_pyref(vm),
-                st_uid: stat.st_uid.into_pyref(vm),
-                st_gid: stat.st_gid.into_pyref(vm),
-                st_size: stat.st_size.into_pyref(vm),
+                st_mode: vm.new_pyref(stat.st_mode),
+                st_ino: vm.new_pyref(stat.st_ino),
+                st_dev: vm.new_pyref(stat.st_dev),
+                st_nlink: vm.new_pyref(stat.st_nlink),
+                st_uid: vm.new_pyref(stat.st_uid),
+                st_gid: vm.new_pyref(stat.st_gid),
+                st_size: vm.new_pyref(stat.st_size),
                 __st_atime_int: atime.0,
                 __st_mtime_int: mtime.0,
                 __st_ctime_int: ctime.0,
diff --git a/vm/src/vm_new.rs b/vm/src/vm_new.rs
@@ -10,7 +10,7 @@ use crate::{
     convert::ToPyObject,
     scope::Scope,
     vm::VirtualMachine,
-    AsPyObject, PyObject, PyObjectRef, PyObjectWrap, PyRef,
+    AsPyObject, PyObject, PyObjectRef, PyObjectWrap, PyRef, PyValue,
 };
 
 /// Collection of object creation helpers
@@ -20,6 +20,14 @@ impl VirtualMachine {
         value.to_pyobject(self)
     }
 
+    pub fn new_pyref<T, P>(&self, value: T) -> PyRef<P>
+    where
+        T: Into<P>,
+        P: PyValue,
+    {
+        value.into().into_ref(self)
+    }
+
     pub fn new_tuple(&self, value: impl IntoPyTuple) -> PyTupleRef {
         value.into_pytuple(self)
     }
