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

src/array.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 114 matching lines @@
       if (i != 0) builder.add(separator);
       if (!IS_UNDEFINED(e) || (i in array)) {
         builder.add(convert(e));
       }
     }
     return builder.generate();
   } finally {
     // Make sure to pop the visited array no matter what happens.
     if (is_array) visited_arrays.pop();
   }
-};
+}
 
 
 function ConvertToString(e) {
   if (e == null) return '';
   else return ToString(e);
-};
+}
 
 
 function ConvertToLocaleString(e) {
   if (e == null) return '';
   else {
     // e_obj's toLocaleString might be overwritten, check if it is a function.
     // Call ToString if toLocaleString is not a function.
     // See issue 877615.
     var e_obj = ToObject(e);
     if (IS_FUNCTION(e_obj.toLocaleString))
       return e_obj.toLocaleString();
     else
       return ToString(e);
   }
-};
+}
 
 
 // This function implements the optimized splice implementation that can use
 // special array operations to handle sparse arrays in a sensible fashion.
 function SmartSlice(array, start_i, del_count, len, deleted_elements) {
   // Move deleted elements to a new array (the return value from splice).
   // Intervals array can contain keys and intervals.  See comment in Concat.
   var intervals = %GetArrayKeys(array, start_i + del_count);
   var length = intervals.length;
   for (var k = 0; k < length; k++) {
@@ skipping 22 matching lines @@
           // appropriate test.  We follow KJS in consulting the
           // prototype.
           var current = array[key];
           if (!IS_UNDEFINED(current) || key in array) {
             deleted_elements[key - start_i] = current;
           }
         }
       }
     }
   }
-};
+}
 
 
 // This function implements the optimized splice implementation that can use
 // special array operations to handle sparse arrays in a sensible fashion.
 function SmartMove(array, start_i, del_count, len, num_additional_args) {
   // Move data to new array.
   var new_array = new $Array(len - del_count + num_additional_args);
   var intervals = %GetArrayKeys(array, len);
   var length = intervals.length;
   for (var k = 0; k < length; k++) {
@@ skipping 41 matching lines @@
           var current = array[key];
           if (!IS_UNDEFINED(current) || key in array) {
             new_array[key - del_count + num_additional_args] = current;
           }
         }
       }
     }
   }
   // Move contents of new_array into this array
   %MoveArrayContents(new_array, array);
-};
+}
 
 
 // This is part of the old simple-minded splice.  We are using it either
 // because the receiver is not an array (so we have no choice) or because we
 // know we are not deleting or moving a lot of elements.
 function SimpleSlice(array, start_i, del_count, len, deleted_elements) {
   for (var i = 0; i < del_count; i++) {
     var index = start_i + i;
     // The spec could also be interpreted such that %HasLocalProperty
     // would be the appropriate test.  We follow KJS in consulting the
     // prototype.
     var current = array[index];
     if (!IS_UNDEFINED(current) || index in array)
       deleted_elements[i] = current;
   }
-};
+}
 
 
 function SimpleMove(array, start_i, del_count, len, num_additional_args) {
   if (num_additional_args !== del_count) {
     // Move the existing elements after the elements to be deleted
     // to the right position in the resulting array.
     if (num_additional_args > del_count) {
       for (var i = len - del_count; i > start_i; i--) {
         var from_index = i + del_count - 1;
         var to_index = i + num_additional_args - 1;
@@ skipping 19 matching lines @@
           array[to_index] = current;
         } else {
           delete array[to_index];
         }
       }
       for (var i = len; i > len - del_count + num_additional_args; i--) {
         delete array[i - 1];
       }
     }
   }
-};
+}
 
 
 // -------------------------------------------------------------------
 
 
 function ArrayToString() {
   if (!IS_ARRAY(this)) {
     throw new $TypeError('Array.prototype.toString is not generic');
   }
   return Join(this, this.length, ',', ConvertToString);
-};
+}
 
 
 function ArrayToLocaleString() {
   if (!IS_ARRAY(this)) {
     throw new $TypeError('Array.prototype.toString is not generic');
   }
   return Join(this, this.length, ',', ConvertToLocaleString);
-};
+}
 
 
 function ArrayJoin(separator) {
   if (IS_UNDEFINED(separator)) separator = ',';
   else separator = ToString(separator);
   return Join(this, ToUint32(this.length), separator, ConvertToString);
-};
+}
 
 
 // Removes the last element from the array and returns it. See
 // ECMA-262, section 15.4.4.6.
 function ArrayPop() {
   var n = ToUint32(this.length);
   if (n == 0) {
     this.length = n;
     return;
   }
   n--;
   var value = this[n];
   this.length = n;
   delete this[n];
   return value;
-};
+}
 
 
 // Appends the arguments to the end of the array and returns the new
 // length of the array. See ECMA-262, section 15.4.4.7.
 function ArrayPush() {
   var n = ToUint32(this.length);
   var m = %_ArgumentsLength();
   for (var i = 0; i < m; i++) {
     this[i+n] = %_Arguments(i);
   }
   this.length = n + m;
   return this.length;
-};
+}
 
 
 function ArrayConcat(arg1) {  // length == 1
   var arg_number = 0, arg_count = %_ArgumentsLength();
   var n = 0;
 
   var A = $Array(1 + arg_count);
   var E = this;
 
   while (true) {
@@ skipping 25 matching lines @@
       n += E.length;
     } else {
       A[n++] = E;
     }
     if (arg_number == arg_count) break;
     E = %_Arguments(arg_number++);
   }
 
   A.length = n;  // may contain empty arrays
   return A;
-};
+}
 
 
 // For implementing reverse() on large, sparse arrays.
 function SparseReverse(array, len) {
   var keys = GetSortedArrayKeys(array, %GetArrayKeys(array, len));
   var high_counter = keys.length - 1;
   var low_counter = 0;
   while (low_counter <= high_counter) {
     var i = keys[low_counter];
     var j = keys[high_counter];
@@ skipping 54 matching lines @@
       }
     } else {
       var current_j = this[j];
       if (!IS_UNDEFINED(current_j) || j in this) {
         this[i] = current_j;
         delete this[j];
       }
     }
   }
   return this;
-};
+}
 
 
 function ArrayShift() {
   var len = ToUint32(this.length);
-  
+
   if (len === 0) {
     this.length = 0;
     return;
   }
-  
+
   var first = this[0];
-  
+
   if (IS_ARRAY(this))
     SmartMove(this, 0, 1, len, 0);
   else
     SimpleMove(this, 0, 1, len, 0);
-  
+
   this.length = len - 1;
-  
+
   return first;
-};
+}
 
 
 function ArrayUnshift(arg1) {  // length == 1
   var len = ToUint32(this.length);
   var num_arguments = %_ArgumentsLength();
-  
+
   if (IS_ARRAY(this))
     SmartMove(this, 0, 0, len, num_arguments);
   else
     SimpleMove(this, 0, 0, len, num_arguments);
-  
+
   for (var i = 0; i < num_arguments; i++) {
     this[i] = %_Arguments(i);
   }
-  
+
   this.length = len + num_arguments;
-  
+
   return len + num_arguments;
-};
+}
 
 
 function ArraySlice(start, end) {
   var len = ToUint32(this.length);
   var start_i = TO_INTEGER(start);
   var end_i = len;
-  
+
   if (end !== void 0) end_i = TO_INTEGER(end);
-  
+
   if (start_i < 0) {
     start_i += len;
     if (start_i < 0) start_i = 0;
   } else {
     if (start_i > len) start_i = len;
   }
-  
+
   if (end_i < 0) {
     end_i += len;
     if (end_i < 0) end_i = 0;
   } else {
     if (end_i > len) end_i = len;
   }
-  
+
   var result = [];
-  
-  if (end_i < start_i)
-    return result;
-  
-  if (IS_ARRAY(this))
+
+  if (end_i < start_i) return result;
+
+  if (IS_ARRAY(this)) {
     SmartSlice(this, start_i, end_i - start_i, len, result);
-  else 
+  } else {
     SimpleSlice(this, start_i, end_i - start_i, len, result);
-  
+  }
+
   result.length = end_i - start_i;
-  
+
   return result;
-};
+}
 
 
 function ArraySplice(start, delete_count) {
   var num_arguments = %_ArgumentsLength();
-  
+
   // SpiderMonkey and KJS return undefined in the case where no
   // arguments are given instead of using the implicit undefined
   // arguments.  This does not follow ECMA-262, but we do the same for
   // compatibility.
   if (num_arguments == 0) return;
-  
+
   var len = ToUint32(this.length);
   var start_i = TO_INTEGER(start);
-  
+
   if (start_i < 0) {
     start_i += len;
     if (start_i < 0) start_i = 0;
   } else {
     if (start_i > len) start_i = len;
   }
-  
+
   // SpiderMonkey and KJS treat the case where no delete count is
   // given differently from when an undefined delete count is given.
   // This does not follow ECMA-262, but we do the same for
   // compatibility.
   var del_count = 0;
   if (num_arguments > 1) {
     del_count = TO_INTEGER(delete_count);
     if (del_count < 0) del_count = 0;
     if (del_count > len - start_i) del_count = len - start_i;
   } else {
     del_count = len - start_i;
   }
-  
+
   var deleted_elements = [];
   deleted_elements.length = del_count;
-  
+
   // Number of elements to add.
   var num_additional_args = 0;
   if (num_arguments > 2) {
     num_additional_args = num_arguments - 2;
   }
-  
+
   var use_simple_splice = true;
-  
+
   if (IS_ARRAY(this) && num_additional_args !== del_count) {
     // If we are only deleting/moving a few things near the end of the
     // array then the simple version is going to be faster, because it
     // doesn't touch most of the array.
     var estimated_non_hole_elements = %EstimateNumberOfElements(this);
     if (len > 20 && (estimated_non_hole_elements >> 2) < (len - start_i)) {
       use_simple_splice = false;
     }
   }
-  
+
   if (use_simple_splice) {
     SimpleSlice(this, start_i, del_count, len, deleted_elements);
     SimpleMove(this, start_i, del_count, len, num_additional_args);
   } else {
     SmartSlice(this, start_i, del_count, len, deleted_elements);
     SmartMove(this, start_i, del_count, len, num_additional_args);
   }
-  
+
   // Insert the arguments into the resulting array in
   // place of the deleted elements.
   var i = start_i;
   var arguments_index = 2;
   var arguments_length = %_ArgumentsLength();
   while (arguments_index < arguments_length) {
     this[i++] = %_Arguments(arguments_index++);
   }
   this.length = len - del_count + num_additional_args;
-  
+
   // Return the deleted elements.
   return deleted_elements;
-};
+}
 
 
 function ArraySort(comparefn) {
   // In-place QuickSort algorithm.
   // For short (length <= 22) arrays, insertion sort is used for efficiency.
 
   var custom_compare = IS_FUNCTION(comparefn);
-  
+
   function Compare(x,y) {
     if (custom_compare) {
       return comparefn.call(null, x, y);
     }
     if (%_IsSmi(x) && %_IsSmi(y)) {
       return %SmiLexicographicCompare(x, y);
     }
     x = ToString(x);
     y = ToString(y);
     if (x == y) return 0;
@@ skipping 88 matching lines @@
 
   // We only changed the length of the this object (in
   // RemoveArrayHoles) if it was an array.  We are not allowed to set
   // the length of the this object if it is not an array because this
   // might introduce a new length property.
   if (IS_ARRAY(this)) {
     this.length = old_length;
   }
 
   return this;
-};
+}
 
 
 // The following functions cannot be made efficient on sparse arrays while
 // preserving the semantics, since the calls to the receiver function can add
 // or delete elements from the array.
-
 function ArrayFilter(f, receiver) {
   if (!IS_FUNCTION(f)) {
     throw MakeTypeError('called_non_callable', [ f ]);
   }
   // Pull out the length so that modifications to the length in the
   // loop will not affect the looping.
   var length = this.length;
   var result = [];
   for (var i = 0; i < length; i++) {
     var current = this[i];
     if (!IS_UNDEFINED(current) || i in this) {
       if (f.call(receiver, current, i, this)) result.push(current);
     }
   }
   return result;
-};
+}
 
 
 function ArrayForEach(f, receiver) {
   if (!IS_FUNCTION(f)) {
     throw MakeTypeError('called_non_callable', [ f ]);
   }
   // Pull out the length so that modifications to the length in the
   // loop will not affect the looping.
   var length = this.length;
   for (var i = 0; i < length; i++) {
     var current = this[i];
     if (!IS_UNDEFINED(current) || i in this) {
       f.call(receiver, current, i, this);
     }
   }
-};
+}
 
 
 // Executes the function once for each element present in the
 // array until it finds one where callback returns true.
 function ArraySome(f, receiver) {
   if (!IS_FUNCTION(f)) {
     throw MakeTypeError('called_non_callable', [ f ]);
   }
   // Pull out the length so that modifications to the length in the
   // loop will not affect the looping.
   var length = this.length;
   for (var i = 0; i < length; i++) {
     var current = this[i];
     if (!IS_UNDEFINED(current) || i in this) {
       if (f.call(receiver, current, i, this)) return true;
     }
   }
   return false;
-};
+}
 
 
 function ArrayEvery(f, receiver) {
   if (!IS_FUNCTION(f)) {
     throw MakeTypeError('called_non_callable', [ f ]);
   }
   // Pull out the length so that modifications to the length in the
   // loop will not affect the looping.
   var length = this.length;
   for (var i = 0; i < length; i++) {
     var current = this[i];
     if (!IS_UNDEFINED(current) || i in this) {
       if (!f.call(receiver, current, i, this)) return false;
     }
   }
-  
+
   return true;
-};
+}
 
 
 function ArrayMap(f, receiver) {
   if (!IS_FUNCTION(f)) {
     throw MakeTypeError('called_non_callable', [ f ]);
   }
   // Pull out the length so that modifications to the length in the
   // loop will not affect the looping.
   var length = this.length;
   var result = new $Array(length);
   for (var i = 0; i < length; i++) {
     var current = this[i];
     if (!IS_UNDEFINED(current) || i in this) {
       result[i] = f.call(receiver, current, i, this);
     }
   }
   return result;
-};
+}
 
 
 function ArrayIndexOf(element, index) {
   var length = this.length;
   if (index == null) {
     index = 0;
   } else {
     index = TO_INTEGER(index);
     // If index is negative, index from the end of the array.
     if (index < 0) index = length + index;
     // If index is still negative, search the entire array.
     if (index < 0) index = 0;
   }
   // Lookup through the array.
   for (var i = index; i < length; i++) {
     var current = this[i];
     if (!IS_UNDEFINED(current) || i in this) {
       if (current === element) return i;
     }
   }
   return -1;
-};
+}
 
 
 function ArrayLastIndexOf(element, index) {
   var length = this.length;
   if (index == null) {
     index = length - 1;
   } else {
     index = TO_INTEGER(index);
     // If index is negative, index from end of the array.
     if (index < 0) index = length + index;
     // If index is still negative, do not search the array.
     if (index < 0) index = -1;
     else if (index >= length) index = length - 1;
   }
   // Lookup through the array.
   for (var i = index; i >= 0; i--) {
     var current = this[i];
     if (!IS_UNDEFINED(current) || i in this) {
       if (current === element) return i;
     }
   }
   return -1;
-};
+}
 
 
 // -------------------------------------------------------------------
 
-function InstallProperties(prototype, attributes, properties) {
-  for (var key in properties) {
-    %AddProperty(prototype, key, properties[key], attributes);
+function InstallFunctions(prototype, attributes, functions) {
+  for (var i = 0; i < functions.length; i += 2) {
+    var key = functions[i];
+    var f = functions[i + 1];
+    %FunctionSetName(f, key);
+    %AddProperty(prototype, key, f, attributes);
   }
-};
+}
 
 
 function UpdateFunctionLengths(lengths) {
   for (var key in lengths) {
     %FunctionSetLength(this[key], lengths[key]);
   }
-};
+}
 
 
 // -------------------------------------------------------------------
 
 function SetupArray() {
-  // Setup non-enumerable properties of the Array.prototype object.
-  InstallProperties($Array.prototype, DONT_ENUM, {
-    constructor: $Array,
-    toString: ArrayToString,
-    toLocaleString: ArrayToLocaleString,
-    join: ArrayJoin,
-    pop: ArrayPop,
-    push: ArrayPush,
-    concat: ArrayConcat,
-    reverse: ArrayReverse,
-    shift: ArrayShift,
-    unshift: ArrayUnshift,
-    slice: ArraySlice,
-    splice: ArraySplice,
-    sort: ArraySort,
-    filter: ArrayFilter,
-    forEach: ArrayForEach,
-    some: ArraySome,
-    every: ArrayEvery,
-    map: ArrayMap,
-    indexOf: ArrayIndexOf,
-    lastIndexOf: ArrayLastIndexOf
-  });
+  // Setup non-enumerable constructor property on the Array.prototype
+  // object.
+  %AddProperty($Array.prototype, "constructor", $Array, DONT_ENUM);
+
+  // Setup non-enumerable functions of the Array.prototype object and
+  // set their names.
+  InstallFunctions($Array.prototype, DONT_ENUM, $Array(
+    "toString", ArrayToString,
+    "toLocaleString", ArrayToLocaleString,
+    "join", ArrayJoin,
+    "pop", ArrayPop,
+    "push", ArrayPush,
+    "concat", ArrayConcat,
+    "reverse", ArrayReverse,
+    "shift", ArrayShift,
+    "unshift", ArrayUnshift,
+    "slice", ArraySlice,
+    "splice", ArraySplice,
+    "sort", ArraySort,
+    "filter", ArrayFilter,
+    "forEach", ArrayForEach,
+    "some", ArraySome,
+    "every", ArrayEvery,
+    "map", ArrayMap,
+    "indexOf", ArrayIndexOf,
+    "lastIndexOf", ArrayLastIndexOf
+  ));
 
   // Manipulate the length of some of the functions to meet
   // expectations set by ECMA-262 or Mozilla.
   UpdateFunctionLengths({
     ArrayFilter: 1,
     ArrayForEach: 1,
     ArraySome: 1,
     ArrayEvery: 1,
     ArrayMap: 1,
     ArrayIndexOf: 1,
     ArrayLastIndexOf: 1,
     ArrayPush: 1
   });
-};
+}
 
 
 SetupArray();