[runtime] Replace %to_string_fun with %_ToString.

src/runtime.js

 // Copyright 2006-2008 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.
 
 // This files contains runtime support implemented in JavaScript.
 
 // CAUTION: Some of the functions specified in this file are called
 // directly from compiled code. These are the functions with names in
 // ALL CAPS. The compiled code passes the first argument in 'this'.
 
@@ skipping 147 matching lines @@
 function ADD(x) {
   // Fast case: Check for number operands and do the addition.
   if (IS_NUMBER(this) && IS_NUMBER(x)) return %NumberAdd(this, x);
   if (IS_STRING(this) && IS_STRING(x)) return %_StringAdd(this, x);
 
   // Default implementation.
   var a = %to_primitive(this, NO_HINT);
   var b = %to_primitive(x, NO_HINT);
 
   if (IS_STRING(a)) {
-    return %_StringAdd(a, %to_string_fun(b));
+    return %_StringAdd(a, TO_STRING(b));
   } else if (IS_STRING(b)) {
     return %_StringAdd(%non_string_to_string(a), b);
   } else {
     return %NumberAdd(%to_number_fun(a), %to_number_fun(b));
   }
 }
 
 
 // Strong mode ADD throws if an implicit conversion would be performed
 function ADD_STRONG(x) {
   if (IS_NUMBER(this) && IS_NUMBER(x)) return %NumberAdd(this, x);
   if (IS_STRING(this) && IS_STRING(x)) return %_StringAdd(this, x);
 
   throw %make_type_error(kStrongImplicitConversion);
 }
 
 
 // Left operand (this) is already a string.
 function STRING_ADD_LEFT(y) {
   if (!IS_STRING(y)) {
     if (IS_STRING_WRAPPER(y) && %_IsStringWrapperSafeForDefaultValueOf(y)) {
       y = %_ValueOf(y);
     } else {
       y = IS_NUMBER(y)
           ? %_NumberToString(y)
-          : %to_string_fun(%to_primitive(y, NO_HINT));
+          : TO_STRING(%to_primitive(y, NO_HINT));
     }
   }
   return %_StringAdd(this, y);
 }
 
 
 // Right operand (y) is already a string.
 function STRING_ADD_RIGHT(y) {
   var x = this;
   if (!IS_STRING(x)) {
     if (IS_STRING_WRAPPER(x) && %_IsStringWrapperSafeForDefaultValueOf(x)) {
       x = %_ValueOf(x);
     } else {
       x = IS_NUMBER(x)
           ? %_NumberToString(x)
-          : %to_string_fun(%to_primitive(x, NO_HINT));
+          : TO_STRING(%to_primitive(x, NO_HINT));
     }
   }
   return %_StringAdd(x, y);
 }
 
 
 // ECMA-262, section 11.6.2, page 50.
 function SUB(y) {
   var x = IS_NUMBER(this) ? this : %non_number_to_number(this);
   if (!IS_NUMBER(y)) y = %non_number_to_number(y);
@@ skipping 267 matching lines @@
   }
 
   length = (args == null) ? 0 : TO_UINT32(args.length);
 
   // We can handle any number of apply arguments if the stack is
   // big enough, but sanity check the value to avoid overflow when
   // multiplying with pointer size.
   if (length > kSafeArgumentsLength) throw %make_range_error(kStackOverflow);
 
   if (!IS_SPEC_FUNCTION(this)) {
-    throw %make_type_error(kApplyNonFunction, %to_string_fun(this), typeof this);
+    throw %make_type_error(kApplyNonFunction, TO_STRING(this), typeof this);
   }
 
   // Make sure the arguments list has the right type.
   if (args != null && !IS_SPEC_OBJECT(args)) {
     throw %make_type_error(kWrongArgs, "Function.prototype.apply");
   }
 
   // Return the length which is the number of arguments to copy to the
   // stack. It is guaranteed to be a small integer at this point.
   return length;
 }
 
 
 function REFLECT_APPLY_PREPARE(args) {
   var length;
   // First check whether length is a positive Smi and args is an
   // array. This is the fast case. If this fails, we do the slow case
   // that takes care of more eventualities.
   if (IS_ARRAY(args)) {
     length = args.length;
     if (%_IsSmi(length) && length >= 0 && length < kSafeArgumentsLength &&
         IS_SPEC_FUNCTION(this)) {
       return length;
     }
   }
 
   if (!IS_SPEC_FUNCTION(this)) {
-    throw %make_type_error(kCalledNonCallable, %to_string_fun(this));
+    throw %make_type_error(kCalledNonCallable, TO_STRING(this));
   }
 
   if (!IS_SPEC_OBJECT(args)) {
     throw %make_type_error(kWrongArgs, "Reflect.apply");
   }
 
   length = %to_length_fun(args.length);
 
   // We can handle any number of apply arguments if the stack is
   // big enough, but sanity check the value to avoid overflow when
@@ skipping 18 matching lines @@
   if (IS_ARRAY(args)) {
     length = args.length;
     if (%_IsSmi(length) && length >= 0 && length < kSafeArgumentsLength &&
         ctorOk && newTargetOk) {
       return length;
     }
   }
 
   if (!ctorOk) {
     if (!IS_SPEC_FUNCTION(this)) {
-      throw %make_type_error(kCalledNonCallable, %to_string_fun(this));
+      throw %make_type_error(kCalledNonCallable, TO_STRING(this));
     } else {
-      throw %make_type_error(kNotConstructor, %to_string_fun(this));
+      throw %make_type_error(kNotConstructor, TO_STRING(this));
     }
   }
 
   if (!newTargetOk) {
     if (!IS_SPEC_FUNCTION(newTarget)) {
-      throw %make_type_error(kCalledNonCallable, %to_string_fun(newTarget));
+      throw %make_type_error(kCalledNonCallable, TO_STRING(newTarget));
     } else {
-      throw %make_type_error(kNotConstructor, %to_string_fun(newTarget));
+      throw %make_type_error(kNotConstructor, TO_STRING(newTarget));
     }
   }
 
   if (!IS_SPEC_OBJECT(args)) {
     throw %make_type_error(kWrongArgs, "Reflect.construct");
   }
 
   length = %to_length_fun(args.length);
 
   // We can handle any number of apply arguments if the stack is
@@ skipping 16 matching lines @@
   throw %make_range_error(kStackOverflow);
 }
 
 
 // Convert the receiver to a number - forward to ToNumber.
 function TO_NUMBER() {
   return %to_number_fun(this);
 }
 
 
-// Convert the receiver to a string - forward to ToString.
-function TO_STRING() {
-  return %to_string_fun(this);
-}
-
-
 /* -------------------------------------
    - - -   C o n v e r s i o n s   - - -
    -------------------------------------
 */
 
 // ECMA-262, section 9.1, page 30. Use null/undefined for no hint,
 // (1) for number hint, and (2) for string hint.
 function ToPrimitive(x, hint) {
   if (!IS_SPEC_OBJECT(x)) return x;
   if (hint == NO_HINT) hint = (IS_DATE(x)) ? STRING_HINT : NUMBER_HINT;
@@ skipping 238 matching lines @@
 ]);
 
 %InstallToContext([
   "concat_iterable_to_array", ConcatIterableToArray,
   "non_number_to_number", NonNumberToNumber,
   "non_string_to_string", NonStringToString,
   "to_integer_fun", ToInteger,
   "to_length_fun", ToLength,
   "to_number_fun", ToNumber,
   "to_primitive", ToPrimitive,
-  "to_string_fun", ToString,
 ]);
 
 utils.Export(function(to) {
   to.ToBoolean = ToBoolean;
   to.ToLength = ToLength;
   to.ToNumber = ToNumber;
   to.ToPrimitive = ToPrimitive;
   to.ToString = ToString;
 });
 
 })