Added handles to the mirror objects. When a mirror for an object is created...

src/mirror-delay.js

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 15 matching lines @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Touch the RegExp and Date functions to make sure that date-delay.js and
 // regexp-delay.js has been loaded. This is required as the mirrors use
 // functions within these files through the builtins object. See the
 // function DateToISO8601_ as an example.
 RegExp;
 Date;
 
 
+var next_handle_ = 0;
+var mirror_cache_ = [];
+
+/**
+ * Clear the mirror handle cache.
+ */
+function ClearMirrorCache() {
+  next_handle_ = 0;
+  mirror_cache_ = [];
+}
+
+
 /**
  * Returns the mirror for a specified value or object.
  *
  * @param {value or Object} value the value or object to retreive the mirror for
  * @returns {Mirror} the mirror reflects the passed value or object
  */
 function MakeMirror(value) {
-  if (IS_UNDEFINED(value)) return new UndefinedMirror();
-  if (IS_NULL(value)) return new NullMirror();
-  if (IS_BOOLEAN(value)) return new BooleanMirror(value);
-  if (IS_NUMBER(value)) return new NumberMirror(value);
-  if (IS_STRING(value)) return new StringMirror(value);
-  if (IS_ARRAY(value)) return new ArrayMirror(value);
-  if (IS_DATE(value)) return new DateMirror(value);
-  if (IS_FUNCTION(value)) return new FunctionMirror(value);
-  if (IS_REGEXP(value)) return new RegExpMirror(value);
-  if (IS_ERROR(value)) return new ErrorMirror(value);
-  return new ObjectMirror(value);
+  var mirror;
+  for (id in mirror_cache_) {
+    mirror = mirror_cache_[id];
+    if (mirror.value() === value) {
+      return mirror;
+    }
+  }
+  
+  if (IS_UNDEFINED(value)) {
+    mirror = new UndefinedMirror();
+  } else if (IS_NULL(value)) {
+    mirror = new NullMirror();
+  } else if (IS_BOOLEAN(value)) {
+    mirror = new BooleanMirror(value);
+  } else if (IS_NUMBER(value)) {
+    mirror = new NumberMirror(value);
+  } else if (IS_STRING(value)) {
+    mirror = new StringMirror(value);
+  } else if (IS_ARRAY(value)) {
+    mirror = new ArrayMirror(value);
+  } else if (IS_DATE(value)) {
+    mirror = new DateMirror(value);
+  } else if (IS_FUNCTION(value)) {
+    mirror = new FunctionMirror(value);
+  } else if (IS_REGEXP(value)) {
+    mirror = new RegExpMirror(value);
+  } else if (IS_ERROR(value)) {
+    mirror = new ErrorMirror(value);
+  } else {
+    mirror = new ObjectMirror(value);
+  }
+
+  mirror_cache_[mirror.handle()] = mirror;
+  return mirror;
+}
+
+
+/**
+ * Returns the mirror for the undefined value.
+ *
+ * @returns {Mirror} the mirror reflects the undefined value
+ */
+function GetUndefinedMirror() {
+  return MakeMirror(void 0);
 }
 
 
 /**
  * Inherit the prototype methods from one constructor into another.
  *
  * The Function.prototype.inherits from lang.js rewritten as a standalone
  * function (not on Function.prototype). NOTE: If this file is to be loaded
  * during bootstrapping this function needs to be revritten using some native
  * functions as prototype setup using normal JavaScript does not work as
@@ skipping 16 matching lines @@
 const UNDEFINED_TYPE = 'undefined';
 const NULL_TYPE = 'null';
 const BOOLEAN_TYPE = 'boolean';
 const NUMBER_TYPE = 'number';
 const STRING_TYPE = 'string';
 const OBJECT_TYPE = 'object';
 const FUNCTION_TYPE = 'function';
 const REGEXP_TYPE = 'regexp';
 const ERROR_TYPE = 'error';
 const PROPERTY_TYPE = 'property';
-const ACCESSOR_TYPE = 'accessor';
 const FRAME_TYPE = 'frame';
 const SCRIPT_TYPE = 'script';
 
 // Maximum length when sending strings through the JSON protocol.
 const kMaxProtocolStringLength = 80;
 
 // Different kind of properties.
 PropertyKind = {};
 PropertyKind.Named   = 1;
 PropertyKind.Indexed = 2;
@@ skipping 47 matching lines @@
   this.type_ = type;
 };
 
 
 Mirror.prototype.type = function() {
   return this.type_;
 };
 
 
 /**
+ * Check whether the mirror reflects a value.
+ * @returns {boolean} True if the mirror reflects a value.
+ */
+Mirror.prototype.isValue = function() {
+  return this instanceof ValueMirror;
+}
+
+
+/**
  * Check whether the mirror reflects the undefined value.
  * @returns {boolean} True if the mirror reflects the undefined value.
  */
 Mirror.prototype.isUndefined = function() {
   return this instanceof UndefinedMirror;
 }
 
 
 /**
  * Check whether the mirror reflects the null value.
@@ skipping 114 matching lines @@
 
 /**
  * Check whether the mirror reflects a script.
  * @returns {boolean} True if the mirror reflects a script
  */
 Mirror.prototype.isScript = function() {
   return this instanceof ScriptMirror;
 }
 
 
-/**
- * Serialize object in JSON format. The actual serialization is handled by the
- * JSONProtocolSerializer.
- * @param {boolean} details Indicate level of details to include
- * @return {string} JSON serialization
- */
-Mirror.prototype.toJSONProtocol = function(details) {
-  var serializer = new JSONProtocolSerializer(details)
-  return serializer.serialize(this)
-}
-
-
 Mirror.prototype.toText = function() {
   // Simpel to text which is used when on specialization in subclass.
   return "#<" + builtins.GetInstanceName(this.constructor.name) + ">";
 }
 
 
 /**
  * Base class for all value mirror objects.
  * @param {string} type The type of the mirror
  * @param {value} value The value reflected by this mirror
  * @constructor
  * @extends Mirror
  */
 function ValueMirror(type, value) {
   Mirror.call(this, type);
+  this.handle_ = next_handle_++;
   this.value_ = value;
 }
 inherits(ValueMirror, Mirror);
 
 
+Mirror.prototype.handle = function() {
+  return this.handle_;
+};
+
+
 /**
  * Check whether this is a primitive value.
  * @return {boolean} True if the mirror reflects a primitive value
  */
 ValueMirror.prototype.isPrimitive = function() {
   var type = this.type();
   return type === 'undefined' ||
          type === 'null' ||
          type === 'boolean' ||
          type === 'number' ||
          type === 'string';
 };
 
 
- /**
+/**
  * Get the actual value reflected by this mirror.
  * @return {value} The value reflected by this mirror
  */
 ValueMirror.prototype.value = function() {
   return this.value_;
 };
 
 
 /**
  * Mirror object for Undefined.
@@ skipping 225 matching lines @@
 };
 
 
 ObjectMirror.prototype.property = function(name) {
   var details = %DebugGetPropertyDetails(this.value_, %ToString(name));
   if (details) {
     return new PropertyMirror(this, name, details);
   }
 
   // Nothing found.
-  return new UndefinedMirror();
+  return GetUndefinedMirror();
 };
 
 
 
 /**
  * Try to find a property from its value.
  * @param {Mirror} value The property value to look for
  * @return {PropertyMirror} The property with the specified value. If no
  *     property was found with the specified value UndefinedMirror is returned
  */
 ObjectMirror.prototype.lookupProperty = function(value) {
   var properties = this.properties();
 
   // Look for property value in properties.
   for (var i = 0; i < properties.length; i++) {
 
     // Skip properties which are defined through assessors.
     var property = properties[i];
     if (property.propertyType() != PropertyType.Callbacks) {
       if (%_ObjectEquals(property.value_, value.value_)) {
         return property;
       }
     }
   }
 
   // Nothing found.
-  return new UndefinedMirror();
+  return GetUndefinedMirror();
 };
 
 
 /**
  * Returns objects which has direct references to this object
  * @param {number} opt_max_instances Optional parameter specifying the maximum
  *     number of instances to return.
  * @return {Array} The objects which has direct references to this object.
  */
 ObjectMirror.prototype.referencedBy = function(opt_max_instances) {
@@ skipping 58 matching lines @@
 
 /**
  * Returns the source code for the function.
  * @return {string or undefined} The source code for the function. If the
  *     function is not resolved undefined will be returned.
  */
 FunctionMirror.prototype.source = function() {
   // Return source if function is resolved. Otherwise just fall through to
   // return undefined.
   if (this.resolved()) {
-    // This builtins function is context independant (only uses runtime
-    // calls and typeof.
     return builtins.FunctionSourceString(this.value_);
   }
 };
 
 
 /**
  * Returns the script object for the function.
  * @return {ScriptMirror or undefined} Script object for the function or
  *     undefined if the function has no script
  */
@@ skipping 54 matching lines @@
 }
 inherits(UnresolvedFunctionMirror, FunctionMirror);
 
 
 UnresolvedFunctionMirror.prototype.className = function() {
   return 'Function';
 };
 
 
 UnresolvedFunctionMirror.prototype.constructorFunction = function() {
-  return new UndefinedMirror();
+  return GetUndefinedMirror();
 };
 
 
 UnresolvedFunctionMirror.prototype.prototypeObject = function() {
-  return new UndefinedMirror();
+  return GetUndefinedMirror();
 };
 
 
 UnresolvedFunctionMirror.prototype.protoObject = function() {
-  return new UndefinedMirror();
+  return GetUndefinedMirror();
 };
 
 
 UnresolvedFunctionMirror.prototype.name = function() {
   return this.value_;
 };
 
 
 UnresolvedFunctionMirror.prototype.propertyNames = function(kind, limit) {
   return [];
@@ skipping 21 matching lines @@
   var from_index = opt_from_index || 0;
   var to_index = opt_to_index || this.length() - 1;
   if (from_index > to_index) return new Array();
   var values = new Array(to_index - from_index + 1);
   for (var i = from_index; i <= to_index; i++) {
     var details = %DebugGetPropertyDetails(this.value_, %ToString(i));
     var value;
     if (details) {
       value = new PropertyMirror(this, i, details);
     } else {
-      value = new UndefinedMirror();
+      value = GetUndefinedMirror();
     }
     values[i - from_index] = value;
   }
   return values;
 }
 
 
 /**
  * Mirror object for dates.
  * @param {Date} value The Date object reflected by this mirror
@@ skipping 389 matching lines @@
 
 
 FrameMirror.prototype.func = function() {
   // Get the function for this frame from the VM.
   var f = this.details_.func();
   
   // Create a function mirror. NOTE: MakeMirror cannot be used here as the
   // value returned from the VM might be a string if the function for the
   // frame is unresolved.
   if (IS_FUNCTION(f)) {
-    return new FunctionMirror(f);
+    return MakeMirror(f);
   } else {
     return new UnresolvedFunctionMirror(f);
   }
 };
 
 
 FrameMirror.prototype.receiver = function() {
   return MakeMirror(this.details_.receiver());
 };
 
@@ skipping 99 matching lines @@
   } else if (this.isDebuggerFrame()) {
     result += '[debugger]';
   } else {
     // If the receiver has a className which is 'global' don't display it.
     var display_receiver = !receiver.className || receiver.className() != 'global';
     if (display_receiver) {
       result += receiver.toText();
     }
     // Try to find the function as a property in the receiver. Include the
     // prototype chain in the lookup.
-    var property = new UndefinedMirror();
+    var property = GetUndefinedMirror();
     if (!receiver.isUndefined()) {
       for (var r = receiver; !r.isNull() && property.isUndefined(); r = r.protoObject()) {
         property = r.lookupProperty(func);
       }
     }
     if (!property.isUndefined()) {
       // The function invoked was found on the receiver. Use the property name
       // for the backtrace.
       if (!property.isIndexed()) {
         if (display_receiver) {
@@ skipping 160 matching lines @@
     result += '-';
     result += this.lineOffset() + this.lineCount() - 1;
   } else {
     result += this.lineCount();
   }
   result += ')';
   return result;
 }
 
 
-function JSONProtocolSerializer(details) {
-  this.details_ = details;
+/**
+ * Returns a mirror serializer
+ *
+ * @param {boolean} details Set to true to include details
+ * @returns {MirrorSerializer} mirror serializer
+ */
+function MakeMirrorSerializer(details) {
+  return new JSONProtocolSerializer(details);
 }
 
 
-JSONProtocolSerializer.prototype.serialize = function(mirror) {
-  // Collect the JSON property/value pairs in a array.
+/**
+ * Object for serializing a mirror objects and its direct references.
+ * @param {boolean} details Indicates whether to include details for the mirror
+ *     serialized
+ * @constructor
+ */
+function JSONProtocolSerializer(details) {
+  this.details_ = details;
+  this.mirrors_ = [ ];
+}
+
+
+/**
+ * Returns a serialization of an object reference. The referenced object are
+ * added to the serialization state.
+ *
+ * @param {Mirror} mirror The mirror to serialize
+ * @returns {String} JSON serialization
+ */
+JSONProtocolSerializer.prototype.serializeReference = function(mirror) {
+  return this.serialize_(mirror, true, true);
+}
+
+
+/**
+ * Returns a serialization of an object value. The referenced objects are
+ * added to the serialization state.
+ *
+ * @param {Mirror} mirror The mirror to serialize
+ * @returns {String} JSON serialization
+ */
+JSONProtocolSerializer.prototype.serializeValue = function(mirror) {
+  var json = this.serialize_(mirror, false, true);
+  return json;
+}
+
+
+/**
+ * Returns a serialization of all the objects referenced.
+ *
+ * @param {Mirror} mirror The mirror to serialize
+ * @returns {String} JSON serialization
+ */
+JSONProtocolSerializer.prototype.serializeReferencedObjects = function() {
+  // Collect the JSON serialization of the referenced objects in an array.
+  var content = new Array();
+  
+  // Get the number of referenced objects.
+  var count = this.mirrors_.length;
+  
+  for (var i = 0; i < count; i++) {
+    content.push(this.serialize_(this.mirrors_[i], false, false));
+  }
+
+  var json = ArrayToJSONArray_(content);
+  return json;
+}
+
+
+JSONProtocolSerializer.prototype.add_ = function(mirror) {
+  // If this mirror is already in the list just return.
+  for (var i = 0; i < this.mirrors_.length; i++) {
+    if (this.mirrors_[i] === mirror) {
+      return;
+    }
+  }
+  
+  // Add the mirror to the list of mirrors to be serialized.
+  this.mirrors_.push(mirror);
+}
+
+
+JSONProtocolSerializer.prototype.serialize_ = function(mirror, reference,
+                                                       details) {
+  // If serializing a reference to a value just return the reference and add the
+  // mirror to the referenced mirrors.
+  if (reference && mirror.isValue()) {
+    this.add_(mirror);
+    return '{ref:' + mirror.handle() + '}';
+  }
+  
+  // Collect the JSON property/value pairs in an array.
   var content = new Array();
 
-  // Always add the type  
+  // Add the handle for value mirrors.
+  if (mirror.isValue()) {
+    content.push(MakeJSONPair_('handle', NumberToJSON_(mirror.handle())));
+  }
+
+  // Always add the type.
   content.push(MakeJSONPair_('type', StringToJSON_(mirror.type())));
 
   switch (mirror.type()) {
     case UNDEFINED_TYPE:
     case NULL_TYPE:
       // Undefined and null are represented just by their type.
       break;
 
     case BOOLEAN_TYPE:
       // Boolean values are simply represented by their value.
@@ skipping 17 matching lines @@
         content.push(MakeJSONPair_('value', StringToJSON_(mirror.value())));
       }
       content.push(MakeJSONPair_('length', NumberToJSON_(mirror.length())));
       break;
 
     case OBJECT_TYPE:
     case FUNCTION_TYPE:
     case ERROR_TYPE:
     case REGEXP_TYPE:
       // Add object representation.
-      this.serializeObject_(mirror, content);
+      this.serializeObject_(mirror, content, details);
       break;
 
     case PROPERTY_TYPE:
-      // Properties are represented by name, value, attributes and type.
-      content.push(MakeJSONPair_('name',
-                                 StringToJSON_(mirror.name())));
-      content.push(MakeJSONPair_('value',
-                                 mirror.value().toJSONProtocol(this.details_)));
-      if (mirror.attributes() != PropertyAttribute.None) {
-        content.push(MakeJSONPair_('attributes',
-                                   NumberToJSON_(mirror.attributes())));
-      }
-      if (mirror.propertyType() != PropertyType.Normal) {
-        content.push(MakeJSONPair_('propertyType',
-                                   NumberToJSON_(mirror.propertyType())));
-      }
-      break;
-
-    case ACCESSOR_TYPE:
-      // An accessor can either be native or defined through JavaScript.
-      if (mirror.isNative()) {
-        content.push(MakeJSONPair_('native', BooleanToJSON_(true)));
-      } else {
-        content.push(MakeJSONPair_('getter',
-                                   mirror.getter().toJSONProtocol(false)));
-        content.push(MakeJSONPair_('setter',
-                                   mirror.setter().toJSONProtocol(false)));
-      }
+      throw new Error('PropertyMirror cannot be serialized independeltly')
       break;
 
     case FRAME_TYPE:
       // Add object representation.
       this.serializeFrame_(mirror, content);
       break;
 
     case SCRIPT_TYPE:
       // Script is represented by name and source attributes.
       if (mirror.name()) {
         content.push(MakeJSONPair_('name', StringToJSON_(mirror.name())));
       }
       content.push(MakeJSONPair_('lineOffset',
                                  NumberToJSON_(mirror.lineOffset())));
       content.push(MakeJSONPair_('columnOffset',
                                  NumberToJSON_(mirror.columnOffset())));
       content.push(MakeJSONPair_('lineCount',
                                  NumberToJSON_(mirror.lineCount())));
       content.push(MakeJSONPair_('scriptType',
                                  NumberToJSON_(mirror.scriptType())));
       break;
-
   }
 
   // Always add the text representation.
   content.push(MakeJSONPair_('text', StringToJSON_(mirror.toText())));
   
   // Create and return the JSON string.
   return ArrayToJSONObject_(content);
 }
 
 
-JSONProtocolSerializer.prototype.serializeObject_ = function(mirror, content) {
+/**
+ * Serialize object information to the following JSON format.
+ *
+ *   {"className":"<class name>",
+ *    "constructorFunction":{"ref":<number>},
+ *    "protoObject":{"ref":<number>},
+ *    "prototypeObject":{"ref":<number>},
+ *    "namedInterceptor":<boolean>,
+ *    "indexedInterceptor":<boolean>,
+ *    "properties":[<properties>]}
+ */
+JSONProtocolSerializer.prototype.serializeObject_ = function(mirror, content,
+                                                             details) {
+  // Add general object properties.
   content.push(MakeJSONPair_('className',
                              StringToJSON_(mirror.className())));
+  content.push(MakeJSONPair_('constructorFunction',
+      this.serializeReference(mirror.constructorFunction())));
+  content.push(MakeJSONPair_('protoObject',
+      this.serializeReference(mirror.protoObject())));
+  content.push(MakeJSONPair_('prototypeObject',
+      this.serializeReference(mirror.prototypeObject())));
 
-  if (this.details_) {
-    content.push(MakeJSONPair_('constructorFunction',
-        mirror.constructorFunction().toJSONProtocol(false)));
-    content.push(MakeJSONPair_('protoObject',
-                               mirror.protoObject().toJSONProtocol(false)));
-    content.push(MakeJSONPair_('prototypeObject',
-                               mirror.prototypeObject().toJSONProtocol(false)));
-
-    // Add properties. For arrays don't include indexed proeprties.
-    var kind = PropertyKind.Named;
-    if (!mirror.isArray()) {
-      kind |= PropertyKind.Indexed
-    }
-    var propertyNames = mirror.propertyNames(kind);
-    var x = new Array(propertyNames.length);
-    for (var i = 0; i < propertyNames.length; i++) {
-      x[i] = mirror.property(propertyNames[i]).toJSONProtocol(false);
-    }
-    content.push(MakeJSONPair_('properties', ArrayToJSONArray_(x)));
-
-    // For arrays the indexed properties are added separately and the length is
-    // added as well.
-    if (mirror.isArray()) {
-      var propertyNames = mirror.propertyNames(PropertyKind.Indexed);
-      var x = new Array(propertyNames.length);
-      for (var i = 0; i < propertyNames.length; i++) {
-        x[i] = mirror.property(propertyNames[i]).toJSONProtocol(false);
-      }
-      content.push(MakeJSONPair_('indexedProperties', ArrayToJSONArray_(x)));
-
-      // Add the array length.
-      content.push(MakeJSONPair_('length', NumberToJSON_(mirror.length())));
-    }
-  }
-
+  // Add flags to indicate whether there are interceptors.
   if (mirror.hasNamedInterceptor()) {
     content.push(MakeJSONPair_('namedInterceptor', BooleanToJSON_(true)));
   }
-
   if (mirror.hasIndexedInterceptor()) {
     content.push(MakeJSONPair_('indexedInterceptor', BooleanToJSON_(true)));
   }
   
+  // Add function specific properties.
   if (mirror.isFunction()) {
     // Add function specific properties.
     content.push(MakeJSONPair_('name', StringToJSON_(mirror.name())));
     content.push(MakeJSONPair_('resolved', BooleanToJSON_(mirror.resolved())));
-    if (this.details_ && mirror.resolved()) {
+    if (mirror.resolved()) {
       content.push(MakeJSONPair_('source', StringToJSON_(mirror.source())));
     }
     if (mirror.script()) {
-      content.push(MakeJSONPair_('script', mirror.script().toJSONProtocol()));
+      content.push(MakeJSONPair_('script', this.serializeValue(mirror.script())));
     }
-  } else if (mirror.isDate()) {
+  }
+
+  // Add date specific properties.
+  if (mirror.isDate()) {
     // Add date specific properties.
     content.push(MakeJSONPair_('value', DateToJSON_(mirror.value())));
-  } else if (mirror.isRegExp()) {
-    // Add regexp specific properties.
-    content.push(MakeJSONPair_('source', StringToJSON_(mirror.source())));
-    content.push(MakeJSONPair_('global', BooleanToJSON_(mirror.global())));
-    content.push(MakeJSONPair_('ignoreCase',
-                               BooleanToJSON_(mirror.ignoreCase())));
-    content.push(MakeJSONPair_('multiline',
-                               BooleanToJSON_(mirror.multiline())));
-  } else if (mirror.isError()) {
-    // Add error specific properties.
-    content.push(MakeJSONPair_('message', StringToJSON_(mirror.message())));
   }
+
+  // Add actual properties - named properties followed by indexed properties.
+  var propertyNames = mirror.propertyNames(PropertyKind.Named);
+  var propertyIndexes = mirror.propertyNames(PropertyKind.Indexed);
+  var p = new Array(propertyNames.length + propertyIndexes.length);
+  for (var i = 0; i < propertyNames.length; i++) {
+    var property_mirror = mirror.property(propertyNames[i]);
+    p[i] = this.serializeProperty_(property_mirror);
+    if (details) {
+      this.add_(property_mirror.value());
+    }
+  }
+  for (var i = 0; i < propertyIndexes.length; i++) {
+    var property_mirror = mirror.property(propertyIndexes[i]);
+    p[propertyNames.length + i] = this.serializeProperty_(property_mirror);
+    if (details) {
+      this.add_(property_mirror.value());
+    }
+  }
+  content.push(MakeJSONPair_('properties', ArrayToJSONArray_(p)));
+}
+
+
+/**
+ * Serialize property information to the following JSON format for building the
+ * array of properties.
+ *
+ *   {"name":"<property name>",
+ *    "attributes":<number>,
+ *    "propertyType":<number>,
+ *    "ref":<number>}
+ *
+ * If the attribute for the property is PropertyAttribute.None it is not added.
+ * If the propertyType for the property is PropertyType.Normal it is not added.
+ * Here are a couple of examples.
+ *
+ *   {"name":"hello","ref":1}
+ *   {"name":"length","attributes":7,"propertyType":3,"ref":2}
+ *
+ * @param {PropertyMirror} property_mirror The property to serialize
+ * @returns {String} JSON serialization
+ */
+JSONProtocolSerializer.prototype.serializeProperty_ = function(property_mirror) {
+  var builder = new builtins.StringBuilder();
+  builder.add('{"name":');
+  builder.add(StringToJSON_(property_mirror.name()));
+  if (property_mirror.attributes() != PropertyAttribute.None) {
+    builder.add(',"attributes":');
+    builder.add(NumberToJSON_(property_mirror.attributes()));
+  }
+  if (property_mirror.propertyType() != PropertyType.Normal) {
+    builder.add(',"propertyType":');
+    builder.add(NumberToJSON_(property_mirror.propertyType()));
+  }
+  builder.add(',"ref":');
+  builder.add(NumberToJSON_(property_mirror.value().handle()));
+  builder.add('}');
+  return builder.generate();
 }
 
 
 JSONProtocolSerializer.prototype.serializeFrame_ = function(mirror, content) {
   content.push(MakeJSONPair_('index', NumberToJSON_(mirror.index())));
   content.push(MakeJSONPair_('receiver',
-                             mirror.receiver().toJSONProtocol(false)));
-  content.push(MakeJSONPair_('func', mirror.func().toJSONProtocol(false)));
+                             this.serializeReference(mirror.receiver())));
+  content.push(MakeJSONPair_('func', this.serializeReference(mirror.func())));
   content.push(MakeJSONPair_('constructCall',
                              BooleanToJSON_(mirror.isConstructCall())));
   content.push(MakeJSONPair_('debuggerFrame',
                              BooleanToJSON_(mirror.isDebuggerFrame())));
   var x = new Array(mirror.argumentCount());
   for (var i = 0; i < mirror.argumentCount(); i++) {
     arg = new Array();
     var argument_name = mirror.argumentName(i)
     if (argument_name) {
       arg.push(MakeJSONPair_('name', StringToJSON_(argument_name)));
     }
     arg.push(MakeJSONPair_('value',
-                           mirror.argumentValue(i).toJSONProtocol(false)));
+                           this.serializeReference(mirror.argumentValue(i))));
     x[i] = ArrayToJSONObject_(arg);
   }
   content.push(MakeJSONPair_('arguments', ArrayToJSONArray_(x)));
   var x = new Array(mirror.localCount());
   for (var i = 0; i < mirror.localCount(); i++) {
     var name = MakeJSONPair_('name', StringToJSON_(mirror.localName(i)));
     var value = MakeJSONPair_('value',
-                              mirror.localValue(i).toJSONProtocol(false));
+                              this.serializeReference(mirror.localValue(i)));
     x[i] = '{' + name + ',' + value + '}';
   }
   content.push(MakeJSONPair_('locals', ArrayToJSONArray_(x)));
   content.push(MakeJSONPair_('position',
                              NumberToJSON_(mirror.sourcePosition())));
   var line = mirror.sourceLine();
   if (!IS_UNDEFINED(line)) {
     content.push(MakeJSONPair_('line', NumberToJSON_(line)));
   }
   var column = mirror.sourceColumn();
@@ skipping 112 matching lines @@
 /**
  * Convert a Date to ISO 8601 format. To avoid depending on the Date object
  * this method calls the functions in date.js directly and not through the
  * value.
  * @param {Date} value The Date value to format as JSON
  * @return {string} JSON formatted Date value
  */
 function DateToJSON_(value) {
   return '"' + DateToISO8601_(value) + '"';
 }