Move family of MakeError functions to C++

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();
 
 // -------------------------------------------------------------------
 // Imports
 
 var GetIterator;
 var GetMethod;
 var GlobalArray = global.Array;
 var InternalArray = utils.InternalArray;
 var InternalPackedArray = utils.InternalPackedArray;
-var MakeTypeError;
 var MaxSimple;
 var MinSimple;
 var ObjectHasOwnProperty;
 var ObjectToString = utils.ImportNow("object_to_string");
 var iteratorSymbol = utils.ImportNow("iterator_symbol");
 var speciesSymbol = utils.ImportNow("species_symbol");
 var unscopablesSymbol = utils.ImportNow("unscopables_symbol");
 
 utils.Import(function(from) {
   GetIterator = from.GetIterator;
   GetMethod = from.GetMethod;
-  MakeTypeError = from.MakeTypeError;
   MaxSimple = from.MaxSimple;
   MinSimple = from.MinSimple;
   ObjectHasOwnProperty = from.ObjectHasOwnProperty;
 });
 
 // -------------------------------------------------------------------
 
 
 function ArraySpeciesCreate(array, length) {
   length = INVERT_NEG_ZERO(length);
@@ skipping 375 matching lines @@
 function ArrayPush() {
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.push");
 
   var array = TO_OBJECT(this);
   var n = TO_LENGTH(array.length);
   var m = arguments.length;
 
   // Subtract n from kMaxSafeInteger rather than testing m + n >
   // kMaxSafeInteger. n may already be kMaxSafeInteger. In that case adding
   // e.g., 1 would not be safe.
-  if (m > kMaxSafeInteger - n) throw MakeTypeError(kPushPastSafeLength, m, n);
+  if (m > kMaxSafeInteger - n) throw %make_type_error(kPushPastSafeLength, m, n);
 
   for (var i = 0; i < m; i++) {
     array[i+n] = arguments[i];
   }
 
   var new_length = n + m;
   array.length = new_length;
   return new_length;
 }
 
@@ skipping 101 matching lines @@
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.shift");
 
   var array = TO_OBJECT(this);
   var len = TO_LENGTH(array.length);
 
   if (len === 0) {
     array.length = 0;
     return;
   }
 
-  if (%object_is_sealed(array)) throw MakeTypeError(kArrayFunctionsOnSealed);
+  if (%object_is_sealed(array)) throw %make_type_error(kArrayFunctionsOnSealed);
 
   var first = array[0];
 
   if (UseSparseVariant(array, len, IS_ARRAY(array), len)) {
     SparseMove(array, 0, 1, len, 0);
   } else {
     SimpleMove(array, 0, 1, len, 0);
   }
 
   array.length = len - 1;
@@ skipping 106 matching lines @@
   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)) {
-    throw MakeTypeError(kArrayFunctionsOnSealed);
+    throw %make_type_error(kArrayFunctionsOnSealed);
   } else if (del_count > 0 && %object_is_frozen(array)) {
-    throw MakeTypeError(kArrayFunctionsOnFrozen);
+    throw %make_type_error(kArrayFunctionsOnFrozen);
   }
 
   var changed_elements = del_count;
   if (num_elements_to_add != del_count) {
     // If the slice needs to do a actually move elements after the insertion
     // point, then include those in the estimate of changed elements.
     changed_elements += len - start_i - del_count;
   }
   if (UseSparseVariant(array, len, IS_ARRAY(array), changed_elements)) {
     %NormalizeElements(array);
@@ skipping 335 matching lines @@
 
 
 
 function ArrayFilter(f, receiver) {
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.filter");
 
   // 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);
-  if (!IS_CALLABLE(f)) throw MakeTypeError(kCalledNonCallable, f);
+  if (!IS_CALLABLE(f)) throw %make_type_error(kCalledNonCallable, f);
   var result = ArraySpeciesCreate(array, 0);
   return InnerArrayFilter(f, receiver, array, length, result);
 }
 
 
 function InnerArrayForEach(f, receiver, array, length) {
-  if (!IS_CALLABLE(f)) throw MakeTypeError(kCalledNonCallable, f);
+  if (!IS_CALLABLE(f)) throw %make_type_error(kCalledNonCallable, f);
 
   if (IS_UNDEFINED(receiver)) {
     for (var i = 0; i < length; i++) {
       if (i in array) {
         var element = array[i];
         f(element, i, array);
       }
     }
   } else {
     for (var i = 0; i < length; i++) {
@@ skipping 11 matching lines @@
 
   // 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);
   InnerArrayForEach(f, receiver, array, length);
 }
 
 
 function InnerArraySome(f, receiver, array, length) {
-  if (!IS_CALLABLE(f)) throw MakeTypeError(kCalledNonCallable, f);
+  if (!IS_CALLABLE(f)) throw %make_type_error(kCalledNonCallable, f);
 
   for (var i = 0; i < length; i++) {
     if (i in array) {
       var element = array[i];
       if (%_Call(f, receiver, element, i, array)) return true;
     }
   }
   return false;
 }
 
 
 // Executes the function once for each element present in the
 // array until it finds one where callback returns true.
 function ArraySome(f, receiver) {
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.some");
 
   // 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 InnerArraySome(f, receiver, array, length);
 }
 
 
 function InnerArrayEvery(f, receiver, array, length) {
-  if (!IS_CALLABLE(f)) throw MakeTypeError(kCalledNonCallable, f);
+  if (!IS_CALLABLE(f)) throw %make_type_error(kCalledNonCallable, f);
 
   for (var i = 0; i < length; i++) {
     if (i in array) {
       var element = array[i];
       if (!%_Call(f, receiver, element, i, array)) return false;
     }
   }
   return true;
 }
 
 function ArrayEvery(f, receiver) {
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.every");
 
   // 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 InnerArrayEvery(f, receiver, array, length);
 }
 
 
 function ArrayMap(f, receiver) {
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.map");
 
   // 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);
-  if (!IS_CALLABLE(f)) throw MakeTypeError(kCalledNonCallable, f);
+  if (!IS_CALLABLE(f)) throw %make_type_error(kCalledNonCallable, f);
   var result = ArraySpeciesCreate(array, length);
   for (var i = 0; i < length; i++) {
     if (i in array) {
       var element = array[i];
       %CreateDataProperty(result, i, %_Call(f, receiver, element, i, array));
     }
   }
   return result;
 }
 
@@ skipping 118 matching lines @@
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.lastIndexOf");
 
   var length = TO_LENGTH(this.length);
   return InnerArrayLastIndexOf(this, element, index, length,
                                arguments.length);
 }
 
 
 function InnerArrayReduce(callback, current, array, length, argumentsLength) {
   if (!IS_CALLABLE(callback)) {
-    throw MakeTypeError(kCalledNonCallable, callback);
+    throw %make_type_error(kCalledNonCallable, callback);
   }
 
   var i = 0;
   find_initial: if (argumentsLength < 2) {
     for (; i < length; i++) {
       if (i in array) {
         current = array[i++];
         break find_initial;
       }
     }
-    throw MakeTypeError(kReduceNoInitial);
+    throw %make_type_error(kReduceNoInitial);
   }
 
   for (; i < length; i++) {
     if (i in array) {
       var element = array[i];
       current = callback(current, element, i, array);
     }
   }
   return current;
 }
 
 
 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,
                           arguments.length);
 }
 
 
 function InnerArrayReduceRight(callback, current, array, length,
                                argumentsLength) {
   if (!IS_CALLABLE(callback)) {
-    throw MakeTypeError(kCalledNonCallable, callback);
+    throw %make_type_error(kCalledNonCallable, callback);
   }
 
   var i = length - 1;
   find_initial: if (argumentsLength < 2) {
     for (; i >= 0; i--) {
       if (i in array) {
         current = array[i--];
         break find_initial;
       }
     }
-    throw MakeTypeError(kReduceNoInitial);
+    throw %make_type_error(kReduceNoInitial);
   }
 
   for (; i >= 0; i--) {
     if (i in array) {
       var element = array[i];
       current = callback(current, element, i, array);
     }
   }
   return current;
 }
@@ skipping 65 matching lines @@
 
   var array = TO_OBJECT(this);
   var length = TO_LENGTH(array.length);
 
   return InnerArrayCopyWithin(target, start, end, array, length);
 }
 
 
 function InnerArrayFind(predicate, thisArg, array, length) {
   if (!IS_CALLABLE(predicate)) {
-    throw MakeTypeError(kCalledNonCallable, predicate);
+    throw %make_type_error(kCalledNonCallable, predicate);
   }
 
   for (var i = 0; i < length; i++) {
     var element = array[i];
     if (%_Call(predicate, thisArg, element, i, array)) {
       return element;
     }
   }
 
   return;
 }
 
 
 // ES6 draft 07-15-13, section 15.4.3.23
 function ArrayFind(predicate, thisArg) {
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.find");
 
   var array = TO_OBJECT(this);
   var length = TO_INTEGER(array.length);
 
   return InnerArrayFind(predicate, thisArg, array, length);
 }
 
 
 function InnerArrayFindIndex(predicate, thisArg, array, length) {
   if (!IS_CALLABLE(predicate)) {
-    throw MakeTypeError(kCalledNonCallable, predicate);
+    throw %make_type_error(kCalledNonCallable, predicate);
   }
 
   for (var i = 0; i < length; i++) {
     var element = array[i];
     if (%_Call(predicate, thisArg, element, i, array)) {
       return i;
     }
   }
 
   return -1;
@@ skipping 24 matching lines @@
   }
 
   if (end < 0) {
     end += length;
     if (end < 0) end = 0;
   } else {
     if (end > length) end = length;
   }
 
   if ((end - i) > 0 && %object_is_frozen(array)) {
-    throw MakeTypeError(kArrayFunctionsOnFrozen);
+    throw %make_type_error(kArrayFunctionsOnFrozen);
   }
 
   for (; i < end; i++)
     array[i] = value;
   return array;
 }
 
 
 // ES6, draft 04-05-14, section 22.1.3.6
 function ArrayFill(value, start, end) {
   CHECK_OBJECT_COERCIBLE(this, "Array.prototype.fill");
 
   var array = TO_OBJECT(this);
   var length = TO_LENGTH(array.length);
 
   return InnerArrayFill(value, start, end, array, length);
 }
 
 
 // ES6, draft 10-14-14, section 22.1.2.1
 function ArrayFrom(arrayLike, mapfn, receiver) {
   var items = TO_OBJECT(arrayLike);
   var mapping = !IS_UNDEFINED(mapfn);
 
   if (mapping) {
     if (!IS_CALLABLE(mapfn)) {
-      throw MakeTypeError(kCalledNonCallable, mapfn);
+      throw %make_type_error(kCalledNonCallable, mapfn);
     }
   }
 
   var iterable = GetMethod(items, iteratorSymbol);
   var k;
   var result;
   var mappedValue;
   var nextValue;
 
   if (!IS_UNDEFINED(iterable)) {
@@ skipping 191 matching lines @@
 %InstallToContext([
   "array_pop", ArrayPop,
   "array_push", ArrayPush,
   "array_shift", ArrayShift,
   "array_splice", ArraySplice,
   "array_slice", ArraySlice,
   "array_unshift", ArrayUnshift,
 ]);
 
 });