InternalProperty in mirror-debugger.js and ARM experimental assert

src/mirror-debugger.js

 // Copyright 2006-2012 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 136 matching lines @@
 var UNDEFINED_TYPE = 'undefined';
 var NULL_TYPE = 'null';
 var BOOLEAN_TYPE = 'boolean';
 var NUMBER_TYPE = 'number';
 var STRING_TYPE = 'string';
 var OBJECT_TYPE = 'object';
 var FUNCTION_TYPE = 'function';
 var REGEXP_TYPE = 'regexp';
 var ERROR_TYPE = 'error';
 var PROPERTY_TYPE = 'property';
+var INTERNAL_PROPERTY_TYPE = 'internalProperty';
 var FRAME_TYPE = 'frame';
 var SCRIPT_TYPE = 'script';
 var CONTEXT_TYPE = 'context';
 var SCOPE_TYPE = 'scope';
 
 // Maximum length when sending strings through the JSON protocol.
 var kMaxProtocolStringLength = 80;
 
 // Different kind of properties.
 var PropertyKind = {};
@@ skipping 38 matching lines @@
 //       - NumberMirror
 //       - StringMirror
 //       - ObjectMirror
 //         - FunctionMirror
 //           - UnresolvedFunctionMirror
 //         - ArrayMirror
 //         - DateMirror
 //         - RegExpMirror
 //         - ErrorMirror
 //     - PropertyMirror
+//     - InternalPropertyMirror
 //     - FrameMirror
 //     - ScriptMirror
 
 
 /**
  * Base class for all mirror objects.
  * @param {string} type The type of the mirror
  * @constructor
  */
 function Mirror(type) {
@@ skipping 126 matching lines @@
 /**
  * Check whether the mirror reflects a property.
  * @returns {boolean} True if the mirror reflects a property
  */
 Mirror.prototype.isProperty = function() {
   return this instanceof PropertyMirror;
 };
 
 
 /**
+ * Check whether the mirror reflects an internal property.
+ * @returns {boolean} True if the mirror reflects an internal property
+ */
+Mirror.prototype.isInternalProperty = function() {
+  return this instanceof InternalPropertyMirror;
+};
+
+
+/**
  * Check whether the mirror reflects a stack frame.
  * @returns {boolean} True if the mirror reflects a stack frame
  */
 Mirror.prototype.isFrame = function() {
   return this instanceof FrameMirror;
 };
 
 
 /**
  * Check whether the mirror reflects a script.
@@ skipping 216 matching lines @@
 ObjectMirror.prototype.prototypeObject = function() {
   return MakeMirror(%DebugGetProperty(this.value_, 'prototype'));
 };
 
 
 ObjectMirror.prototype.protoObject = function() {
   return MakeMirror(%DebugGetPrototype(this.value_));
 };
 
 
-/**
- * Return the primitive value if this is object of Boolean, Number or String
- * type (but not Date). Otherwise return undefined.
- */
-ObjectMirror.prototype.primitiveValue = function() {
-  if (!IS_STRING_WRAPPER(this.value_) && !IS_NUMBER_WRAPPER(this.value_) &&
-      !IS_BOOLEAN_WRAPPER(this.value_)) {
-    return void 0;
-  }
-  var primitiveValue = %_ValueOf(this.value_);
-  if (IS_UNDEFINED(primitiveValue)) {
-    return void 0;
-  }
-  return MakeMirror(primitiveValue);
-};
-
-
 ObjectMirror.prototype.hasNamedInterceptor = function() {
   // Get information on interceptors for this object.
   var x = %GetInterceptorInfo(this.value_);
   return (x & 2) != 0;
 };
 
 
 ObjectMirror.prototype.hasIndexedInterceptor = function() {
   // Get information on interceptors for this object.
   var x = %GetInterceptorInfo(this.value_);
@@ skipping 70 matching lines @@
   }
 
   return names;
 };
 
 
 /**
  * Return the properties for this object as an array of PropertyMirror objects.
  * @param {number} kind Indicate whether named, indexed or both kinds of
  *     properties are requested
- * @param {number} limit Limit the number of properties returend to the
+ * @param {number} limit Limit the number of properties returned to the
        specified value
  * @return {Array} Property mirrors for this object
  */
 ObjectMirror.prototype.properties = function(kind, limit) {
   var names = this.propertyNames(kind, limit);
   var properties = new Array(names.length);
   for (var i = 0; i < names.length; i++) {
     properties[i] = this.property(names[i]);
   }
 
   return properties;
 };
 
 
+/**
+ * Return the internal properties for this object as an array of
+ * InternalPropertyMirror objects.
+ * @return {Array} Property mirrors for this object
+ */
+ObjectMirror.prototype.internalProperties = function() {
+  return ObjectMirror.GetInternalProperties(this.value_);
+}
+
+
 ObjectMirror.prototype.property = function(name) {
   var details = %DebugGetPropertyDetails(this.value_, %ToString(name));
   if (details) {
     return new PropertyMirror(this, name, details);
   }
 
   // Nothing found.
   return GetUndefinedMirror();
 };
 
@@ skipping 54 matching lines @@
     name = ctor.name();
     if (!name) {
       name = this.className();
     }
   }
   return '#<' + name + '>';
 };
 
 
 /**
+ * Return the internal properties of the value, such as [[PrimitiveValue]] of
+ * scalar wrapper objects and properties of the bound function.
+ * This method is done static to be accessible from Debug API with the bare
+ * values without mirrors.
+ * @return {Array} array (possibly empty) of InternalProperty instances
+ */
+ObjectMirror.GetInternalProperties = function(value) {
+/*
+  if (IS_STRING_WRAPPER(value) || IS_NUMBER_WRAPPER(value) ||
+      IS_BOOLEAN_WRAPPER(value)) {
+    var primitiveValue = %_ValueOf(value);
+    return [new InternalPropertyMirror("[[PrimitiveValue]]", primitiveValue)];
+  } else if (IS_FUNCTION(value)) {
+    var bindings = %BoundFunctionGetBindings(value);
+    var result = [];
+    if (bindings && IS_ARRAY(bindings)) {
+      result.push(new InternalPropertyMirror("[[TargetFunction]]",
+                                             bindings[0]));
+      result.push(new InternalPropertyMirror("[[BoundThis]]", bindings[1]));
+      var boundArgs = [];
+      for (var i = 2; i < bindings.length; i++) {
+        boundArgs.push(bindings[i]);
+      }
+      result.push(new InternalPropertyMirror("[[BoundArgs]]", boundArgs));
+    }
+    return result;
+  }
+  */
+  return [];
+}
+
+
+/**
  * Mirror object for functions.
  * @param {function} value The function object reflected by this mirror.
  * @constructor
  * @extends ObjectMirror
  */
 function FunctionMirror(value) {
   %_CallFunction(this, value, FUNCTION_TYPE, ObjectMirror);
   this.resolved_ = true;
 }
 inherits(FunctionMirror, ObjectMirror);
@@ skipping 458 matching lines @@
  * @return {boolean} True if the property is
  *     UndefinedMirror if there is no setter for this property
  */
 PropertyMirror.prototype.isNative = function() {
   return (this.propertyType() == PropertyType.Interceptor) ||
          ((this.propertyType() == PropertyType.Callbacks) &&
           !this.hasGetter() && !this.hasSetter());
 };
 
 
+/**
+ * Mirror object for internal properties. Internal property reflects properties
+ * not accessible from user code such as [[BoundThis]] in bound function.
+ * Their names are merely symbolic.
+ * @param {string} name The name of the property
+ * @param {value} property value
+ * @constructor
+ * @extends Mirror
+ */
+function InternalPropertyMirror(name, value) {
+  %_CallFunction(this, INTERNAL_PROPERTY_TYPE, Mirror);
+  this.name_ = name;
+  this.value_ = value;
+}
+inherits(InternalPropertyMirror, Mirror);
+
+
+InternalPropertyMirror.prototype.name = function() {
+  return this.name_;
+};
+
+
+InternalPropertyMirror.prototype.value = function() {
+  return MakeMirror(this.value_, false);
+};
+
+
 var kFrameDetailsFrameIdIndex = 0;
 var kFrameDetailsReceiverIndex = 1;
 var kFrameDetailsFunctionIndex = 2;
 var kFrameDetailsArgumentCountIndex = 3;
 var kFrameDetailsLocalCountIndex = 4;
 var kFrameDetailsSourcePositionIndex = 5;
 var kFrameDetailsConstructCallIndex = 6;
 var kFrameDetailsAtReturnIndex = 7;
 var kFrameDetailsFlagsIndex = 8;
 var kFrameDetailsFirstDynamicIndex = 9;
@@ skipping 750 matching lines @@
 };
 
 
 /**
  * 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) {
+JSONProtocolSerializer.prototype.serializeValue = function xSerializeValue(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 {Array.<Object>} Array of the referenced objects converted to
  *     protcol objects.
  */
-JSONProtocolSerializer.prototype.serializeReferencedObjects = function() {
+JSONProtocolSerializer.prototype.serializeReferencedObjects = function xSerializeReferencedObjects() {
   // Collect the protocol representation of the referenced objects in an array.
   var content = [];
 
   // 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));
   }
 
@@ skipping 66 matching lines @@
       o.value = mirror.toText();
       break;
     case OBJECT_TYPE:
       o.className = mirror.className();
       break;
   }
   return o;
 };
 
 
-JSONProtocolSerializer.prototype.serialize_ = function(mirror, reference,
+JSONProtocolSerializer.prototype.serialize_ = function xSerialize_(mirror, reference,
                                                        details) {
   // If serializing a reference to a mirror just return the reference and add
   // the mirror to the referenced mirrors.
   if (reference &&
       (mirror.isValue() || mirror.isScript() || mirror.isContext())) {
     if (this.inlineRefs_() && mirror.isValue()) {
       return this.serializeReferenceWithDisplayData_(mirror);
     } else {
       this.add_(mirror);
       return {'ref' : mirror.handle()};
@@ skipping 43 matching lines @@
 
     case OBJECT_TYPE:
     case FUNCTION_TYPE:
     case ERROR_TYPE:
     case REGEXP_TYPE:
       // Add object representation.
       this.serializeObject_(mirror, content, details);
       break;
 
     case PROPERTY_TYPE:
-      throw new Error('PropertyMirror cannot be serialized independeltly');
+    case INTERNAL_PROPERTY_TYPE:
+      throw new Error('PropertyMirror cannot be serialized independently');
       break;
 
     case FRAME_TYPE:
       // Add object representation.
       this.serializeFrame_(mirror, content);
       break;
 
     case SCOPE_TYPE:
       // Add object representation.
       this.serializeScope_(mirror, content);
@@ skipping 55 matching lines @@
 
 /**
  * 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>]}
+ *    "properties":[<properties>],
+ *    "internalProperties":[<internal properties>]}
  */
-JSONProtocolSerializer.prototype.serializeObject_ = function(mirror, content,
+JSONProtocolSerializer.prototype.serializeObject_ = function xSerializeObject_(mirror, content,
                                                              details) {
   // Add general object properties.
   content.className = mirror.className();
   content.constructorFunction =
       this.serializeReference(mirror.constructorFunction());
   content.protoObject = this.serializeReference(mirror.protoObject());
   content.prototypeObject = this.serializeReference(mirror.prototypeObject());
 
-  var primitiveValue = mirror.primitiveValue();
-  if (!IS_UNDEFINED(primitiveValue)) {
-    content.primitiveValue = this.serializeReference(primitiveValue);
-  }
-
   // Add flags to indicate whether there are interceptors.
   if (mirror.hasNamedInterceptor()) {
     content.namedInterceptor = true;
   }
   if (mirror.hasIndexedInterceptor()) {
     content.indexedInterceptor = true;
   }
 
   // Add function specific properties.
   if (mirror.isFunction()) {
@@ skipping 41 matching lines @@
     }
   }
   for (var i = 0; i < propertyIndexes.length; i++) {
     var propertyMirror = mirror.property(propertyIndexes[i]);
     p[propertyNames.length + i] = this.serializeProperty_(propertyMirror);
     if (details) {
       this.add_(propertyMirror.value());
     }
   }
   content.properties = p;
+
+  var internalProperties = mirror.internalProperties();
+  if (internalProperties.length > 0) {
+    var ip = [];
+    for (var i = 0; i < internalProperties.length; i++) {
+      ip.push(this.serializeInternalProperty_(internalProperties[i]));
+    }
+    content.internalProperties = ip;
+  }
 };
 
 
 /**
  * Serialize location information to the following JSON format:
  *
  *   "position":"<position>",
  *   "line":"<line>",
  *   "column":"<column>",
  *
@@ skipping 47 matching lines @@
     }
     if (propertyMirror.propertyType() != PropertyType.Normal) {
       result.propertyType = propertyMirror.propertyType();
     }
     result.ref = propertyValue.handle();
   }
   return result;
 };
 
 
+/**
+ * Serialize internal property information to the following JSON format for
+ * building the array of properties.
+ *
+ *   {"name":"<property name>",
+ *    "ref":<number>}
+ *
+ *   {"name":"[[BoundThis]]","ref":117}
+ *
+ * @param {InternalPropertyMirror} propertyMirror The property to serialize.
+ * @returns {Object} Protocol object representing the property.
+ */
+JSONProtocolSerializer.prototype.serializeInternalProperty_ =
+    function xSerializeInternalProperty_(propertyMirror) {
+  var result = {};
+
+  result.name = propertyMirror.name();
+  var propertyValue = propertyMirror.value();
+  if (this.inlineRefs_() && propertyValue.isValue()) {
+    result.value = this.serializeReferenceWithDisplayData_(propertyValue);
+  } else {
+    result.ref = propertyValue.handle();
+  }
+  return result;
+};
+
+
 JSONProtocolSerializer.prototype.serializeFrame_ = function(mirror, content) {
   content.index = mirror.index();
   content.receiver = this.serializeReference(mirror.receiver());
   var func = mirror.func();
   content.func = this.serializeReference(func);
   if (func.script()) {
     content.script = this.serializeReference(func.script());
   }
   content.constructCall = mirror.isConstructCall();
   content.atReturn = mirror.isAtReturn();
@@ skipping 62 matching lines @@
   }
   if (!NUMBER_IS_FINITE(value)) {
     if (value > 0) {
       return 'Infinity';
     } else {
       return '-Infinity';
     }
   }
   return value;
 }