Implemented repr slot

Author: haxelion

vm/src/builtins/asyncgenerator.rs

@@ -1,12 +1,12 @@
-use super::{PyCode, PyGenericAlias, PyStrRef, PyType, PyTypeRef};
+use super::{PyCode, PyGenericAlias, PyStr, PyStrRef, PyType, PyTypeRef};
 use crate::{
     builtins::PyBaseExceptionRef,
     class::PyClassImpl,
     coroutine::Coro,
     frame::FrameRef,
     function::OptionalArg,
     protocol::PyIterReturn,
-    types::{Constructor, IterNext, IterNextIterable, Unconstructible},
+    types::{Constructor, IterNext, IterNextIterable, Representable, Unconstructible},
     AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
 };
 
@@ -26,7 +26,7 @@ impl PyPayload for PyAsyncGen {
     }
 }
 
-#[pyclass(with(Constructor))]
+#[pyclass(with(Constructor, Representable))]
 impl PyAsyncGen {
     pub fn as_coro(&self) -> &Coro {
         &self.inner
@@ -49,11 +49,6 @@ impl PyAsyncGen {
         self.inner.set_name(name)
     }
 
-    #[pymethod(magic)]
-    fn repr(zelf: PyRef<Self>, vm: &VirtualMachine) -> String {
-        zelf.inner.repr(zelf.as_object(), zelf.get_id(), vm)
-    }
-
     #[pymethod(magic)]
     fn aiter(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyRef<Self> {
         zelf
@@ -129,6 +124,14 @@ impl PyAsyncGen {
         PyGenericAlias::new(cls, args, vm)
     }
 }
+
+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))
+    }
+}
+
 impl Unconstructible for PyAsyncGen {}
 
 #[pyclass(module = false, name = "async_generator_wrapped_value")]

vm/src/builtins/bool.rs

@@ -5,7 +5,7 @@ use crate::{
     function::OptionalArg,
     identifier,
     protocol::PyNumberMethods,
-    types::{AsNumber, Constructor},
+    types::{AsNumber, Constructor, Representable},
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyResult, TryFromBorrowedObject,
     VirtualMachine,
 };
@@ -107,18 +107,8 @@ impl Constructor for PyBool {
     }
 }
 
-#[pyclass(with(Constructor, AsNumber))]
+#[pyclass(with(Constructor, AsNumber, Representable))]
 impl PyBool {
-    #[pymethod(magic)]
-    fn repr(zelf: bool, vm: &VirtualMachine) -> PyStrRef {
-        if zelf {
-            vm.ctx.names.True
-        } else {
-            vm.ctx.names.False
-        }
-        .to_owned()
-    }
-
     #[pymethod(magic)]
     fn format(obj: PyObjectRef, format_spec: PyStrRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
         if format_spec.is_empty() {
@@ -189,6 +179,31 @@ 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())
+        } else {
+            Ok(vm.ctx.names.False.to_owned())
+        }
+    }
+
+    #[inline]
+    fn __repr__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        Self::slot_repr(&zelf, vm)
+    }
+
+    #[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())
+        }
+    }
+}
+
 pub(crate) fn init(context: &Context) {
     PyBool::extend_class(context, context.types.bool_type);
 }

vm/src/builtins/builtin_func.rs

@@ -3,7 +3,7 @@ use crate::{
     builtins::PyBoundMethod,
     class::PyClassImpl,
     function::{FuncArgs, IntoPyNativeFunc, PyNativeFunc},
-    types::{Callable, Constructor, GetDescriptor, Unconstructible},
+    types::{Callable, Constructor, GetDescriptor, Representable, Unconstructible},
     AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
 };
 use std::fmt;
@@ -145,10 +145,6 @@ impl PyBuiltinFunction {
     fn reduce_ex(&self, _ver: PyObjectRef) -> PyStrRef {
         self.name()
     }
-    #[pymethod(magic)]
-    fn repr(&self) -> String {
-        format!("<built-in function {}>", self.value.name)
-    }
     #[pygetset(magic)]
     fn text_signature(&self) -> Option<String> {
         self.value.doc.as_ref().and_then(|doc| {
@@ -157,6 +153,14 @@ 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))
+    }
+}
+
 impl Unconstructible for PyBuiltinFunction {}
 
 // `PyBuiltinMethod` is similar to both `PyMethodDescrObject` in
@@ -225,7 +229,10 @@ impl PyBuiltinMethod {
     }
 }
 
-#[pyclass(with(GetDescriptor, Callable, Constructor), flags(METHOD_DESCR))]
+#[pyclass(
+    with(GetDescriptor, Callable, Constructor, Representable),
+    flags(METHOD_DESCR)
+)]
 impl PyBuiltinMethod {
     #[pygetset(magic)]
     fn name(&self) -> PyStrRef {
@@ -247,14 +254,6 @@ impl PyBuiltinMethod {
         })
     }
     #[pymethod(magic)]
-    fn repr(&self) -> String {
-        format!(
-            "<method '{}' of '{}' objects>",
-            &self.value.name,
-            self.class.name()
-        )
-    }
-    #[pymethod(magic)]
     fn reduce(
         &self,
         vm: &VirtualMachine,
@@ -264,6 +263,19 @@ impl PyBuiltinMethod {
         (builtins_getattr, (classname, self.value.name.clone()))
     }
 }
+
+impl Representable for PyBuiltinMethod {
+    #[inline]
+    fn repr(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        Ok(PyStr::from(format!(
+            "<method '{}' of '{}' objects>",
+            &zelf.value.name,
+            zelf.class.name()
+        ))
+        .into_ref(vm))
+    }
+}
+
 impl Unconstructible for PyBuiltinMethod {}
 
 pub fn init(context: &Context) {

vm/src/builtins/bytearray.rs

@@ -1,7 +1,7 @@
 //! Implementation of the python bytearray object.
 use super::{
-    PositionIterInternal, PyBytes, PyBytesRef, PyDictRef, PyIntRef, PyStrRef, PyTuple, PyTupleRef,
-    PyType, PyTypeRef,
+    PositionIterInternal, PyBytes, PyBytesRef, PyDictRef, PyIntRef, PyStr, PyStrRef, PyTuple,
+    PyTupleRef, PyType, PyTypeRef,
 };
 use crate::{
     anystr::{self, AnyStr},
@@ -31,7 +31,7 @@ use crate::{
     sliceable::{SequenceIndex, SliceableSequenceMutOp, SliceableSequenceOp},
     types::{
         AsBuffer, AsMapping, AsNumber, AsSequence, Callable, Comparable, Constructor, Initializer,
-        IterNext, IterNextIterable, Iterable, PyComparisonOp, Unconstructible,
+        IterNext, IterNextIterable, Iterable, PyComparisonOp, Representable, Unconstructible,
     },
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
     VirtualMachine,
@@ -107,7 +107,8 @@ pub(crate) fn init(context: &Context) {
         AsMapping,
         AsSequence,
         AsNumber,
-        Iterable
+        Iterable,
+        Representable
     )
 )]
 impl PyByteArray {
@@ -126,13 +127,6 @@ impl PyByteArray {
         self.inner.write()
     }
 
-    #[pymethod(magic)]
-    fn repr(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<String> {
-        let class = zelf.class();
-        let class_name = class.name();
-        zelf.inner().repr(Some(&class_name), vm)
-    }
-
     #[pymethod(magic)]
     fn alloc(&self) -> usize {
         self.inner().capacity()
@@ -886,6 +880,17 @@ impl Iterable for PyByteArray {
     }
 }
 
+impl Representable for PyByteArray {
+    #[inline]
+    fn repr(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        let class = zelf.class();
+        let class_name = class.name();
+        zelf.inner()
+            .repr(Some(&class_name), vm)
+            .map(|s| PyStr::from(s).into_ref(vm))
+    }
+}
+
 // fn set_value(obj: &PyObject, value: Vec<u8>) {
 //     obj.borrow_mut().kind = PyObjectPayload::Bytes { value };
 // }
@@ -922,6 +927,7 @@ impl PyByteArrayIterator {
             .set_state(state, |obj, pos| pos.min(obj.len()), vm)
     }
 }
+
 impl Unconstructible for PyByteArrayIterator {}
 
 impl IterNextIterable for PyByteArrayIterator {}

vm/src/builtins/bytes.rs

@@ -1,5 +1,6 @@
 use super::{
-    PositionIterInternal, PyDictRef, PyIntRef, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef,
+    PositionIterInternal, PyDictRef, PyIntRef, PyStr, PyStrRef, PyTuple, PyTupleRef, PyType,
+    PyTypeRef,
 };
 use crate::{
     anystr::{self, AnyStr},
@@ -21,7 +22,7 @@ use crate::{
     sliceable::{SequenceIndex, SliceableSequenceOp},
     types::{
         AsBuffer, AsMapping, AsNumber, AsSequence, Callable, Comparable, Constructor, Hashable,
-        IterNext, IterNextIterable, Iterable, PyComparisonOp, Unconstructible,
+        IterNext, IterNextIterable, Iterable, PyComparisonOp, Representable, Unconstructible,
     },
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
     TryFromBorrowedObject, TryFromObject, VirtualMachine,
@@ -125,15 +126,11 @@ impl PyBytes {
         AsBuffer,
         Iterable,
         Constructor,
-        AsNumber
+        AsNumber,
+        Representable,
     )
 )]
 impl PyBytes {
-    #[pymethod(magic)]
-    pub(crate) fn repr(&self, vm: &VirtualMachine) -> PyResult<String> {
-        self.inner.repr(None, vm)
-    }
-
     #[pymethod(magic)]
     #[inline]
     pub fn len(&self) -> usize {
@@ -689,6 +686,15 @@ 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))
+    }
+}
+
 #[pyclass(module = false, name = "bytes_iterator")]
 #[derive(Debug)]
 pub struct PyBytesIterator {

vm/src/builtins/classmethod.rs

@@ -1,8 +1,8 @@
-use super::{PyBoundMethod, PyStr, PyType, PyTypeRef};
+use super::{PyBoundMethod, PyStr, PyStrRef, PyType, PyTypeRef};
 use crate::{
     class::PyClassImpl,
     common::lock::PyMutex,
-    types::{Constructor, GetDescriptor, Initializer},
+    types::{Constructor, GetDescriptor, Initializer, Representable},
     AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
 };
 
@@ -104,7 +104,10 @@ impl PyClassMethod {
     }
 }
 
-#[pyclass(with(GetDescriptor, Constructor), flags(BASETYPE, HAS_DICT))]
+#[pyclass(
+    with(GetDescriptor, Constructor, Representable),
+    flags(BASETYPE, HAS_DICT)
+)]
 impl PyClassMethod {
     #[pygetset(magic)]
     fn func(&self) -> PyObjectRef {
@@ -136,26 +139,6 @@ impl PyClassMethod {
         self.callable.lock().get_attr("__annotations__", vm)
     }
 
-    #[pymethod(magic)]
-    fn repr(&self, vm: &VirtualMachine) -> Option<String> {
-        let callable = self.callable.lock().repr(vm).unwrap();
-        let class = Self::class(vm);
-
-        match (
-            class
-                .qualname(vm)
-                .downcast_ref::<PyStr>()
-                .map(|n| n.as_str()),
-            class.module(vm).downcast_ref::<PyStr>().map(|m| m.as_str()),
-        ) {
-            (None, _) => None,
-            (Some(qualname), Some(module)) if module != "builtins" => {
-                Some(format!("<{module}.{qualname}({callable})>"))
-            }
-            _ => Some(format!("<{}({})>", class.slot_name(), callable)),
-        }
-    }
-
     #[pygetset(magic)]
     fn isabstractmethod(&self, vm: &VirtualMachine) -> PyObjectRef {
         match vm.get_attribute_opt(self.callable.lock().clone(), "__isabstractmethod__") {
@@ -173,6 +156,28 @@ impl PyClassMethod {
     }
 }
 
+impl Representable for PyClassMethod {
+    #[inline]
+    fn repr(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        let callable = zelf.callable.lock().repr(vm).unwrap();
+        let class = Self::class(vm);
+
+        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())),
+            (Some(qualname), Some(module)) if module != "builtins" => {
+                Ok(PyStr::from(format!("<{module}.{qualname}({callable})>")).into_ref(vm))
+            }
+            _ => Ok(PyStr::from(format!("<{}({})>", class.slot_name(), callable)).into_ref(vm)),
+        }
+    }
+}
+
 pub(crate) fn init(context: &Context) {
     PyClassMethod::extend_class(context, context.types.classmethod_type);
 }