Simplify Representable impls

Author: youknowone

vm/src/builtins/asyncgenerator.rs

@@ -1,4 +1,4 @@
-use super::{PyCode, PyGenericAlias, PyStr, PyStrRef, PyType, PyTypeRef};
+use super::{PyCode, PyGenericAlias, PyStrRef, PyType, PyTypeRef};
 use crate::{
     builtins::PyBaseExceptionRef,
     class::PyClassImpl,
@@ -127,8 +127,8 @@ impl PyAsyncGen {
 
 impl Representable for PyAsyncGen {
     #[inline]
-    fn repr(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        Ok(PyStr::from(zelf.inner.repr(zelf.as_object(), zelf.get_id(), vm)).into_ref(vm))
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        Ok(zelf.inner.repr(zelf.as_object(), zelf.get_id(), vm))
     }
 }
 
@@ -267,7 +267,7 @@ impl PyAsyncGenASend {
 
 impl IterNextIterable for PyAsyncGenASend {}
 impl IterNext for PyAsyncGenASend {
-    fn next(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
         PyIterReturn::from_pyresult(zelf.send(vm.ctx.none(), vm), vm)
     }
 }
@@ -413,7 +413,7 @@ impl PyAsyncGenAThrow {
 
 impl IterNextIterable for PyAsyncGenAThrow {}
 impl IterNext for PyAsyncGenAThrow {
-    fn next(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
         PyIterReturn::from_pyresult(zelf.send(vm.ctx.none(), vm), vm)
     }
 }

vm/src/builtins/bool.rs

@@ -182,25 +182,17 @@ impl AsNumber for PyBool {
 impl Representable for PyBool {
     #[inline]
     fn slot_repr(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        if get_value(zelf) {
-            Ok(vm.ctx.names.True.to_owned())
+        let name = if get_value(zelf.as_object()) {
+            vm.ctx.names.True
         } else {
-            Ok(vm.ctx.names.False.to_owned())
-        }
-    }
-
-    #[inline]
-    fn __repr__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        Self::slot_repr(&zelf, vm)
+            vm.ctx.names.False
+        };
+        Ok(name.to_owned())
     }
 
-    #[inline]
-    fn repr(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        if get_value(zelf.as_object()) {
-            Ok(vm.ctx.names.True.to_owned())
-        } else {
-            Ok(vm.ctx.names.False.to_owned())
-        }
+    #[cold]
+    fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        unreachable!("use slot_repr instead")
     }
 }
 

vm/src/builtins/builtin_func.rs

@@ -109,7 +109,7 @@ impl PyBuiltinFunction {
 impl Callable for PyBuiltinFunction {
     type Args = FuncArgs;
     #[inline]
-    fn call(zelf: &crate::Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+    fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
         (zelf.value.func)(vm, args)
     }
 }
@@ -156,8 +156,8 @@ impl PyBuiltinFunction {
 
 impl Representable for PyBuiltinFunction {
     #[inline]
-    fn repr(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        Ok(PyStr::from(format!("<built-in function {}>", zelf.value.name)).into_ref(vm))
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        Ok(format!("<built-in function {}>", zelf.value.name))
     }
 }
 
@@ -210,7 +210,7 @@ impl GetDescriptor for PyBuiltinMethod {
 impl Callable for PyBuiltinMethod {
     type Args = FuncArgs;
     #[inline]
-    fn call(zelf: &crate::Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+    fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
         (zelf.value.func)(vm, args)
     }
 }
@@ -266,13 +266,12 @@ impl PyBuiltinMethod {
 
 impl Representable for PyBuiltinMethod {
     #[inline]
-    fn repr(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        Ok(PyStr::from(format!(
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        Ok(format!(
             "<method '{}' of '{}' objects>",
             &zelf.value.name,
             zelf.class.name()
         ))
-        .into_ref(vm))
     }
 }
 

vm/src/builtins/bytearray.rs

@@ -1,7 +1,7 @@
 //! Implementation of the python bytearray object.
 use super::{
-    PositionIterInternal, PyBytes, PyBytesRef, PyDictRef, PyIntRef, PyStr, PyStrRef, PyTuple,
-    PyTupleRef, PyType, PyTypeRef,
+    PositionIterInternal, PyBytes, PyBytesRef, PyDictRef, PyIntRef, PyStrRef, PyTuple, PyTupleRef,
+    PyType, PyTypeRef,
 };
 use crate::{
     anystr::{self, AnyStr},
@@ -294,7 +294,7 @@ impl PyByteArray {
         }
     }
 
-    fn irepeat(zelf: &crate::Py<Self>, n: isize, vm: &VirtualMachine) -> PyResult<()> {
+    fn irepeat(zelf: &Py<Self>, n: isize, vm: &VirtualMachine) -> PyResult<()> {
         if n == 1 {
             return Ok(());
         }
@@ -733,7 +733,7 @@ impl Initializer for PyByteArray {
 
 impl Comparable for PyByteArray {
     fn cmp(
-        zelf: &crate::Py<Self>,
+        zelf: &Py<Self>,
         other: &PyObject,
         op: PyComparisonOp,
         vm: &VirtualMachine,
@@ -882,12 +882,10 @@ impl Iterable for PyByteArray {
 
 impl Representable for PyByteArray {
     #[inline]
-    fn repr(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
         let class = zelf.class();
         let class_name = class.name();
-        zelf.inner()
-            .repr(Some(&class_name), vm)
-            .map(|s| PyStr::from(s).into_ref(vm))
+        zelf.inner().repr(Some(&class_name), vm)
     }
 }
 
@@ -932,7 +930,7 @@ impl Unconstructible for PyByteArrayIterator {}
 
 impl IterNextIterable for PyByteArrayIterator {}
 impl IterNext for PyByteArrayIterator {
-    fn next(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
         zelf.internal.lock().next(|bytearray, pos| {
             let buf = bytearray.borrow_buf();
             Ok(PyIterReturn::from_result(

vm/src/builtins/bytes.rs

@@ -1,6 +1,5 @@
 use super::{
-    PositionIterInternal, PyDictRef, PyIntRef, PyStr, PyStrRef, PyTuple, PyTupleRef, PyType,
-    PyTypeRef,
+    PositionIterInternal, PyDictRef, PyIntRef, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef,
 };
 use crate::{
     anystr::{self, AnyStr},
@@ -647,14 +646,14 @@ impl AsNumber for PyBytes {
 
 impl Hashable for PyBytes {
     #[inline]
-    fn hash(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash> {
+    fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash> {
         Ok(zelf.inner.hash(vm))
     }
 }
 
 impl Comparable for PyBytes {
     fn cmp(
-        zelf: &crate::Py<Self>,
+        zelf: &Py<Self>,
         other: &PyObject,
         op: PyComparisonOp,
         vm: &VirtualMachine,
@@ -688,10 +687,8 @@ impl Iterable for PyBytes {
 
 impl Representable for PyBytes {
     #[inline]
-    fn repr(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        zelf.inner
-            .repr(None, vm)
-            .map(|s| PyStr::from(s).into_ref(vm))
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        zelf.inner.repr(None, vm)
     }
 }
 
@@ -732,7 +729,7 @@ impl Unconstructible for PyBytesIterator {}
 
 impl IterNextIterable for PyBytesIterator {}
 impl IterNext for PyBytesIterator {
-    fn next(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
         zelf.internal.lock().next(|bytes, pos| {
             Ok(PyIterReturn::from_result(
                 bytes

vm/src/builtins/classmethod.rs

@@ -1,4 +1,4 @@
-use super::{PyBoundMethod, PyStr, PyStrRef, PyType, PyTypeRef};
+use super::{PyBoundMethod, PyStr, PyType, PyTypeRef};
 use crate::{
     class::PyClassImpl,
     common::lock::PyMutex,
@@ -158,23 +158,24 @@ impl PyClassMethod {
 
 impl Representable for PyClassMethod {
     #[inline]
-    fn repr(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
         let callable = zelf.callable.lock().repr(vm).unwrap();
         let class = Self::class(vm);
 
-        match (
+        let repr = match (
             class
                 .qualname(vm)
                 .downcast_ref::<PyStr>()
                 .map(|n| n.as_str()),
             class.module(vm).downcast_ref::<PyStr>().map(|m| m.as_str()),
         ) {
-            (None, _) => Err(vm.new_type_error("Unknown qualified name".into())),
+            (None, _) => return Err(vm.new_type_error("Unknown qualified name".into())),
             (Some(qualname), Some(module)) if module != "builtins" => {
-                Ok(PyStr::from(format!("<{module}.{qualname}({callable})>")).into_ref(vm))
+                format!("<{module}.{qualname}({callable})>")
             }
-            _ => Ok(PyStr::from(format!("<{}({})>", class.slot_name(), callable)).into_ref(vm)),
-        }
+            _ => format!("<{}({})>", class.slot_name(), callable),
+        };
+        Ok(repr)
     }
 }
 

vm/src/builtins/code.rs

@@ -2,7 +2,7 @@
 
 */
 
-use super::{PyStr, PyStrRef, PyTupleRef, PyType, PyTypeRef};
+use super::{PyStrRef, PyTupleRef, PyType, PyTypeRef};
 use crate::{
     builtins::PyStrInterned,
     bytecode::{self, AsBag, BorrowedConstant, CodeFlags, Constant, ConstantBag},
@@ -221,16 +221,15 @@ impl PyCode {}
 
 impl Representable for PyCode {
     #[inline]
-    fn repr(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
         let code = &zelf.code;
-        Ok(PyStr::from(format!(
+        Ok(format!(
             "<code object {} at {:#x} file {:?}, line {}>",
             code.obj_name,
             zelf.get_id(),
             code.source_path.as_str(),
             code.first_line_number
         ))
-        .into_ref(vm))
     }
 }
 

vm/src/builtins/complex.rs

@@ -1,4 +1,4 @@
-use super::{float, PyStr, PyStrRef, PyType, PyTypeRef};
+use super::{float, PyStr, PyType, PyTypeRef};
 use crate::{
     class::PyClassImpl,
     convert::{ToPyObject, ToPyResult},
@@ -371,7 +371,7 @@ impl PyComplex {
 
 impl Comparable for PyComplex {
     fn cmp(
-        zelf: &crate::Py<Self>,
+        zelf: &Py<Self>,
         other: &PyObject,
         op: PyComparisonOp,
         vm: &VirtualMachine,
@@ -401,7 +401,7 @@ impl Comparable for PyComplex {
 
 impl Hashable for PyComplex {
     #[inline]
-    fn hash(zelf: &crate::Py<Self>, _vm: &VirtualMachine) -> PyResult<hash::PyHash> {
+    fn hash(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<hash::PyHash> {
         let value = zelf.value;
 
         let re_hash =
@@ -455,7 +455,7 @@ impl AsNumber for PyComplex {
 
 impl Representable for PyComplex {
     #[inline]
-    fn repr(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
         // TODO: when you fix this, move it to rustpython_common::complex::repr and update
         //       ast/src/unparse.rs + impl Display for Constant in ast/src/constant.rs
         let Complex64 { re, im } = zelf.value;
@@ -470,7 +470,7 @@ impl Representable for PyComplex {
         // positive empty => return im_part, integer => drop ., fractional => float_ops
         let re_part = if re == 0.0 {
             if re.is_sign_positive() {
-                return Ok(PyStr::from(im_part).into_ref(vm));
+                return Ok(im_part);
             } else {
                 re.to_string()
             }
@@ -489,7 +489,7 @@ impl Representable for PyComplex {
         }
         result.push_str(&im_part);
         result.push(')');
-        Ok(PyStr::from(result).into_ref(vm))
+        Ok(result)
     }
 }
 

vm/src/builtins/coroutine.rs

@@ -1,4 +1,4 @@
-use super::{PyCode, PyStr, PyStrRef, PyType};
+use super::{PyCode, PyStrRef, PyType};
 use crate::{
     class::PyClassImpl,
     coroutine::Coro,
@@ -103,14 +103,14 @@ impl Unconstructible for PyCoroutine {}
 
 impl Representable for PyCoroutine {
     #[inline]
-    fn repr(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        Ok(PyStr::from(zelf.inner.repr(zelf.as_object(), zelf.get_id(), vm)).into_ref(vm))
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        Ok(zelf.inner.repr(zelf.as_object(), zelf.get_id(), vm))
     }
 }
 
 impl IterNextIterable for PyCoroutine {}
 impl IterNext for PyCoroutine {
-    fn next(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
         Self::send(zelf.to_owned(), vm.ctx.none(), vm)
     }
 }
@@ -149,7 +149,7 @@ impl PyCoroutineWrapper {
 
 impl IterNextIterable for PyCoroutineWrapper {}
 impl IterNext for PyCoroutineWrapper {
-    fn next(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
         Self::send(zelf.to_owned(), vm.ctx.none(), vm)
     }
 }

vm/src/builtins/descriptor.rs

@@ -1,4 +1,4 @@
-use super::{PyStr, PyStrRef, PyType, PyTypeRef};
+use super::{PyStr, PyType, PyTypeRef};
 use crate::{
     class::PyClassImpl,
     function::PySetterValue,
@@ -190,13 +190,12 @@ impl Unconstructible for MemberDescrObject {}
 
 impl Representable for MemberDescrObject {
     #[inline]
-    fn repr(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        Ok(PyStr::from(format!(
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        Ok(format!(
             "<member '{}' of '{}' objects>",
             zelf.common.name,
             zelf.common.typ.name(),
         ))
-        .into_ref(vm))
     }
 }