Relocate vm.to_repr to object.repr

src/lib.rs

@@ -128,7 +128,7 @@ where
                         }
                     }),
                     _ => {
-                        if let Ok(r) = vm.to_repr(args.as_object()) {
+                        if let Ok(r) = args.as_object().repr(vm) {
                             eprintln!("{}", r);
                         }
                         1

vm/src/builtins/dict.rs

@@ -213,8 +213,8 @@ impl PyDict {
         let s = if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
             let mut str_parts = Vec::with_capacity(zelf.len());
             for (key, value) in zelf {
-                let key_repr = vm.to_repr(&key)?;
-                let value_repr = vm.to_repr(&value)?;
+                let key_repr = &key.repr(vm)?;
+                let value_repr = value.repr(vm)?;
                 str_parts.push(format!("{}: {}", key_repr, value_repr));
             }
 
@@ -696,7 +696,7 @@ where
         let s = if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
             let mut str_parts = Vec::with_capacity(zelf.len());
             for (key, value) in zelf.dict().clone() {
-                let s = vm.to_repr(&Self::item(vm, key, value))?;
+                let s = &Self::item(vm, key, value).repr(vm)?;
                 str_parts.push(s.as_str().to_owned());
             }
             format!("{}([{}])", Self::NAME, str_parts.join(", "))

vm/src/builtins/function.rs

@@ -516,7 +516,7 @@ impl PyBoundMethod {
         Ok(format!(
             "<bound method {} of {}>",
             funcname.as_ref().map_or("?", |s| s.as_str()),
-            vm.to_repr(&self.object)?.as_str(),
+            &self.object.repr(vm)?.as_str(),
         ))
     }
 

vm/src/builtins/genericalias.rs

@@ -82,7 +82,7 @@ impl PyGenericAlias {
             if vm.get_attribute_opt(obj.clone(), "__origin__")?.is_some()
                 && vm.get_attribute_opt(obj.clone(), "__args__")?.is_some()
             {
-                return Ok(vm.to_repr(&obj)?.as_str().to_string());
+                return Ok(obj.repr(vm)?.as_str().to_string());
             }
 
             match (
@@ -91,7 +91,7 @@ impl PyGenericAlias {
                 vm.get_attribute_opt(obj.clone(), "__module__")?
                     .and_then(|o| o.downcast_ref::<PyStr>().map(|m| m.as_str().to_string())),
             ) {
-                (None, _) | (_, None) => Ok(vm.to_repr(&obj)?.as_str().to_string()),
+                (None, _) | (_, None) => Ok(obj.repr(vm)?.as_str().to_string()),
                 (Some(qualname), Some(module)) => Ok(if module == "builtins" {
                     qualname
                 } else {

vm/src/builtins/int.rs

@@ -785,7 +785,7 @@ fn try_int_radix(obj: &PyObject, base: u32, vm: &VirtualMachine) -> PyResult<Big
         None => Err(vm.new_value_error(format!(
             "invalid literal for int() with base {}: {}",
             base,
-            vm.to_repr(obj)?,
+            obj.repr(vm)?,
         ))),
     }
 }
@@ -917,7 +917,7 @@ pub(crate) fn try_int(obj: &PyObject, vm: &VirtualMachine) -> PyResult<BigInt> {
             None => Err(vm.new_value_error(format!(
                 "invalid literal for int() with base {}: {}",
                 base,
-                vm.to_repr(obj)?,
+                obj.repr(vm)?,
             ))),
         }
     }

vm/src/builtins/list.rs

@@ -228,7 +228,7 @@ impl PyList {
             let elements = zelf.borrow_vec().to_vec();
             let mut str_parts = Vec::with_capacity(elements.len());
             for elem in elements.iter() {
-                let s = vm.to_repr(elem)?;
+                let s = elem.repr(vm)?;
                 str_parts.push(s.as_str().to_owned());
             }
             format!("[{}]", str_parts.join(", "))

vm/src/builtins/mappingproxy.rs

@@ -146,7 +146,7 @@ impl PyMappingProxy {
                 PyDict::from_attributes(c.attributes.read().clone(), vm)?.into_pyobject(vm)
             }
         };
-        Ok(format!("mappingproxy({})", vm.to_repr(&obj)?))
+        Ok(format!("mappingproxy({})", obj.repr(vm)?))
     }
 
     #[pyclassmethod(magic)]

vm/src/builtins/namespace.rs

@@ -61,9 +61,9 @@ impl PyNamespace {
             let parts = if let Some(dict) = zelf.as_object().dict() {
                 let mut parts = Vec::with_capacity(dict.len());
                 for (key, value) in dict {
-                    let k = vm.to_repr(&key)?;
+                    let k = &key.repr(vm)?;
                     let key_str = k.as_str();
-                    let value_repr = vm.to_repr(&value)?;
+                    let value_repr = value.repr(vm)?;
                     parts.push(format!("{}={}", &key_str[1..key_str.len() - 1], value_repr));
                 }
                 parts

vm/src/builtins/object.rs

@@ -170,7 +170,7 @@ impl PyBaseObject {
     /// Return str(self).
     #[pymethod(magic)]
     fn str(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        vm.to_repr(&zelf)
+        zelf.repr(vm)
     }
 
     /// Return repr(self).

vm/src/builtins/range.rs

@@ -49,7 +49,8 @@ fn iter_search(
         SearchType::Contains => Ok(0),
         SearchType::Index => Err(vm.new_value_error(format!(
             "{} not in range",
-            vm.to_repr(&item)
+            &item
+                .repr(vm)
                 .map(|v| v.as_str().to_owned())
                 .unwrap_or_else(|_| "value".to_owned())
         ))),

vm/src/builtins/set.rs

@@ -219,7 +219,7 @@ impl PySetInner {
         }
         repr.push('{');
         {
-            let mut parts_iter = self.elements().into_iter().map(|o| vm.to_repr(&o));
+            let mut parts_iter = self.elements().into_iter().map(|o| o.repr(vm));
             repr.push_str(
                 parts_iter
                     .next()

vm/src/builtins/slice.rs

@@ -57,9 +57,9 @@ impl PySlice {
 
     #[pymethod(magic)]
     fn repr(&self, vm: &VirtualMachine) -> PyResult<String> {
-        let start_repr = vm.to_repr(self.start_ref(vm))?;
-        let stop_repr = vm.to_repr(&self.stop)?;
-        let step_repr = vm.to_repr(self.step_ref(vm))?;
+        let start_repr = self.start_ref(vm).repr(vm)?;
+        let stop_repr = &self.stop.repr(vm)?;
+        let step_repr = self.step_ref(vm).repr(vm)?;
 
         Ok(format!(
             "slice({}, {}, {})",

vm/src/builtins/tuple.rs

@@ -201,7 +201,7 @@ impl PyTuple {
         let s = if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
             let mut str_parts = Vec::with_capacity(zelf.elements.len());
             for elem in zelf.elements.iter() {
-                let s = vm.to_repr(elem)?;
+                let s = elem.repr(vm)?;
                 str_parts.push(s.as_str().to_owned());
             }
 

vm/src/cformat.rs

@@ -360,7 +360,7 @@ impl CFormatSpec {
         match &self.format_type {
             CFormatType::String(preconversor) => match preconversor {
                 CFormatPreconversor::Repr | CFormatPreconversor::Ascii => {
-                    let s = vm.to_repr(&obj)?;
+                    let s = obj.repr(vm)?;
                     let s = self.format_string(s.as_str().to_owned());
                     Ok(s.into_bytes())
                 }
@@ -461,7 +461,7 @@ impl CFormatSpec {
             CFormatType::String(preconversor) => {
                 let result = match preconversor {
                     CFormatPreconversor::Str => obj.str(vm)?,
-                    CFormatPreconversor::Repr | CFormatPreconversor::Ascii => vm.to_repr(&obj)?,
+                    CFormatPreconversor::Repr | CFormatPreconversor::Ascii => obj.repr(vm)?,
                     CFormatPreconversor::Bytes => {
                         return Err(vm.new_value_error(
                             "unsupported format character 'b' (0x62)".to_owned(),

vm/src/exceptions.rs

@@ -160,7 +160,8 @@ impl VirtualMachine {
                         .str(vm)
                         .unwrap_or_else(|_| PyStr::from("<element str() failed>").into_ref(vm))
                 } else {
-                    vm.to_repr(&varargs[0])
+                    varargs[0]
+                        .repr(vm)
                         .unwrap_or_else(|_| PyStr::from("<element repr() failed>").into_ref(vm))
                 };
                 vec![args0_repr]
@@ -168,7 +169,8 @@ impl VirtualMachine {
             _ => varargs
                 .iter()
                 .map(|vararg| {
-                    vm.to_repr(vararg)
+                    vararg
+                        .repr(vm)
                         .unwrap_or_else(|_| PyStr::from("<element repr() failed>").into_ref(vm))
                 })
                 .collect(),

vm/src/format.rs

@@ -893,7 +893,7 @@ fn call_object_format(
 ) -> PyResult<PyStrRef> {
     let argument = match preconversion_spec.and_then(FormatPreconversor::from_char) {
         Some(FormatPreconversor::Str) => argument.str(vm)?.into(),
-        Some(FormatPreconversor::Repr) => vm.to_repr(&argument)?.into(),
+        Some(FormatPreconversor::Repr) => argument.repr(vm)?.into(),
         Some(FormatPreconversor::Ascii) => vm.ctx.new_str(builtins::ascii(argument, vm)?).into(),
         Some(FormatPreconversor::Bytes) => vm.call_method(&argument, "decode", ())?,
         None => argument,

vm/src/frame.rs

@@ -1101,7 +1101,7 @@ impl ExecutingFrame<'_> {
                 let value = self.pop_value();
                 let value = match conversion {
                     ConversionFlag::Str => value.str(vm)?.into(),
-                    ConversionFlag::Repr => vm.to_repr(&value)?.into(),
+                    ConversionFlag::Repr => value.repr(vm)?.into(),
                     ConversionFlag::Ascii => vm.ctx.new_str(builtins::ascii(value, vm)?).into(),
                     ConversionFlag::None => value,
                 };
@@ -1354,7 +1354,7 @@ impl ExecutingFrame<'_> {
                     #[allow(clippy::collapsible_if)]
                     if for_call {
                         if map_obj.contains_key(key.clone(), vm) {
-                            let key_repr = vm.to_repr(&key)?;
+                            let key_repr = &key.repr(vm)?;
                             let msg = format!(
                                 "got multiple values for keyword argument {}",
                                 key_repr.as_str()

vm/src/protocol/object.rs

@@ -208,11 +208,14 @@ impl PyObject {
     }
 
     pub fn repr(&self, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        vm.to_repr(self)
+        vm.with_recursion("while getting the repr of an object", || {
+            let repr = vm.call_special_method(self.to_owned(), "__repr__", ())?;
+            repr.try_into_value(vm)
+        })
     }
 
     pub fn ascii(&self, vm: &VirtualMachine) -> PyResult<ascii::AsciiString> {
-        let repr = vm.to_repr(self)?;
+        let repr = self.repr(vm)?;
         let ascii = to_ascii(repr.as_str());
         Ok(ascii)
     }

vm/src/pyobject.rs

@@ -981,7 +981,7 @@ pub trait PyStructSequence: StaticType + PyClassImpl + Sized + 'static {
     #[pymethod(magic)]
     fn repr(zelf: PyRef<PyTuple>, vm: &VirtualMachine) -> PyResult<String> {
         let format_field = |(value, name): (&PyObjectRef, _)| {
-            let s = vm.to_repr(value)?;
+            let s = value.repr(vm)?;
             Ok(format!("{}={}", name, s))
         };
         let (body, suffix) =

vm/src/pyobjectrc.rs

@@ -438,7 +438,7 @@ fn print_del_error(e: PyBaseExceptionRef, zelf: &PyObject, vm: &VirtualMachine)
     // exception in del will be ignored but printed
     print!("Exception ignored in: ",);
     let del_method = zelf.get_class_attr("__del__").unwrap();
-    let repr = vm.to_repr(&del_method);
+    let repr = &del_method.repr(vm);
     match repr {
         Ok(v) => println!("{}", v.to_string()),
         Err(_) => println!("{}", del_method.class().name()),
@@ -448,7 +448,7 @@ fn print_del_error(e: PyBaseExceptionRef, zelf: &PyObject, vm: &VirtualMachine)
     let print_stack = tb_module.get_attr("print_stack", vm).unwrap();
     vm.invoke(&print_stack, ()).unwrap();
 
-    if let Ok(repr) = vm.to_repr(e.as_object()) {
+    if let Ok(repr) = e.as_object().repr(vm) {
         println!("{}", repr.as_str());
     }
 }

vm/src/stdlib/ast/gen.rs

@@ -1907,7 +1907,7 @@ impl Node for ast::Mod {
         } else {
             return Err(_vm.new_type_error(format!(
                 "expected some sort of mod, but got {}",
-                _vm.to_repr(&_object)?
+                _object.repr(_vm)?
             )));
         })
     }
@@ -2576,7 +2576,7 @@ impl Node for ast::StmtKind {
         } else {
             return Err(_vm.new_type_error(format!(
                 "expected some sort of stmt, but got {}",
-                _vm.to_repr(&_object)?
+                _object.repr(_vm)?
             )));
         })
     }
@@ -3136,7 +3136,7 @@ impl Node for ast::ExprKind {
         } else {
             return Err(_vm.new_type_error(format!(
                 "expected some sort of expr, but got {}",
-                _vm.to_repr(&_object)?
+                _object.repr(_vm)?
             )));
         })
     }
@@ -3178,7 +3178,7 @@ impl Node for ast::ExprContext {
         } else {
             return Err(_vm.new_type_error(format!(
                 "expected some sort of expr_context, but got {}",
-                _vm.to_repr(&_object)?
+                _object.repr(_vm)?
             )));
         })
     }
@@ -3212,7 +3212,7 @@ impl Node for ast::Boolop {
         } else {
             return Err(_vm.new_type_error(format!(
                 "expected some sort of boolop, but got {}",
-                _vm.to_repr(&_object)?
+                _object.repr(_vm)?
             )));
         })
     }
@@ -3334,7 +3334,7 @@ impl Node for ast::Operator {
         } else {
             return Err(_vm.new_type_error(format!(
                 "expected some sort of operator, but got {}",
-                _vm.to_repr(&_object)?
+                _object.repr(_vm)?
             )));
         })
     }
@@ -3384,7 +3384,7 @@ impl Node for ast::Unaryop {
         } else {
             return Err(_vm.new_type_error(format!(
                 "expected some sort of unaryop, but got {}",
-                _vm.to_repr(&_object)?
+                _object.repr(_vm)?
             )));
         })
     }
@@ -3482,7 +3482,7 @@ impl Node for ast::Cmpop {
         } else {
             return Err(_vm.new_type_error(format!(
                 "expected some sort of cmpop, but got {}",
-                _vm.to_repr(&_object)?
+                _object.repr(_vm)?
             )));
         })
     }
@@ -3587,7 +3587,7 @@ impl Node for ast::ExcepthandlerKind {
         } else {
             return Err(_vm.new_type_error(format!(
                 "expected some sort of excepthandler, but got {}",
-                _vm.to_repr(&_object)?
+                _object.repr(_vm)?
             )));
         })
     }
@@ -3824,7 +3824,7 @@ impl Node for ast::TypeIgnore {
         } else {
             return Err(_vm.new_type_error(format!(
                 "expected some sort of type_ignore, but got {}",
-                _vm.to_repr(&_object)?
+                _object.repr(_vm)?
             )));
         })
     }

vm/src/stdlib/builtins.rs

@@ -64,7 +64,7 @@ mod builtins {
 
     #[pyfunction]
     pub fn ascii(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<ascii::AsciiString> {
-        let repr = vm.to_repr(&obj)?;
+        let repr = obj.repr(vm)?;
         let ascii = to_ascii(repr.as_str());
         Ok(ascii)
     }
@@ -679,7 +679,7 @@ mod builtins {
 
     #[pyfunction]
     fn repr(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        vm.to_repr(&obj)
+        obj.repr(vm)
     }
 
     #[pyfunction]

vm/src/stdlib/collections.rs

@@ -276,7 +276,7 @@ mod _collections {
                 }
             }
             Err(vm.new_value_error(
-                vm.to_repr(&obj)
+                obj.repr(vm)
                     .map(|repr| format!("{} is not in deque", repr))
                     .unwrap_or_else(|_| String::new()),
             ))
@@ -410,7 +410,7 @@ mod _collections {
                 let deque = zelf.borrow_deque().clone();
                 let elements = deque
                     .iter()
-                    .map(|obj| vm.to_repr(obj))
+                    .map(|obj| obj.repr(vm))
                     .collect::<Result<Vec<_>, _>>()?;
                 let maxlen = zelf
                     .maxlen

vm/src/stdlib/io.rs

@@ -1366,7 +1366,7 @@ mod _io {
         match name {
             Some(name) => {
                 if let Some(_guard) = ReprGuard::enter(vm, obj) {
-                    vm.to_repr(&name).map(Some)
+                    name.repr(vm).map(Some)
                 } else {
                     Err(vm.new_runtime_error(format!(
                         "reentrant call inside {}.__repr__",
@@ -2385,7 +2385,7 @@ mod _io {
             use crate::types::PyComparisonOp;
             if cookie.rich_compare_bool(vm.ctx.new_int(0).as_ref(), PyComparisonOp::Lt, vm)? {
                 return Err(
-                    vm.new_value_error(format!("negative seek position {}", vm.to_repr(&cookie)?))
+                    vm.new_value_error(format!("negative seek position {}", &cookie.repr(vm)?))
                 );
             }
             drop(textio);

vm/src/stdlib/itertools.rs

@@ -307,7 +307,7 @@ mod decl {
 
         #[pymethod(magic)]
         fn repr(&self, vm: &VirtualMachine) -> PyResult<String> {
-            let mut fmt = format!("{}", vm.to_repr(&self.object)?);
+            let mut fmt = format!("{}", &self.object.repr(vm)?);
             if let Some(ref times) = self.times {
                 fmt.push_str(&format!(", {}", times.read()));
             }

vm/src/stdlib/operator.rs

@@ -457,7 +457,7 @@ mod _operator {
             let fmt = if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
                 let mut parts = Vec::with_capacity(zelf.attrs.len());
                 for part in zelf.attrs.iter() {
-                    parts.push(vm.to_repr(part.as_object())?.as_str().to_owned());
+                    parts.push(part.as_object().repr(vm)?.as_str().to_owned());
                 }
                 parts.join(", ")
             } else {
@@ -546,7 +546,7 @@ mod _operator {
             let fmt = if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
                 let mut items = Vec::with_capacity(zelf.items.len());
                 for item in zelf.items.iter() {
-                    items.push(vm.to_repr(item)?.as_str().to_owned());
+                    items.push(item.repr(vm)?.as_str().to_owned());
                 }
                 items.join(", ")
             } else {
@@ -615,11 +615,11 @@ mod _operator {
             let fmt = if let Some(_guard) = ReprGuard::enter(vm, zelf.as_object()) {
                 let args = &zelf.args.args;
                 let kwargs = &zelf.args.kwargs;
-                let mut fmt = vec![vm.to_repr(zelf.name.as_object())?.as_str().to_owned()];
+                let mut fmt = vec![zelf.name.as_object().repr(vm)?.as_str().to_owned()];
                 if !args.is_empty() {
                     let mut parts = Vec::with_capacity(args.len());
                     for v in args {
-                        parts.push(vm.to_repr(v)?.as_str().to_owned());
+                        parts.push(v.repr(vm)?.as_str().to_owned());
                     }
                     fmt.push(parts.join(", "));
                 }
@@ -627,7 +627,7 @@ mod _operator {
                 if !kwargs.is_empty() {
                     let mut parts = Vec::with_capacity(kwargs.len());
                     for (key, value) in kwargs {
-                        let value_repr = vm.to_repr(value)?;
+                        let value_repr = value.repr(vm)?;
                         parts.push(format!("{}={}", key, value_repr));
                     }
                     fmt.push(parts.join(", "));

vm/src/stdlib/os.rs

@@ -880,7 +880,7 @@ pub(super) mod _os {
             };
             if let Some(name) = name {
                 if let Some(_guard) = ReprGuard::enter(vm, &zelf) {
-                    let repr = vm.to_repr(&name)?;
+                    let repr = name.repr(vm)?;
                     Ok(format!("<{} {}>", zelf.class(), repr))
                 } else {
                     Err(vm.new_runtime_error(format!(

vm/src/stdlib/posix.rs

@@ -475,7 +475,7 @@ pub mod module {
 
         #[pymethod(magic)]
         fn repr(&self, vm: &VirtualMachine) -> PyResult<String> {
-            let sched_priority_repr = vm.to_repr(&self.sched_priority)?;
+            let sched_priority_repr = self.sched_priority.repr(vm)?;
             Ok(format!(
                 "posix.sched_param(sched_priority = {})",
                 sched_priority_repr.as_str()

vm/src/stdlib/pwd.rs

@@ -54,7 +54,7 @@ mod pwd {
         match User::from_name(name.as_str()).map_err(|err| err.into_pyexception(vm))? {
             Some(user) => Ok(Passwd::from(user)),
             None => {
-                let name_repr = vm.to_repr(name.as_object())?;
+                let name_repr = name.as_object().repr(vm)?;
                 let message = vm
                     .ctx
                     .new_str(format!("getpwnam(): name not found: {}", name_repr))

vm/src/stdlib/sre.rs

@@ -400,7 +400,7 @@ mod _sre {
                 .map(|(name, _)| name)
                 .join("|");
 
-            let pattern = vm.to_repr(&self.pattern)?;
+            let pattern = self.pattern.repr(vm)?;
             let truncated: String;
             let s = if pattern.char_len() > 200 {
                 truncated = pattern.as_str().chars().take(200).collect();
@@ -757,7 +757,7 @@ mod _sre {
                         "<re.Match object; span=({}, {}), match={}>",
                         self.regs[0].0,
                         self.regs[0].1,
-                        vm.to_repr(&self.get_slice(0, str_drive, vm).unwrap())?
+                        self.get_slice(0, str_drive, vm).unwrap().repr(vm)?
                     ))
                 })
         }

vm/src/stdlib/sys.rs

@@ -291,7 +291,7 @@ mod sys {
         // set to none to avoid recursion while printing
         vm.builtins.set_attr("_", vm.ctx.none(), vm)?;
         // TODO: catch encoding errors
-        let repr = vm.to_repr(&obj)?.into();
+        let repr = obj.repr(vm)?.into();
         builtins::print(PosArgs::new(vec![repr]), Default::default(), vm)?;
         vm.builtins.set_attr("_", obj, vm)?;
         Ok(())

vm/src/stdlib/thread.rs

@@ -260,7 +260,7 @@ pub(crate) mod _thread {
                 // TODO: sys.unraisablehook
                 let stderr = std::io::stderr();
                 let mut stderr = py_io::IoWriter(stderr.lock());
-                let repr = vm.to_repr(func.as_ref()).ok();
+                let repr = func.as_ref().repr(vm).ok();
                 let repr = repr
                     .as_ref()
                     .map_or("<object repr() failed>", |s| s.as_str());

vm/src/vm.rs

@@ -898,13 +898,6 @@ impl VirtualMachine {
         obj.unwrap_or_else(|| self.ctx.none())
     }
 
-    pub fn to_repr(&self, obj: &PyObject) -> PyResult<PyStrRef> {
-        self.with_recursion("while getting the repr of an object", || {
-            let repr = self.call_special_method(obj.to_owned(), "__repr__", ())?;
-            repr.try_into_value(self)
-        })
-    }
-
     pub fn to_index_opt(&self, obj: PyObjectRef) -> Option<PyResult<PyIntRef>> {
         match obj.downcast() {
             Ok(val) => Some(Ok(val)),