[builtins] Remove bunch of uses of %_Arguments and %_ArgumentsLength.

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 497 matching lines @@
   n--;
   var value = array[n];
   %DeleteProperty_Strict(array, n);
   array.length = n;
   return value;
 }
 
 
 function ObservedArrayPush() {
   var n = TO_LENGTH(this.length);
-  var m = %_ArgumentsLength();
+  var m = arguments.length;
 
   try {
     ObserveBeginPerformSplice(this);
     for (var i = 0; i < m; i++) {
-      this[i+n] = %_Arguments(i);
+      this[i+n] = arguments[i];
     }
     var new_length = n + m;
     this.length = new_length;
   } finally {
     ObserveEndPerformSplice(this);
     ObserveEnqueueSpliceRecord(this, n, [], m);
   }
 
   return new_length;
 }
 
 
 // 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() {
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.push");
 
   if (%IsObserved(this))
     return ObservedArrayPush.apply(this, arguments);
 
   var array = TO_OBJECT(this);
   var n = TO_LENGTH(array.length);
-  var m = %_ArgumentsLength();
+  var m = arguments.length;
 
   // It appears that there is no enforced, absolute limit on the number of
   // arguments, but it would surely blow the stack to use 2**30 or more.
   // To avoid integer overflow, do the comparison to the max safe integer
   // after subtracting 2**30 from both sides. (2**31 would seem like a
   // natural value, but it is negative in JS, and 2**32 is 1.)
   if (m > (1 << 30) || (n - (1 << 30)) + m > kMaxSafeInteger - (1 << 30)) {
     throw MakeTypeError(kPushPastSafeLength, m, n);
   }
 
   for (var i = 0; i < m; i++) {
-    array[i+n] = %_Arguments(i);
+    array[i+n] = arguments[i];
   }
 
   var new_length = n + m;
   array.length = new_length;
   return new_length;
 }
 
 
 // For implementing reverse() on large, sparse arrays.
 function SparseReverse(array, len) {
@@ skipping 135 matching lines @@
   }
 
   array.length = len - 1;
 
   return first;
 }
 
 
 function ObservedArrayUnshift() {
   var len = TO_LENGTH(this.length);
-  var num_arguments = %_ArgumentsLength();
+  var num_arguments = arguments.length;
 
   try {
     ObserveBeginPerformSplice(this);
     SimpleMove(this, 0, 0, len, num_arguments);
     for (var i = 0; i < num_arguments; i++) {
-      this[i] = %_Arguments(i);
+      this[i] = arguments[i];
     }
     var new_length = len + num_arguments;
     this.length = new_length;
   } finally {
     ObserveEndPerformSplice(this);
     ObserveEnqueueSpliceRecord(this, 0, [], num_arguments);
   }
 
   return new_length;
 }
 
 
 function ArrayUnshift(arg1) {  // length == 1
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.unshift");
 
   if (%IsObserved(this))
     return ObservedArrayUnshift.apply(this, arguments);
 
   var array = TO_OBJECT(this);
   var len = TO_LENGTH(array.length);
-  var num_arguments = %_ArgumentsLength();
+  var num_arguments = arguments.length;
 
   if (len > 0 && UseSparseVariant(array, len, IS_ARRAY(array), len) &&
       !%object_is_sealed(array)) {
     SparseMove(array, 0, 0, len, num_arguments);
   } else {
     SimpleMove(array, 0, 0, len, num_arguments);
   }
 
   for (var i = 0; i < num_arguments; i++) {
-    array[i] = %_Arguments(i);
+    array[i] = arguments[i];
   }
 
   var new_length = len + num_arguments;
   array.length = new_length;
   return new_length;
 }
 
 
 function ArraySlice(start, end) {
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.slice");
@@ skipping 62 matching lines @@
     return 0;
 
   if (del_count > len - start_i)
     return len - start_i;
 
   return del_count;
 }
 
 
 function ObservedArraySplice(start, delete_count) {
-  var num_arguments = %_ArgumentsLength();
+  var num_arguments = arguments.length;
   var len = TO_LENGTH(this.length);
   var start_i = ComputeSpliceStartIndex(TO_INTEGER(start), len);
   var del_count = ComputeSpliceDeleteCount(delete_count, num_arguments, len,
                                            start_i);
   var deleted_elements = [];
   deleted_elements.length = del_count;
   var num_elements_to_add = num_arguments > 2 ? num_arguments - 2 : 0;
 
   try {
     ObserveBeginPerformSplice(this);
 
     SimpleSlice(this, start_i, del_count, len, deleted_elements);
     SimpleMove(this, start_i, del_count, len, num_elements_to_add);
 
     // 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();
+    var arguments_length = arguments.length;
     while (arguments_index < arguments_length) {
-      this[i++] = %_Arguments(arguments_index++);
+      this[i++] = arguments[arguments_index++];
     }
     this.length = len - del_count + num_elements_to_add;
 
   } finally {
     ObserveEndPerformSplice(this);
     if (deleted_elements.length || num_elements_to_add) {
       ObserveEnqueueSpliceRecord(this,
                                  start_i,
                                  deleted_elements.slice(),
                                  num_elements_to_add);
     }
   }
 
   // Return the deleted elements.
   return deleted_elements;
 }
 
 
 function ArraySplice(start, delete_count) {
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.splice");
 
   if (%IsObserved(this))
     return ObservedArraySplice.apply(this, arguments);
 
-  var num_arguments = %_ArgumentsLength();
+  var num_arguments = arguments.length;
   var array = TO_OBJECT(this);
   var len = TO_LENGTH(array.length);
   var start_i = ComputeSpliceStartIndex(TO_INTEGER(start), len);
   var del_count = ComputeSpliceDeleteCount(delete_count, num_arguments, len,
                                            start_i);
   var deleted_elements = ArraySpeciesCreate(array, del_count);
   deleted_elements.length = del_count;
   var num_elements_to_add = num_arguments > 2 ? num_arguments - 2 : 0;
 
   if (del_count != num_elements_to_add && %object_is_sealed(array)) {
@@ skipping 15 matching lines @@
     SparseMove(array, start_i, del_count, len, num_elements_to_add);
   } else {
     SimpleSlice(array, start_i, del_count, len, deleted_elements);
     SimpleMove(array, start_i, del_count, len, num_elements_to_add);
   }
 
   // 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();
+  var arguments_length = arguments.length;
   while (arguments_index < arguments_length) {
-    array[i++] = %_Arguments(arguments_index++);
+    array[i++] = arguments[arguments_index++];
   }
   array.length = len - del_count + num_elements_to_add;
 
   // Return the deleted elements.
   return deleted_elements;
 }
 
 
 function InnerArraySort(array, length, comparefn) {
   // In-place QuickSort algorithm.
@@ skipping 533 matching lines @@
   }
   return -1;
 }
 
 
 function ArrayLastIndexOf(element, index) {
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.lastIndexOf");
 
   var length = TO_LENGTH(this.length);
   return InnerArrayLastIndexOf(this, element, index, length,
-                        %_ArgumentsLength());
+                               arguments.length);
 }
 
 
 function InnerArrayReduce(callback, current, array, length, argumentsLength) {
   if (!IS_CALLABLE(callback)) {
     throw MakeTypeError(kCalledNonCallable, callback);
   }
 
   var is_array = IS_ARRAY(array);
   var i = 0;
@@ skipping 18 matching lines @@
 
 
 function ArrayReduce(callback, current) {
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.reduce");
 
   // Pull out the length so that modifications to the length in the
   // loop will not affect the looping and side effects are visible.
   var array = TO_OBJECT(this);
   var length = TO_LENGTH(array.length);
   return InnerArrayReduce(callback, current, array, length,
-                          %_ArgumentsLength());
+                          arguments.length);
 }
 
 
 function InnerArrayReduceRight(callback, current, array, length,
                                argumentsLength) {
   if (!IS_CALLABLE(callback)) {
     throw MakeTypeError(kCalledNonCallable, callback);
   }
 
   var is_array = IS_ARRAY(array);
@@ skipping 19 matching lines @@
 
 
 function ArrayReduceRight(callback, current) {
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.reduceRight");
 
   // Pull out the length so that side effects are visible before the
   // callback function is checked.
   var array = TO_OBJECT(this);
   var length = TO_LENGTH(array.length);
   return InnerArrayReduceRight(callback, current, array, length,
-                               %_ArgumentsLength());
+                               arguments.length);
 }
 
 
 function InnerArrayCopyWithin(target, start, end, array, length) {
   target = TO_INTEGER(target);
   var to;
   if (target < 0) {
     to = MaxSimple(length + target, 0);
   } else {
     to = MinSimple(target, length);
@@ skipping 242 matching lines @@
       AddArrayElement(this, result, k, mappedValue);
     }
 
     result.length = k;
     return result;
   }
 }
 
 
 // ES6, draft 05-22-14, section 22.1.2.3
-function ArrayOf() {
-  var length = %_ArgumentsLength();
+function ArrayOf(...args) {
+  var length = args.length;
   var constructor = this;
   // TODO: Implement IsConstructor (ES6 section 7.2.5)
   var array = %IsConstructor(constructor) ? new constructor(length) : [];
   for (var i = 0; i < length; i++) {
-    AddArrayElement(constructor, array, i, %_Arguments(i));
+    AddArrayElement(constructor, array, i, args[i]);
   }
   array.length = length;
   return array;
 }
 
 // -------------------------------------------------------------------
 
 // Set up non-enumerable constructor property on the Array.prototype
 // object.
 %AddNamedProperty(GlobalArray.prototype, "constructor", GlobalArray,
@@ skipping 130 matching lines @@
 %InstallToContext([
   "array_pop", ArrayPop,
   "array_push", ArrayPush,
   "array_shift", ArrayShift,
   "array_splice", ArraySplice,
   "array_slice", ArraySlice,
   "array_unshift", ArrayUnshift,
 ]);
 
 });