[runtime] Remove the very dangerous %_CallFunction intrinsic.

src/debug/mirrors.js

 // Copyright 2006-2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 (function(global, utils) {
 "use strict";
 
 // ----------------------------------------------------------------------------
 // Imports
 
@@ skipping 526 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
  * @param {boolean} transient indicate whether this object is transient with a
  *    transient handle
  * @constructor
  * @extends Mirror
  */
 function ValueMirror(type, value, transient) {
-  %_CallFunction(this, type, Mirror);
+  %_Call(Mirror, this, type);
   this.value_ = value;
   if (!transient) {
     this.allocateHandle_();
   } else {
     this.allocateTransientHandle_();
   }
 }
 inherits(ValueMirror, Mirror);
 
 
@@ skipping 25 matching lines @@
   return this.value_;
 };
 
 
 /**
  * Mirror object for Undefined.
  * @constructor
  * @extends ValueMirror
  */
 function UndefinedMirror() {
-  %_CallFunction(this, MirrorType.UNDEFINED_TYPE, UNDEFINED, ValueMirror);
+  %_Call(ValueMirror, this, MirrorType.UNDEFINED_TYPE, UNDEFINED);
 }
 inherits(UndefinedMirror, ValueMirror);
 
 
 UndefinedMirror.prototype.toText = function() {
   return 'undefined';
 };
 
 
 /**
  * Mirror object for null.
  * @constructor
  * @extends ValueMirror
  */
 function NullMirror() {
-  %_CallFunction(this, MirrorType.NULL_TYPE, null, ValueMirror);
+  %_Call(ValueMirror, this, MirrorType.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) {
-  %_CallFunction(this, MirrorType.BOOLEAN_TYPE, value, ValueMirror);
+  %_Call(ValueMirror, this, MirrorType.BOOLEAN_TYPE, value);
 }
 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) {
-  %_CallFunction(this, MirrorType.NUMBER_TYPE, value, ValueMirror);
+  %_Call(ValueMirror, this, MirrorType.NUMBER_TYPE, value);
 }
 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) {
-  %_CallFunction(this, MirrorType.STRING_TYPE, value, ValueMirror);
+  %_Call(ValueMirror, this, MirrorType.STRING_TYPE, value);
 }
 inherits(StringMirror, ValueMirror);
 
 
 StringMirror.prototype.length = function() {
   return this.value_.length;
 };
 
 StringMirror.prototype.getTruncatedValue = function(maxLength) {
   if (maxLength != -1 && this.length() > maxLength) {
     return this.value_.substring(0, maxLength) +
            '... (length: ' + this.length() + ')';
   }
   return this.value_;
 };
 
 StringMirror.prototype.toText = function() {
   return this.getTruncatedValue(kMaxProtocolStringLength);
 };
 
 
 /**
  * Mirror object for a Symbol
  * @param {Object} value The Symbol
  * @constructor
  * @extends Mirror
  */
 function SymbolMirror(value) {
-  %_CallFunction(this, MirrorType.SYMBOL_TYPE, value, ValueMirror);
+  %_Call(ValueMirror, this, MirrorType.SYMBOL_TYPE, value);
 }
 inherits(SymbolMirror, ValueMirror);
 
 
 SymbolMirror.prototype.description = function() {
   return %SymbolDescription(%_ValueOf(this.value_));
 }
 
 
 SymbolMirror.prototype.toText = function() {
-  return %_CallFunction(this.value_, SymbolToString);
+  return %_Call(SymbolToString, this.value_);
 }
 
 
 /**
  * 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) {
   type = type || MirrorType.OBJECT_TYPE;
-  %_CallFunction(this, type, value, transient, ValueMirror);
+  %_Call(ValueMirror, this, type, value, transient);
 }
 inherits(ObjectMirror, ValueMirror);
 
 
 ObjectMirror.prototype.className = function() {
   return %_ClassOf(this.value_);
 };
 
 
 ObjectMirror.prototype.constructorFunction = function() {
@@ skipping 229 matching lines @@
 }
 
 
 /**
  * Mirror object for functions.
  * @param {function} value The function object reflected by this mirror.
  * @constructor
  * @extends ObjectMirror
  */
 function FunctionMirror(value) {
-  %_CallFunction(this, value, MirrorType.FUNCTION_TYPE, ObjectMirror);
+  %_Call(ObjectMirror, this, value, MirrorType.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
  */
@@ skipping 133 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.
-  %_CallFunction(this, MirrorType.FUNCTION_TYPE, value, ValueMirror);
+  %_Call(ValueMirror, this, MirrorType.FUNCTION_TYPE, value);
   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) {
-  %_CallFunction(this, value, ObjectMirror);
+  %_Call(ObjectMirror, this, value);
 }
 inherits(ArrayMirror, ObjectMirror);
 
 
 ArrayMirror.prototype.length = function() {
   return this.value_.length;
 };
 
 
 ArrayMirror.prototype.indexedPropertiesFromRange = function(opt_from_index,
@@ skipping 16 matching lines @@
 };
 
 
 /**
  * Mirror object for dates.
  * @param {Date} value The Date object reflected by this mirror
  * @constructor
  * @extends ObjectMirror
  */
 function DateMirror(value) {
-  %_CallFunction(this, value, ObjectMirror);
+  %_Call(ObjectMirror, this, value);
 }
 inherits(DateMirror, ObjectMirror);
 
 
 DateMirror.prototype.toText = function() {
   var s = JSONStringify(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) {
-  %_CallFunction(this, value, MirrorType.REGEXP_TYPE, ObjectMirror);
+  %_Call(ObjectMirror, this, value, MirrorType.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 51 matching lines @@
 };
 
 
 /**
  * Mirror object for error objects.
  * @param {Error} value The error object reflected by this mirror
  * @constructor
  * @extends ObjectMirror
  */
 function ErrorMirror(value) {
-  %_CallFunction(this, value, MirrorType.ERROR_TYPE, ObjectMirror);
+  %_Call(ObjectMirror, this, value, MirrorType.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;
 };
 
 
 ErrorMirror.prototype.toText = function() {
   // Use the same text representation as in messages.js.
   var text;
   try {
-    text = %_CallFunction(this.value_, ErrorToString);
+    text = %_Call(ErrorToString, this.value_);
   } catch (e) {
     text = '#<Error>';
   }
   return text;
 };
 
 
 /**
  * Mirror object for a Promise object.
  * @param {Object} value The Promise object
  * @constructor
  * @extends ObjectMirror
  */
 function PromiseMirror(value) {
-  %_CallFunction(this, value, MirrorType.PROMISE_TYPE, ObjectMirror);
+  %_Call(ObjectMirror, this, value, MirrorType.PROMISE_TYPE);
 }
 inherits(PromiseMirror, ObjectMirror);
 
 
 function PromiseGetStatus_(value) {
   var status = %DebugGetProperty(value, promiseStatusSymbol);
   if (status == 0) return "pending";
   if (status == 1) return "resolved";
   return "rejected";
 }
 
 
 function PromiseGetValue_(value) {
   return %DebugGetProperty(value, promiseValueSymbol);
 }
 
 
 PromiseMirror.prototype.status = function() {
   return PromiseGetStatus_(this.value_);
 };
 
 
 PromiseMirror.prototype.promiseValue = function() {
   return MakeMirror(PromiseGetValue_(this.value_));
 };
 
 
 function MapMirror(value) {
-  %_CallFunction(this, value, MirrorType.MAP_TYPE, ObjectMirror);
+  %_Call(ObjectMirror, this, value, MirrorType.MAP_TYPE);
 }
 inherits(MapMirror, ObjectMirror);
 
 
 /**
  * Returns an array of key/value pairs of a map.
  * This will keep keys alive for WeakMaps.
  *
  * @param {number=} opt_limit Max elements to return.
  * @returns {Array.<Object>} Array of key/value pairs of a map.
  */
 MapMirror.prototype.entries = function(opt_limit) {
   var result = [];
 
   if (IS_WEAKMAP(this.value_)) {
     var entries = %GetWeakMapEntries(this.value_, opt_limit || 0);
     for (var i = 0; i < entries.length; i += 2) {
       result.push({
         key: entries[i],
         value: entries[i + 1]
       });
     }
     return result;
   }
 
-  var iter = %_CallFunction(this.value_, MapEntries);
+  var iter = %_Call(MapEntries, this.value_);
   var next;
   while ((!opt_limit || result.length < opt_limit) &&
          !(next = iter.next()).done) {
     result.push({
       key: next.value[0],
       value: next.value[1]
     });
   }
   return result;
 };
 
 
 function SetMirror(value) {
-  %_CallFunction(this, value, MirrorType.SET_TYPE, ObjectMirror);
+  %_Call(ObjectMirror, this, value, MirrorType.SET_TYPE);
 }
 inherits(SetMirror, ObjectMirror);
 
 
 function IteratorGetValues_(iter, next_function, opt_limit) {
   var result = [];
   var next;
   while ((!opt_limit || result.length < opt_limit) &&
-         !(next = %_CallFunction(iter, next_function)).done) {
+         !(next = %_Call(next_function, iter)).done) {
     result.push(next.value);
   }
   return result;
 }
 
 
 /**
  * Returns an array of elements of a set.
  * This will keep elements alive for WeakSets.
  *
  * @param {number=} opt_limit Max elements to return.
  * @returns {Array.<Object>} Array of elements of a set.
  */
 SetMirror.prototype.values = function(opt_limit) {
   if (IS_WEAKSET(this.value_)) {
     return %GetWeakSetValues(this.value_, opt_limit || 0);
   }
 
-  var iter = %_CallFunction(this.value_, SetValues);
+  var iter = %_Call(SetValues, this.value_);
   return IteratorGetValues_(iter, SetIteratorNext, opt_limit);
 };
 
 
 function IteratorMirror(value) {
-  %_CallFunction(this, value, MirrorType.ITERATOR_TYPE, ObjectMirror);
+  %_Call(ObjectMirror, this, value, MirrorType.ITERATOR_TYPE);
 }
 inherits(IteratorMirror, ObjectMirror);
 
 
 /**
  * Returns a preview of elements of an iterator.
  * Does not change the backing iterator state.
  *
  * @param {number=} opt_limit Max elements to return.
  * @returns {Array.<Object>} Array of elements of an iterator.
@@ skipping 11 matching lines @@
 };
 
 
 /**
  * Mirror object for a Generator object.
  * @param {Object} data The Generator object
  * @constructor
  * @extends Mirror
  */
 function GeneratorMirror(value) {
-  %_CallFunction(this, value, MirrorType.GENERATOR_TYPE, ObjectMirror);
+  %_Call(ObjectMirror, this, value, MirrorType.GENERATOR_TYPE);
 }
 inherits(GeneratorMirror, ObjectMirror);
 
 
 function GeneratorGetStatus_(value) {
   var continuation = %GeneratorGetContinuation(value);
   if (continuation < 0) return "running";
   if (continuation == 0) return "closed";
   return "suspended";
 }
@@ skipping 46 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) {
-  %_CallFunction(this, MirrorType.PROPERTY_TYPE, Mirror);
+  %_Call(Mirror, this, MirrorType.PROPERTY_TYPE);
   this.mirror_ = mirror;
   this.name_ = name;
   this.value_ = details[0];
   this.details_ = details[1];
   this.is_interceptor_ = details[2];
   if (details.length > 3) {
     this.exception_ = details[3];
     this.getter_ = details[4];
     this.setter_ = details[5];
   }
@@ skipping 122 matching lines @@
 /**
  * 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, MirrorType.INTERNAL_PROPERTY_TYPE, Mirror);
+  %_Call(Mirror, this, MirrorType.INTERNAL_PROPERTY_TYPE);
   this.name_ = name;
   this.value_ = value;
 }
 inherits(InternalPropertyMirror, Mirror);
 
 
 InternalPropertyMirror.prototype.name = function() {
   return this.name_;
 };
 
@@ skipping 192 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) {
-  %_CallFunction(this, MirrorType.FRAME_TYPE, Mirror);
+  %_Call(Mirror, this, MirrorType.FRAME_TYPE);
   this.break_id_ = break_id;
   this.index_ = index;
   this.details_ = new FrameDetails(break_id, index);
 }
 inherits(FrameMirror, Mirror);
 
 
 FrameMirror.prototype.details = function() {
   return this.details_;
 };
@@ skipping 410 matching lines @@
  * Mirror object for scope of frame or function. Either frame or function must
  * be specified.
  * @param {FrameMirror} frame The frame this scope is a part of
  * @param {FunctionMirror} function The function this scope is a part of
  * @param {number} index The scope index in the frame
  * @param {Array=} opt_details Raw scope details data
  * @constructor
  * @extends Mirror
  */
 function ScopeMirror(frame, fun, index, opt_details) {
-  %_CallFunction(this, MirrorType.SCOPE_TYPE, Mirror);
+  %_Call(Mirror, this, MirrorType.SCOPE_TYPE);
   if (frame) {
     this.frame_index_ = frame.index_;
   } else {
     this.frame_index_ = UNDEFINED;
   }
   this.scope_index_ = index;
   this.details_ = new ScopeDetails(frame, fun, index, opt_details);
 }
 inherits(ScopeMirror, Mirror);
 
@@ skipping 34 matching lines @@
 };
 
 
 /**
  * Mirror object for script source.
  * @param {Script} script The script object
  * @constructor
  * @extends Mirror
  */
 function ScriptMirror(script) {
-  %_CallFunction(this, MirrorType.SCRIPT_TYPE, Mirror);
+  %_Call(Mirror, this, MirrorType.SCRIPT_TYPE);
   this.script_ = script;
   this.context_ = new ContextMirror(script.context_data);
   this.allocateHandle_();
 }
 inherits(ScriptMirror, Mirror);
 
 
 ScriptMirror.prototype.value = function() {
   return this.script_;
 };
@@ skipping 100 matching lines @@
 };
 
 
 /**
  * Mirror object for context.
  * @param {Object} data The context data
  * @constructor
  * @extends Mirror
  */
 function ContextMirror(data) {
-  %_CallFunction(this, MirrorType.CONTEXT_TYPE, Mirror);
+  %_Call(Mirror, this, MirrorType.CONTEXT_TYPE);
   this.data_ = data;
   this.allocateHandle_();
 }
 inherits(ContextMirror, Mirror);
 
 
 ContextMirror.prototype.data = function() {
   return this.data_;
 };
 
@@ skipping 618 matching lines @@
 // Functions needed by the debugger runtime.
 utils.InstallFunctions(utils, DONT_ENUM, [
   "ClearMirrorCache", ClearMirrorCache
 ]);
 
 // Export to debug.js
 utils.Export(function(to) {
   to.MirrorType = MirrorType;
 });
 })