Make toLocaleString on arrays always call toLocaleString on its elements.

src/js/array.js

 // Copyright 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, extrasUtils) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
@@ skipping 32 matching lines @@
   return new constructor(length);
 }
 
 
 function KeySortCompare(a, b) {
   return a - b;
 }
 
 function GetSortedArrayKeys(array, indices) {
   if (IS_NUMBER(indices)) {
-    var keys = new InternalArray();
     // It's an interval
     var limit = indices;
+    var keys = new InternalArray();
     for (var i = 0; i < limit; ++i) {
       var e = array[i];
       if (!IS_UNDEFINED(e) || i in array) {
         keys.push(i);
       }
     }
     return keys;
   }
   return InnerArraySort(indices, indices.length, KeySortCompare);
 }
 
 
-function SparseJoinWithSeparatorJS(array, keys, length, convert, separator) {
+function SparseJoinWithSeparatorJS(array, keys, length, use_locale, separator) {
   var keys_length = keys.length;
   var elements = new InternalArray(keys_length * 2);
   for (var i = 0; i < keys_length; i++) {
     var key = keys[i];
-    var e = array[key];
     elements[i * 2] = key;
-    elements[i * 2 + 1] = IS_STRING(e) ? e : convert(e);
+    elements[i * 2 + 1] = ConvertToString(use_locale, array[key]);
   }
   return %SparseJoinWithSeparator(elements, length, separator);
 }
 
 
 // Optimized for sparse arrays if separator is ''.
-function SparseJoin(array, keys, convert) {
+function SparseJoin(array, keys, use_locale) {
   var keys_length = keys.length;
   var elements = new InternalArray(keys_length);
   for (var i = 0; i < keys_length; i++) {
-    var e = array[keys[i]];
-    elements[i] = IS_STRING(e) ? e : convert(e);
+    elements[i] = ConvertToString(use_locale, array[keys[i]]);
   }
   return %StringBuilderConcat(elements, keys_length, '');
 }
 
 
 function UseSparseVariant(array, length, is_array, touched) {
   // Only use the sparse variant on arrays that are likely to be sparse and the
   // number of elements touched in the operation is relatively small compared to
   // the overall size of the array.
   if (!is_array || length < 1000 || %HasComplexElements(array)) {
@@ skipping 32 matching lines @@
   for (var i = 0; i < length; i++) {
     if (values[i] === v) return true;
   }
   return false;
 }
 
 // Global list of arrays visited during toString, toLocaleString and
 // join invocations.
 var visited_arrays = new Stack();
 
-function DoJoin(array, length, is_array, separator, convert) {
+function DoJoin(array, length, is_array, separator, use_locale) {
   if (UseSparseVariant(array, length, is_array, length)) {
     %NormalizeElements(array);
     var keys = GetSortedArrayKeys(array, %GetArrayKeys(array, length));
     if (separator === '') {
       if (keys.length === 0) return '';
-      return SparseJoin(array, keys, convert);
+      return SparseJoin(array, keys, use_locale);
     } else {
-      return SparseJoinWithSeparatorJS(array, keys, length, convert, separator);
+      return SparseJoinWithSeparatorJS(
+          array, keys, length, use_locale, separator);
     }
   }
 
   // Fast case for one-element arrays.
   if (length === 1) {
-    var e = array[0];
-    return IS_STRING(e) ? e : convert(e);
+    return ConvertToString(use_locale, array[0]);
   }
 
   // Construct an array for the elements.
   var elements = new InternalArray(length);
+  for (var i = 0; i < length; i++) {
+    elements[i] = ConvertToString(use_locale, array[i]);
+  }
 
-  // We pull the empty separator check outside the loop for speed!
   if (separator === '') {
-    for (var i = 0; i < length; i++) {
-      var e = array[i];
-      elements[i] = IS_STRING(e) ? e : convert(e);
-    }
     return %StringBuilderConcat(elements, length, '');
+  } else {
+    return %StringBuilderJoin(elements, length, separator);
   }
-  // Non-empty separator case.
-  // If the first element is a number then use the heuristic that the
-  // remaining elements are also likely to be numbers.
-  var e = array[0];
-  if (IS_NUMBER(e)) {
-    elements[0] = %_NumberToString(e);
-    for (var i = 1; i < length; i++) {
-      e = array[i];
-      if (IS_NUMBER(e)) {
-        elements[i] = %_NumberToString(e);
-      } else {
-        elements[i] = IS_STRING(e) ? e : convert(e);
-      }
-    }
-  } else {
-    elements[0] = IS_STRING(e) ? e : convert(e);
-    for (var i = 1; i < length; i++) {
-      e = array[i];
-      elements[i] = IS_STRING(e) ? e : convert(e);
-    }
-  }
-  return %StringBuilderJoin(elements, length, separator);
 }
 
-function Join(array, length, separator, convert) {
+function Join(array, length, separator, use_locale) {
   if (length === 0) return '';
 
   var is_array = IS_ARRAY(array);
 
   if (is_array) {
     // If the array is cyclic, return the empty string for already
     // visited arrays.
     if (StackHas(visited_arrays, array)) return '';
     StackPush(visited_arrays, array);
   }
 
   // Attempt to convert the elements.
   try {
-    return DoJoin(array, length, is_array, separator, convert);
+    return DoJoin(array, length, is_array, separator, use_locale);
   } finally {
     // Make sure to remove the last element of the visited array no
     // matter what happens.
     if (is_array) StackPop(visited_arrays);
   }
 }
 
 
-function ConvertToString(x) {
+function ConvertToString(use_locale, x) {
   if (IS_NULL_OR_UNDEFINED(x)) return '';
-  return TO_STRING(x);
+  return TO_STRING(use_locale ? x.toLocaleString() : x);
 }
 
 
-function ConvertToLocaleString(e) {
-  if (IS_NULL_OR_UNDEFINED(e)) return '';
-  return TO_STRING(e.toLocaleString());
-}
-
-
 // This function implements the optimized splice implementation that can use
 // special array operations to handle sparse arrays in a sensible fashion.
 function SparseSlice(array, start_i, del_count, len, deleted_elements) {
   // Move deleted elements to a new array (the return value from splice).
   var indices = %GetArrayKeys(array, start_i + del_count);
   if (IS_NUMBER(indices)) {
     var limit = indices;
     for (var i = start_i; i < limit; ++i) {
       var current = array[i];
       if (!IS_UNDEFINED(current) || i in array) {
@@ skipping 123 matching lines @@
 
 // -------------------------------------------------------------------
 
 
 function ArrayToString() {
   var array;
   var func;
   if (IS_ARRAY(this)) {
     func = this.join;
     if (func === ArrayJoin) {
-      return Join(this, this.length, ',', ConvertToString);
+      return Join(this, this.length, ',', false);
     }
     array = this;
   } else {
     array = TO_OBJECT(this);
     func = array.join;
   }
   if (!IS_CALLABLE(func)) {
     return %_Call(ObjectToString, array);
   }
   return %_Call(func, array);
 }
 
 
 function InnerArrayToLocaleString(array, length) {
-  var len = TO_LENGTH(length);
-  if (len === 0) return "";
-  return Join(array, len, ',', ConvertToLocaleString);
+  return Join(array, TO_LENGTH(length), ',', true);
 }
 
 
 function ArrayToLocaleString() {
   var array = TO_OBJECT(this);
   var arrayLen = array.length;
   return InnerArrayToLocaleString(array, arrayLen);
 }
 
 
 function InnerArrayJoin(separator, array, length) {
   if (IS_UNDEFINED(separator)) {
     separator = ',';
   } else {
     separator = TO_STRING(separator);
   }
 
   // Fast case for one-element arrays.
   if (length === 1) {
     var e = array[0];
     if (IS_NULL_OR_UNDEFINED(e)) return '';
     return TO_STRING(e);
   }
 
-  return Join(array, length, separator, ConvertToString);
+  return Join(array, length, separator, false);
 }
 
 
 function ArrayJoin(separator) {
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.join");
 
   var array = TO_OBJECT(this);
   var length = TO_LENGTH(array.length);
 
   return InnerArrayJoin(separator, array, length);
@@ skipping 1354 matching lines @@
 %InstallToContext([
   "array_pop", ArrayPop,
   "array_push", ArrayPush,
   "array_shift", ArrayShift,
   "array_splice", ArraySplice,
   "array_slice", ArraySlice,
   "array_unshift", ArrayUnshift,
 ]);
 
 });