Make sure that the name accessor on functions return the expected...

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 320 matching lines @@
 /**
  * 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.value_ = value;
-};
+}
 inherits(ValueMirror, Mirror);
 
 
 /**
  * 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' ||
@@ skipping 13 matching lines @@
 };
 
 
 /**
  * Mirror object for Undefined.
  * @constructor
  * @extends ValueMirror
  */
 function UndefinedMirror() {
   ValueMirror.call(this, UNDEFINED_TYPE, void 0);
-};
+}
 inherits(UndefinedMirror, ValueMirror);
 
 
 UndefinedMirror.prototype.toText = function() {
   return 'undefined';
 }
 
 
 /**
  * Mirror object for null.
  * @constructor
  * @extends ValueMirror
  */
 function NullMirror() {
   ValueMirror.call(this, NULL_TYPE, null);
-};
+}
 inherits(NullMirror, ValueMirror);
 
 
 NullMirror.prototype.toText = function() {
   return 'null';
 }
 
 
 /**
  * Mirror object for boolean values.
  * @param {boolean} value The boolean value reflected by this mirror
  * @constructor
  * @extends ValueMirror
  */
 function BooleanMirror(value) {
   ValueMirror.call(this, BOOLEAN_TYPE, value);
-};
+}
 inherits(BooleanMirror, ValueMirror);
 
 
 BooleanMirror.prototype.fillJSON_ = function(content, details) {
   BooleanMirror.super_.fillJSONType_.call(this, content);
   content.push(MakeJSONPair_('value', BooleanToJSON_(this.value_)));
 }
 
 
 BooleanMirror.prototype.toText = function() {
   return this.value_ ? 'true' : 'false';
 }
 
 
 /**
  * Mirror object for number values.
  * @param {number} value The number value reflected by this mirror
  * @constructor
  * @extends ValueMirror
  */
 function NumberMirror(value) {
   ValueMirror.call(this, NUMBER_TYPE, value);
-};
+}
 inherits(NumberMirror, ValueMirror);
 
 
 NumberMirror.prototype.fillJSON_ = function(content, details) {
   NumberMirror.super_.fillJSONType_.call(this, content);
   content.push(MakeJSONPair_('value', NumberToJSON_(this.value_)));
 }
 
 
 NumberMirror.prototype.toText = function() {
   return %NumberToString(this.value_);
 }
 
 
 /**
  * Mirror object for string values.
  * @param {string} value The string value reflected by this mirror
  * @constructor
  * @extends ValueMirror
  */
 function StringMirror(value) {
   ValueMirror.call(this, STRING_TYPE, value);
-};
+}
 inherits(StringMirror, ValueMirror);
 
 
 StringMirror.prototype.length = function() {
   return this.value_.length;
 };
 
 
 StringMirror.prototype.fillJSON_ = function(content, details) {
   StringMirror.super_.fillJSONType_.call(this, content);
@@ skipping 21 matching lines @@
 
 
 /**
  * Mirror object for objects.
  * @param {object} value The object reflected by this mirror
  * @constructor
  * @extends ValueMirror
  */
 function ObjectMirror(value, type) {
   ValueMirror.call(this, type || OBJECT_TYPE, value);
-};
+}
 inherits(ObjectMirror, ValueMirror);
 
 
 ObjectMirror.prototype.className = function() {
   return %ClassOf(this.value_);
 };
 
 
 ObjectMirror.prototype.constructorFunction = function() {
   return MakeMirror(%DebugGetProperty(this.value_, 'constructor'));
@@ skipping 44 matching lines @@
     total += propertyNames.length;
   }
   if (kind & PropertyKind.Indexed) {
     elementNames = %DebugLocalElementNames(this.value_)
     total += elementNames.length;
   }
   limit = Math.min(limit || total, total);
 
   var names = new Array(limit);
   var index = 0;
-  
+
   // Copy names for named properties.
   if (kind & PropertyKind.Named) {
     for (var i = 0; index < limit && i < propertyNames.length; i++) {
       names[index++] = propertyNames[i];
     }
   }
-  
+
   // Copy names for indexed properties.
   if (kind & PropertyKind.Indexed) {
     for (var i = 0; index < limit && i < elementNames.length; i++) {
       names[index++] = elementNames[i];
     }
   }
 
   return names;
 };
 
@@ skipping 28 matching lines @@
 ObjectMirror.prototype.interceptorPropertyNames = function(kind, limit) {
   // Find kind.
   kind = kind || PropertyKind.Named | PropertyKind.Indexed;
   var namedInterceptorNames;
   var indexedInterceptorNames;
 
   // Get names for named interceptor properties.
   if (this.hasNamedInterceptor() && kind & PropertyKind.Named) {
     namedInterceptorNames = %DebugNamedInterceptorPropertyNames(this.value_);
   }
-  
+
   // Get names for indexed interceptor properties.
   if (this.hasIndexedInterceptor() && kind & PropertyKind.Indexed) {
     indexedInterceptorNames = %DebugIndexedInterceptorElementNames(this.value_);
   }
 
   // Return either retult or both concattenated.
   if (namedInterceptorNames && indexedInterceptorNames) {
     return namedInterceptorNames.concat(indexedInterceptorNames);
   } else if (namedInterceptorNames) {
     return namedInterceptorNames;
@@ skipping 11 matching lines @@
  *     interceptor properties are requested
  * @param {Array} opt_names Limit the number of properties returned to the
        specified value
  * @return {Array} properties this object as an array of PropertyMirror objects
  */
 ObjectMirror.prototype.interceptorProperties = function(opt_kind, opt_names) {
   // Find kind.
   var kind = opt_kind || PropertyKind.Named | PropertyKind.Indexed;
   var namedInterceptorProperties;
   var indexedInterceptorProperties;
-  
+
   // Get values for named interceptor properties.
   if (kind & PropertyKind.Named) {
     var names = opt_names || this.interceptorPropertyNames(PropertyKind.Named);
     namedInterceptorProperties = new Array(names.length);
     for (i = 0; i < names.length; i++) {
       var value = %DebugNamedInterceptorPropertyValue(this.value_, names[i]);
       namedInterceptorProperties[i] = new InterceptorPropertyMirror(this, names[i], value);
     }
   }
-  
+
   // Get values for indexed interceptor properties.
   if (kind & PropertyKind.Indexed) {
     var names = opt_names || this.interceptorPropertyNames(PropertyKind.Indexed);
     indexedInterceptorProperties = new Array(names.length);
     for (i = 0; i < names.length; i++) {
       // Don't try to get the value if the name is not a number.
       if (IS_NUMBER(names[i])) {
         var value = %DebugIndexedInterceptorElementValue(this.value_, names[i]);
         indexedInterceptorProperties[i] = new InterceptorPropertyMirror(this, names[i], value);
       }
@@ skipping 128 matching lines @@
 
 /**
  * Mirror object for functions.
  * @param {function} value The function object reflected by this mirror.
  * @constructor
  * @extends ObjectMirror
  */
 function FunctionMirror(value) {
   ObjectMirror.call(this, value, FUNCTION_TYPE);
   this.resolved_ = true;
-};
+}
 inherits(FunctionMirror, ObjectMirror);
 
 
 /**
  * Returns whether the function is resolved.
  * @return {boolean} True if the function is resolved. Unresolved functions can
  *     only originate as functions from stack frames
  */
 FunctionMirror.prototype.resolved = function() {
   return this.resolved_;
@@ skipping 45 matching lines @@
 /**
  * Returns objects constructed by this function.
  * @param {number} opt_max_instances Optional parameter specifying the maximum
  *     number of instances to return.
  * @return {Array or undefined} The objects constructed by this function.
  */
 FunctionMirror.prototype.constructedBy = function(opt_max_instances) {
   if (this.resolved()) {
     // Find all objects constructed from this function.
     var result = %DebugConstructedBy(this.value_, opt_max_instances || 0);
-    
+
     // Make mirrors for all the instances found.
     for (var i = 0; i < result.length; i++) {
       result[i] = MakeMirror(result[i]);
     }
-    
+
     return result;
   } else {
     return [];
   }
 };
 
 
 FunctionMirror.prototype.fillJSON_ = function(content, details) {
   // Fill JSON properties from parent (ObjectMirror).
   FunctionMirror.super_.fillJSON_.call(this, content, details);
@@ skipping 21 matching lines @@
  * @constructor
  * @extends ObjectMirror
  */
 function UnresolvedFunctionMirror(value) {
   // Construct this using the ValueMirror as an unresolved function is not a
   // real object but just a string.
   ValueMirror.call(this, FUNCTION_TYPE, value);
   this.propertyCount_ = 0;
   this.elementCount_ = 0;
   this.resolved_ = false;
-};
+}
 inherits(UnresolvedFunctionMirror, FunctionMirror);
 
 
 UnresolvedFunctionMirror.prototype.className = function() {
   return 'Function';
 };
 
 
 UnresolvedFunctionMirror.prototype.constructorFunction = function() {
   return new UndefinedMirror();
@@ skipping 21 matching lines @@
 
 
 /**
  * Mirror object for arrays.
  * @param {Array} value The Array object reflected by this mirror
  * @constructor
  * @extends ObjectMirror
  */
 function ArrayMirror(value) {
   ObjectMirror.call(this, value);
-};
+}
 inherits(ArrayMirror, ObjectMirror);
 
 
 ArrayMirror.prototype.length = function() {
   return this.value_.length;
 };
 
 
 ArrayMirror.prototype.indexedPropertiesFromRange = function(opt_from_index, opt_to_index) {
   var from_index = opt_from_index || 0;
@@ skipping 27 matching lines @@
 
 
 /**
  * Mirror object for dates.
  * @param {Date} value The Date object reflected by this mirror
  * @constructor
  * @extends ObjectMirror
  */
 function DateMirror(value) {
   ObjectMirror.call(this, value);
-};
+}
 inherits(DateMirror, ObjectMirror);
 
 
 DateMirror.prototype.fillJSON_ = function(content, details) {
   // Fill JSON properties from parent (ObjectMirror).
   DateMirror.super_.fillJSON_.call(this, content, details);
   // Add date specific properties.
   content.push(MakeJSONPair_('value', DateToJSON_(this.value_)));
 }
 
 
 DateMirror.prototype.toText = function() {
   return DateToISO8601_(this.value_);
 }
 
 
 /**
  * Mirror object for regular expressions.
  * @param {RegExp} value The RegExp object reflected by this mirror
  * @constructor
  * @extends ObjectMirror
  */
 function RegExpMirror(value) {
   ObjectMirror.call(this, value, REGEXP_TYPE);
-};
+}
 inherits(RegExpMirror, ObjectMirror);
 
 
 /**
  * Returns the source to the regular expression.
  * @return {string or undefined} The source to the regular expression
  */
 RegExpMirror.prototype.source = function() {
   return this.value_.source;
 };
@@ skipping 44 matching lines @@
 
 
 /**
  * Mirror object for error objects.
  * @param {Error} value The error object reflected by this mirror
  * @constructor
  * @extends ObjectMirror
  */
 function ErrorMirror(value) {
   ObjectMirror.call(this, value, ERROR_TYPE);
-};
+}
 inherits(ErrorMirror, ObjectMirror);
 
 
 /**
  * Returns the message for this eror object.
  * @return {string or undefined} The message for this eror object
  */
 ErrorMirror.prototype.message = function() {
   return this.value_.message;
 };
@@ skipping 26 matching lines @@
  * @param {Object} value The value of the property
  * @constructor
  * @extends Mirror
  */
 function PropertyMirror(mirror, name, value, details) {
   Mirror.call(this, PROPERTY_TYPE);
   this.mirror_ = mirror;
   this.name_ = name;
   this.value_ = value;
   this.details_ = details;
-};
+}
 inherits(PropertyMirror, Mirror);
 
 
 PropertyMirror.prototype.isReadOnly = function() {
   return (this.attributes() & PropertyAttribute.ReadOnly) != 0;
 }
 
 
 PropertyMirror.prototype.isEnum = function() {
   return (this.attributes() & PropertyAttribute.DontEnum) == 0;
@@ skipping 62 matching lines @@
 /**
  * Mirror object for interceptor named properties.
  * @param {ObjectMirror} mirror The mirror object having this property
  * @param {String} name The name of the property
  * @param {value} value The value of the property
  * @constructor
  * @extends PropertyMirror
  */
 function InterceptorPropertyMirror(mirror, name, value) {
   PropertyMirror.call(this, mirror, name, value, PropertyType.Interceptor);
-};
+}
 inherits(InterceptorPropertyMirror, PropertyMirror);
 
 
 /**
  * Mirror object for property accessors.
  * @param {Function} getter The getter function for this accessor
  * @param {Function} setter The setter function for this accessor
  * @constructor
  * @extends Mirror
  */
 function AccessorMirror(getter, setter) {
   Mirror.call(this, ACCESSOR_TYPE);
   this.getter_ = getter;
   this.setter_ = setter;
-};
+}
 inherits(AccessorMirror, Mirror);
 
 
 /**
  * Returns whether this accessor is native or not. A native accessor is either
  * a VM buildin or provided through the API. A non native accessor is defined
  * in JavaScript using the __defineGetter__ and/or __defineGetter__ functions.
  * @return {boolean} True is the accessor is native
  */
 AccessorMirror.prototype.isNative = function() {
@@ skipping 70 matching lines @@
  *     6: Construct call
  *     Arguments name, value
  *     Locals name, value
  * @param {number} break_id Current break id
  * @param {number} index Frame number
  * @constructor
  */
 function FrameDetails(break_id, index) {
   this.break_id_ = break_id;
   this.details_ = %GetFrameDetails(break_id, index);
-};
+}
 
 
 FrameDetails.prototype.frameId = function() {
   %CheckExecutionState(this.break_id_);
   return this.details_[kFrameDetailsFrameIdIndex];
 }
 
 
 FrameDetails.prototype.receiver = function() {
   %CheckExecutionState(this.break_id_);
@@ skipping 85 matching lines @@
        valid
  * @param {number} index The frame index (top frame is index 0)
  * @constructor
  * @extends Mirror
  */
 function FrameMirror(break_id, index) {
   Mirror.call(this, FRAME_TYPE);
   this.break_id_ = break_id;
   this.index_ = index;
   this.details_ = new FrameDetails(break_id, index);
-};
+}
 inherits(FrameMirror, Mirror);
 
 
 FrameMirror.prototype.index = function() {
   return this.index_;
 };
 
 
 FrameMirror.prototype.func = function() {
   // Get the function for this frame from the VM.
@@ skipping 180 matching lines @@
         result += property.name();
       } else {
         result += '[';
         result += property.name();
         result += ']';
       }
       // Also known as - if the name in the function doesn't match the name
       // under which it was looked up.
       if (func.name() && func.name() != property.name()) {
         result += '(aka ' + func.name() + ')';
-      }      
+      }
     } else {
       // The function invoked was not found on the receiver. Use the function
       // name if available for the backtrace.
       if (display_receiver) {
         result += '.';
       }
       result += func.name() ? func.name() : '[anonymous]';
     }
   }
 
   // Render arguments for normal frames.
   if (!this.isDebuggerFrame()) {
     result += '(';
     for (var i = 0; i < this.argumentCount(); i++) {
       if (i != 0) result += ', ';
       if (this.argumentName(i)) {
         result += this.argumentName(i);
         result += '=';
       }
       result += this.argumentValue(i).toText();
     }
     result += ')';
   }
-  
+
   return result;
 }
 
 
 FrameMirror.prototype.sourceAndPositionText = function() {
   // Format source and position.
   var result = '';
   var func = this.func();
   if (func.resolved()) {
     if (func.script()) {
@@ skipping 58 matching lines @@
 
 /**
  * Mirror object for script source.
  * @param {Script} script The script object
  * @constructor
  * @extends Mirror
  */
 function ScriptMirror(script) {
   Mirror.call(this, SCRIPT_TYPE);
   this.script_ = script;
-};
+}
 inherits(ScriptMirror, Mirror);
 
 
 ScriptMirror.prototype.name = function() {
   return this.script_.name;
 };
 
 
 ScriptMirror.prototype.lineOffset = function() {
   return this.script_.line_offset;
@@ skipping 28 matching lines @@
 ScriptMirror.prototype.fillJSON_ = function(content, details) {
   ScriptMirror.super_.fillJSONType_.call(this, content);
   if (this.name()) {
     content.push(MakeJSONPair_('name', StringToJSON_(this.name())));
   }
   content.push(MakeJSONPair_('lineOffset', NumberToJSON_(this.lineOffset())));
   content.push(MakeJSONPair_('columnOffset', NumberToJSON_(this.columnOffset())));
   content.push(MakeJSONPair_('lineCount', NumberToJSON_(this.lineCount())));
   content.push(MakeJSONPair_('scriptType', NumberToJSON_(this.scriptType())));
 }
-  
-  
+
+
 ScriptMirror.prototype.toText = function() {
   var result = '';
   result += this.name();
   result += ' (lines: ';
   if (this.lineOffset() > 0) {
     result += this.lineOffset();
     result += '-';
     result += this.lineOffset() + this.lineCount() - 1;
   } else {
     result += this.lineCount();
   }
   result += ')';
   return result;
 }
 
 
 function MakeJSONPair_(name, value) {
   return '"' + name + '":' + value;
-};
+}
 
 
 function ArrayToJSONObject_(content) {
   return '{' + content.join(',') + '}';
-};
+}
 
 
 function ArrayToJSONArray_(content) {
   return '[' + content.join(',') + ']';
-};
+}
 
 
 function BooleanToJSON_(value) {
   return String(value); 
-};
+}
 
 
 function NumberToJSON_(value) {
   return String(value); 
-};
+}
 
 
 // Mapping of some control characters to avoid the \uXXXX syntax for most
 // commonly used control cahracters.
 const ctrlCharMap_ = {
   '\b': '\\b',
   '\t': '\\t',
   '\n': '\\n',
   '\f': '\\f',
   '\r': '\\r',
@@ skipping 32 matching lines @@
         // Convert control character to unicode escape sequence.
         return '\\u00' +
           %NumberToRadixString(Math.floor(mapped / 16), 16) +
           %NumberToRadixString(mapped % 16, 16);
       })
     + '"';
   }
 
   // Simple string with no special characters.
   return '"' + value + '"';
-};
+}
 
 
 /**
  * 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 DateToISO8601_(value) {
   function f(n) {
     return n < 10 ? '0' + n : n;
   }
   function g(n) {
     return n < 10 ? '00' + n : n < 100 ? '0' + n : n;
   }
   return builtins.GetUTCFullYearFrom(value)         + '-' +
           f(builtins.GetUTCMonthFrom(value) + 1)    + '-' +
           f(builtins.GetUTCDateFrom(value))         + 'T' +
           f(builtins.GetUTCHoursFrom(value))        + ':' +
           f(builtins.GetUTCMinutesFrom(value))      + ':' +
           f(builtins.GetUTCSecondsFrom(value))      + '.' +
           g(builtins.GetUTCMillisecondsFrom(value)) + 'Z';
-};
+}
 
 /**
  * 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) + '"';
-};
+}