Fixed RustPython#191, fixes recursive repr() for the standard collections

Author: skinnyBat

Cargo.lock

@@ -4,3 +4,7 @@
 assert len({"a": "b"}) == 1
 assert len({"a": "b", "b": 1}) == 2
 assert len({"a": "b", "b": 1, "a" + "b": 2*2}) == 3
+
+d = {}
+d['a'] = d
+assert repr(d) == "{'a': {...}}"

tests/snippets/builtin_dict.py

@@ -38,3 +38,7 @@
     pass
 else:
     assert False, "IndexError was not raised"
+
+recursive = []
+recursive.append(recursive)
+assert repr(recursive) == "[[...]]"

tests/snippets/list.py

@@ -24,3 +24,16 @@
 assert set([1,2]) < set([1,2,3])
 assert not set([1,2]) < set([1,2])
 assert not set([1,3]) < set([1,2])
+
+
+class Hashable(object):
+    def __init__(self, obj):
+        self.obj = obj
+
+    def __repr__(self):
+        return repr(self.obj)
+
+
+recursive = set()
+recursive.add(Hashable(recursive))
+assert repr(recursive) == "{set(...)}"

tests/snippets/set.py

@@ -19,3 +19,8 @@
 
 b = (1,2,3)
 assert b.index(2) == 1
+
+recursive_list = []
+recursive = (recursive_list,)
+recursive_list.append(recursive)
+assert repr(recursive) == "([(...)],)"

tests/snippets/tuple.py

@@ -20,3 +20,4 @@ regex = "1"
 statrs = "0.10.0"
 caseless = "0.2.1"
 unicode-segmentation = "1.2.1"
+lazy_static = "^1.0.1"

vm/Cargo.toml

@@ -1085,7 +1085,7 @@ impl fmt::Debug for Frame {
         let stack_str = self
             .stack
             .iter()
-            .map(|elem| format!("\n  > {}", elem.borrow().str()))
+            .map(|elem| format!("\n  > {:?}", elem.borrow()))
             .collect::<Vec<_>>()
             .join("");
         let block_str = self
@@ -1099,9 +1099,7 @@ impl fmt::Debug for Frame {
                 PyObjectPayload::Dict { ref elements } => {
                     objdict::get_key_value_pairs_from_content(elements)
                         .iter()
-                        .map(|elem| {
-                            format!("\n  {} = {}", elem.0.borrow().str(), elem.1.borrow().str())
-                        })
+                        .map(|elem| format!("\n  {:?} = {:?}", elem.0.borrow(), elem.1.borrow()))
                         .collect::<Vec<_>>()
                         .join("")
                 }

vm/src/frame.rs

@@ -8,6 +8,8 @@
 #[macro_use]
 extern crate bitflags;
 #[macro_use]
+extern crate lazy_static;
+#[macro_use]
 extern crate log;
 // extern crate env_logger;
 extern crate num_bigint;

vm/src/lib.rs

@@ -1,7 +1,7 @@
 use super::super::pyobject::{
     PyContext, PyFuncArgs, PyObject, PyObjectPayload, PyObjectRef, PyResult, TypeProtocol,
 };
-use super::super::vm::VirtualMachine;
+use super::super::vm::{ReprGuard, VirtualMachine};
 use super::objiter;
 use super::objstr;
 use super::objtype;
@@ -158,16 +158,21 @@ fn dict_len(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 fn dict_repr(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(dict_obj, Some(vm.ctx.dict_type()))]);
 
-    let elements = get_key_value_pairs(dict_obj);
-    let mut str_parts = vec![];
-    for (key, value) in elements {
-        let s = vm.to_repr(&value)?;
-        let key_str = objstr::get_value(&key);
-        let value_str = objstr::get_value(&s);
-        str_parts.push(format!("{}: {}", key_str, value_str));
-    }
+    let s = if let Some(_guard) = ReprGuard::enter(dict_obj) {
+        let elements = get_key_value_pairs(dict_obj);
+        let mut str_parts = vec![];
+        for (key, value) in elements {
+            let key_repr = vm.to_repr(&key)?;
+            let value_repr = vm.to_repr(&value)?;
+            let key_str = objstr::get_value(&key_repr);
+            let value_str = objstr::get_value(&value_repr);
+            str_parts.push(format!("{}: {}", key_str, value_str));
+        }
 
-    let s = format!("{{{}}}", str_parts.join(", "));
+        format!("{{{}}}", str_parts.join(", "))
+    } else {
+        "{...}".to_string()
+    };
     Ok(vm.new_str(s))
 }
 

vm/src/obj/objdict.rs

@@ -1,7 +1,7 @@
 use super::super::pyobject::{
     PyContext, PyFuncArgs, PyObject, PyObjectPayload, PyObjectRef, PyResult, TypeProtocol,
 };
-use super::super::vm::VirtualMachine;
+use super::super::vm::{ReprGuard, VirtualMachine};
 use super::objbool;
 use super::objint;
 use super::objsequence::{
@@ -184,14 +184,18 @@ fn list_add(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 fn list_repr(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(o, Some(vm.ctx.list_type()))]);
 
-    let elements = get_elements(o);
-    let mut str_parts = vec![];
-    for elem in elements.iter() {
-        let s = vm.to_repr(elem)?;
-        str_parts.push(objstr::get_value(&s));
-    }
+    let s = if let Some(_guard) = ReprGuard::enter(o) {
+        let elements = get_elements(o);
+        let mut str_parts = vec![];
+        for elem in elements.iter() {
+            let s = vm.to_repr(elem)?;
+            str_parts.push(objstr::get_value(&s));
+        }
+        format!("[{}]", str_parts.join(", "))
+    } else {
+        "[...]".to_string()
+    };
 
-    let s = format!("[{}]", str_parts.join(", "));
     Ok(vm.new_str(s))
 }