Implement Display for Objects

src/lib/js/value.rs

@@ -8,6 +8,7 @@ use gc_derive::{Finalize, Trace};
 use serde_json::{map::Map, Number as JSONNumber, Value as JSONValue};
 use std::{
     any::Any,
+    collections::HashSet,
     f64::NAN,
     fmt::{self, Display},
     ops::{Add, BitAnd, BitOr, BitXor, Deref, DerefMut, Div, Mul, Not, Rem, Shl, Shr, Sub},
@@ -572,7 +573,7 @@ impl Default for ValueData {
 
 impl Display for ValueData {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
+        match self {
             ValueData::Null => write!(f, "null"),
             ValueData::Undefined => write!(f, "undefined"),
             ValueData::Boolean(v) => write!(f, "{}", v),
@@ -587,7 +588,99 @@ impl Display for ValueData {
                     _ => v.to_string(),
                 }
             ),
-            ValueData::Object(_) => write!(f, "{{}}"),
+            v @ ValueData::Object(_) => {
+                // A simple helper for getting the address of a value
+                // TODO: Find a more general place for this, as it can be used in other situations as well
+                fn address_of<T>(t: &T) -> usize {
+                    let my_ptr: *const T = t;
+                    my_ptr as usize
+                }
+
+                // We keep track of which objects we have encountered by keeping their
+                // in-memory address in this set
+                let mut encounters = HashSet::new();
+
+                fn display_obj(
+                    data: &ValueData,
+                    encounters: &mut HashSet<usize>,
+                    indent: usize,
+                ) -> String {
+                    match *data {
+                        ValueData::Object(ref v) => {
+                            // The in-memory address of the current object
+                            let addr = address_of(v.borrow().deref());
+
+                            // We need not continue if this object has already been
+                            // printed up the current chain
+                            if encounters.contains(&addr) {
+                                return String::from("'[Cycle]'");
+                            }
+
+                            // Mark the current object as encountered
+                            encounters.insert(addr);
+
+                            // Each time we print a nested object we need to increment the
+                            // indentation size in order to pretty print
+                            let indentation = String::from_utf8(vec![b' '; indent])
+                                .expect("Could not create indentation string");
+
+                            let properties = v
+                                .borrow()
+                                .properties
+                                .iter()
+                                .map(|(key, val)| {
+                                    let v = &val
+                                        .value
+                                        .as_ref()
+                                        .expect("Could not get the property's value");
+
+                                    format!(
+                                        "{}{}: {}",
+                                        indentation,
+                                        key,
+                                        display_obj(v, encounters, indent.wrapping_add(4))
+                                    )
+                                })
+                                .collect::<Vec<String>>()
+                                .join(",\n");
+
+                            let internal_slots = v
+                                .borrow()
+                                .internal_slots
+                                .iter()
+                                .map(|(key, val)| {
+                                    format!(
+                                        "{}{}: {}",
+                                        indentation,
+                                        key,
+                                        display_obj(&val, encounters, indent.wrapping_add(4))
+                                    )
+                                })
+                                .collect::<Vec<String>>()
+                                .join(",\n");
+
+                            // If the current object is referenced in a different branch,
+                            // it will not cause an infinte printing loop, so it is safe to be printed again
+                            encounters.remove(&addr);
+
+                            let closing_indent =
+                                String::from_utf8(vec![b' '; indent.wrapping_sub(4)]).expect(
+                                    "Could not create the closing brace's indentation string",
+                                );
+
+                            format!(
+                                "{{\n{}\n{}\n{}}}",
+                                properties, internal_slots, closing_indent
+                            )
+                        }
+
+                        // Every other type of data is printed as is
+                        _ => format!("{}", data),
+                    }
+                }
+
+                write!(f, "{}", display_obj(&v, &mut encounters, 4))
+            }
             ValueData::Integer(v) => write!(f, "{}", v),
             ValueData::Function(ref v) => match *v.borrow() {
                 Function::NativeFunc(_) => write!(f, "function() {{ [native code] }}"),