Avoid using Function.prototype.call in a number of places in our

src/mirror-debugger.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 393 matching lines @@
  * Allocate a transient handle id for this object. Transient handles are
  * negative.
  */
 Mirror.prototype.allocateTransientHandle_ = function() {
   this.handle_ = next_transient_handle_--;
 }
 
 
 Mirror.prototype.toText = function() {
   // Simpel to text which is used when on specialization in subclass.
-  return "#<" + builtins.GetInstanceName(this.constructor.name) + ">";
+  return "#<" + 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
  * @param {boolean} transient indicate whether this object is transient with a
  *    transient handle
  * @constructor
  * @extends Mirror
  */
 function ValueMirror(type, value, transient) {
-  Mirror.call(this, type);
+  %_CallFunction(this, type, Mirror);
   this.value_ = value;
   if (!transient) {
     this.allocateHandle_();
   } else {
     this.allocateTransientHandle_();
   }
 }
 inherits(ValueMirror, Mirror);
 
 
@@ skipping 24 matching lines @@
   return this.value_;
 };
 
 
 /**
  * Mirror object for Undefined.
  * @constructor
  * @extends ValueMirror
  */
 function UndefinedMirror() {
-  ValueMirror.call(this, UNDEFINED_TYPE, void 0);
+  %_CallFunction(this, UNDEFINED_TYPE, void 0, ValueMirror);
 }
 inherits(UndefinedMirror, ValueMirror);
 
 
 UndefinedMirror.prototype.toText = function() {
   return 'undefined';
 }
 
 
 /**
  * Mirror object for null.
  * @constructor
  * @extends ValueMirror
  */
 function NullMirror() {
-  ValueMirror.call(this, NULL_TYPE, null);
+  %_CallFunction(this, NULL_TYPE, null, ValueMirror);
 }
 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);
+  %_CallFunction(this, BOOLEAN_TYPE, value, ValueMirror);
 }
 inherits(BooleanMirror, ValueMirror);
 
 
 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);
+  %_CallFunction(this, NUMBER_TYPE, value, ValueMirror);
 }
 inherits(NumberMirror, ValueMirror);
 
 
 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);
+  %_CallFunction(this, STRING_TYPE, value, ValueMirror);
 }
 inherits(StringMirror, ValueMirror);
 
 
 StringMirror.prototype.length = function() {
   return this.value_.length;
 };
 
 StringMirror.prototype.getTruncatedValue = function(maxLength) {
   if (maxLength != -1 && this.length() > maxLength) {
@@ skipping 10 matching lines @@
 
 /**
  * Mirror object for objects.
  * @param {object} value The object reflected by this mirror
  * @param {boolean} transient indicate whether this object is transient with a
  *    transient handle
  * @constructor
  * @extends ValueMirror
  */
 function ObjectMirror(value, type, transient) {
-  ValueMirror.call(this, type || OBJECT_TYPE, value, transient);
+  %_CallFunction(this, type || OBJECT_TYPE, value, transient, ValueMirror);
 }
 inherits(ObjectMirror, ValueMirror);
 
 
 ObjectMirror.prototype.className = function() {
   return %_ClassOf(this.value_);
 };
 
 
 ObjectMirror.prototype.constructorFunction = function() {
@@ skipping 178 matching lines @@
   var name;
   var ctor = this.constructorFunction();
   if (!ctor.isFunction()) {
     name = this.className();
   } else {
     name = ctor.name();
     if (!name) {
       name = this.className();
     }
   }
-  return '#<' + builtins.GetInstanceName(name) + '>';
+  return '#<' + name + '>';
 };
 
 
 /**
  * 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);
+  %_CallFunction(this, value, FUNCTION_TYPE, ObjectMirror);
   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
  */
@@ skipping 109 matching lines @@
 /**
  * Mirror object for unresolved functions.
  * @param {string} value The name for the unresolved function reflected by this
  *     mirror.
  * @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);
+  %_CallFunction(this, FUNCTION_TYPE, value, ValueMirror);
   this.propertyCount_ = 0;
   this.elementCount_ = 0;
   this.resolved_ = false;
 }
 inherits(UnresolvedFunctionMirror, FunctionMirror);
 
 
 UnresolvedFunctionMirror.prototype.className = function() {
   return 'Function';
 };
@@ skipping 29 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);
+  %_CallFunction(this, value, ObjectMirror);
 }
 inherits(ArrayMirror, ObjectMirror);
 
 
 ArrayMirror.prototype.length = function() {
   return this.value_.length;
 };
 
 
 ArrayMirror.prototype.indexedPropertiesFromRange = function(opt_from_index, opt_to_index) {
@@ skipping 15 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);
+  %_CallFunction(this, value, ObjectMirror);
 }
 inherits(DateMirror, ObjectMirror);
 
 
 DateMirror.prototype.toText = function() {
   var s = JSON.stringify(this.value_);
   return s.substring(1, s.length - 1);  // cut quotes
 }
 
 
 /**
  * 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);
+  %_CallFunction(this, value, REGEXP_TYPE, ObjectMirror);
 }
 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 33 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);
+  %_CallFunction(this, value, ERROR_TYPE, ObjectMirror);
 }
 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 14 matching lines @@
 
 /**
  * Base mirror object for properties.
  * @param {ObjectMirror} mirror The mirror object having this property
  * @param {string} name The name of the property
  * @param {Array} details Details about the property
  * @constructor
  * @extends Mirror
  */
 function PropertyMirror(mirror, name, details) {
-  Mirror.call(this, PROPERTY_TYPE);
+  %_CallFunction(this, PROPERTY_TYPE, Mirror);
   this.mirror_ = mirror;
   this.name_ = name;
   this.value_ = details[0];
   this.details_ = details[1];
   if (details.length > 2) {
     this.exception_ = details[2]
     this.getter_ = details[3];
     this.setter_ = details[4];
   }
 }
@@ skipping 275 matching lines @@
 
 /**
  * Mirror object for stack frames.
  * @param {number} break_id The break id in the VM for which this frame is
        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);
+  %_CallFunction(this, FRAME_TYPE, Mirror);
   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_;
 };
@@ skipping 294 matching lines @@
 
 
 /**
  * Mirror object for scope.
  * @param {FrameMirror} frame The frame this scope is a part of
  * @param {number} index The scope index in the frame
  * @constructor
  * @extends Mirror
  */
 function ScopeMirror(frame, index) {
-  Mirror.call(this, SCOPE_TYPE);
+  %_CallFunction(this, SCOPE_TYPE, Mirror);
   this.frame_index_ = frame.index_;
   this.scope_index_ = index;
   this.details_ = new ScopeDetails(frame, index);
 }
 inherits(ScopeMirror, Mirror);
 
 
 ScopeMirror.prototype.frameIndex = function() {
   return this.frame_index_;
 };
@@ skipping 19 matching lines @@
 };
 
 
 /**
  * Mirror object for script source.
  * @param {Script} script The script object
  * @constructor
  * @extends Mirror
  */
 function ScriptMirror(script) {
-  Mirror.call(this, SCRIPT_TYPE);
+  %_CallFunction(this, SCRIPT_TYPE, Mirror);
   this.script_ = script;
   this.context_ = new ContextMirror(script.context_data);
   this.allocateHandle_();
 }
 inherits(ScriptMirror, Mirror);
 
 
 ScriptMirror.prototype.value = function() {
   return this.script_;
 };
@@ skipping 95 matching lines @@
 }
 
 
 /**
  * Mirror object for context.
  * @param {Object} data The context data
  * @constructor
  * @extends Mirror
  */
 function ContextMirror(data) {
-  Mirror.call(this, CONTEXT_TYPE);
+  %_CallFunction(this, CONTEXT_TYPE, Mirror);
   this.data_ = data;
   this.allocateHandle_();
 }
 inherits(ContextMirror, Mirror);
 
 
 ContextMirror.prototype.data = function() {
   return this.data_;
 };
 
@@ skipping 489 matching lines @@
   }
   if (!NUMBER_IS_FINITE(value)) {
     if (value > 0) {
       return 'Infinity';
     } else {
       return '-Infinity';
     }
   }
   return value;
 }