Move family of MakeError functions to C++

src/js/collection.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) {
 "use strict";
 
 %CheckIsBootstrapping();
 
 // -------------------------------------------------------------------
 // Imports
 
 var GlobalMap = global.Map;
 var GlobalObject = global.Object;
 var GlobalSet = global.Set;
 var hashCodeSymbol = utils.ImportNow("hash_code_symbol");
 var MathRandom;
-var MakeTypeError;
 var MapIterator;
 var NumberIsNaN;
 var SetIterator;
 var speciesSymbol = utils.ImportNow("species_symbol");
 var toStringTagSymbol = utils.ImportNow("to_string_tag_symbol");
 
 utils.Import(function(from) {
   MathRandom = from.MathRandom;
-  MakeTypeError = from.MakeTypeError;
   MapIterator = from.MapIterator;
   NumberIsNaN = from.NumberIsNaN;
   SetIterator = from.SetIterator;
 });
 
 // -------------------------------------------------------------------
 
 function HashToEntry(table, hash, numBuckets) {
   var bucket = ORDERED_HASH_TABLE_HASH_TO_BUCKET(hash, numBuckets);
   return ORDERED_HASH_TABLE_BUCKET_AT(table, bucket);
@@ skipping 82 matching lines @@
   return hash;
 }
 %SetForceInlineFlag(GetHash);
 
 
 // -------------------------------------------------------------------
 // Harmony Set
 
 function SetConstructor(iterable) {
   if (IS_UNDEFINED(new.target)) {
-    throw MakeTypeError(kConstructorNotFunction, "Set");
+    throw %make_type_error(kConstructorNotFunction, "Set");
   }
 
   %_SetInitialize(this);
 
   if (!IS_NULL_OR_UNDEFINED(iterable)) {
     var adder = this.add;
     if (!IS_CALLABLE(adder)) {
-      throw MakeTypeError(kPropertyNotFunction, adder, 'add', this);
+      throw %make_type_error(kPropertyNotFunction, adder, 'add', this);
     }
 
     for (var value of iterable) {
       %_Call(adder, this, value);
     }
   }
 }
 
 
 function SetAdd(key) {
   if (!IS_SET(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver, 'Set.prototype.add', this);
+    throw %make_type_error(kIncompatibleMethodReceiver, 'Set.prototype.add', this);
   }
   // Normalize -0 to +0 as required by the spec.
   // Even though we use SameValueZero as the comparison for the keys we don't
   // want to ever store -0 as the key since the key is directly exposed when
   // doing iteration.
   if (key === 0) {
     key = 0;
   }
   var table = %_JSCollectionGetTable(this);
   var numBuckets = ORDERED_HASH_TABLE_BUCKET_COUNT(table);
@@ skipping 19 matching lines @@
   ORDERED_HASH_TABLE_SET_BUCKET_AT(table, bucket, entry);
   ORDERED_HASH_TABLE_SET_ELEMENT_COUNT(table, nof + 1);
   FIXED_ARRAY_SET(table, index, key);
   FIXED_ARRAY_SET_SMI(table, index + 1, chainEntry);
   return this;
 }
 
 
 function SetHas(key) {
   if (!IS_SET(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver, 'Set.prototype.has', this);
+    throw %make_type_error(kIncompatibleMethodReceiver, 'Set.prototype.has', this);
   }
   var table = %_JSCollectionGetTable(this);
   var numBuckets = ORDERED_HASH_TABLE_BUCKET_COUNT(table);
   var hash = GetExistingHash(key);
   if (IS_UNDEFINED(hash)) return false;
   return SetFindEntry(table, numBuckets, key, hash) !== NOT_FOUND;
 }
 
 
 function SetDelete(key) {
   if (!IS_SET(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         'Set.prototype.delete', this);
   }
   var table = %_JSCollectionGetTable(this);
   var numBuckets = ORDERED_HASH_TABLE_BUCKET_COUNT(table);
   var hash = GetExistingHash(key);
   if (IS_UNDEFINED(hash)) return false;
   var entry = SetFindEntry(table, numBuckets, key, hash);
   if (entry === NOT_FOUND) return false;
 
   var nof = ORDERED_HASH_TABLE_ELEMENT_COUNT(table) - 1;
   var nod = ORDERED_HASH_TABLE_DELETED_COUNT(table) + 1;
   var index = ORDERED_HASH_SET_ENTRY_TO_INDEX(entry, numBuckets);
   FIXED_ARRAY_SET(table, index, %_TheHole());
   ORDERED_HASH_TABLE_SET_ELEMENT_COUNT(table, nof);
   ORDERED_HASH_TABLE_SET_DELETED_COUNT(table, nod);
   if (nof < (numBuckets >>> 1)) %SetShrink(this);
   return true;
 }
 
 
 function SetGetSize() {
   if (!IS_SET(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         'Set.prototype.size', this);
   }
   var table = %_JSCollectionGetTable(this);
   return ORDERED_HASH_TABLE_ELEMENT_COUNT(table);
 }
 
 
 function SetClearJS() {
   if (!IS_SET(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         'Set.prototype.clear', this);
   }
   %_SetClear(this);
 }
 
 
 function SetForEach(f, receiver) {
   if (!IS_SET(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         'Set.prototype.forEach', this);
   }
 
-  if (!IS_CALLABLE(f)) throw MakeTypeError(kCalledNonCallable, f);
+  if (!IS_CALLABLE(f)) throw %make_type_error(kCalledNonCallable, f);
 
   var iterator = new SetIterator(this, ITERATOR_KIND_VALUES);
   var key;
   var value_array = [UNDEFINED];
   while (%SetIteratorNext(iterator, value_array)) {
     key = value_array[0];
     %_Call(f, receiver, key, key, this);
   }
 }
 
@@ skipping 25 matching lines @@
   "clear", SetClearJS,
   "forEach", SetForEach
 ]);
 
 
 // -------------------------------------------------------------------
 // Harmony Map
 
 function MapConstructor(iterable) {
   if (IS_UNDEFINED(new.target)) {
-    throw MakeTypeError(kConstructorNotFunction, "Map");
+    throw %make_type_error(kConstructorNotFunction, "Map");
   }
 
   %_MapInitialize(this);
 
   if (!IS_NULL_OR_UNDEFINED(iterable)) {
     var adder = this.set;
     if (!IS_CALLABLE(adder)) {
-      throw MakeTypeError(kPropertyNotFunction, adder, 'set', this);
+      throw %make_type_error(kPropertyNotFunction, adder, 'set', this);
     }
 
     for (var nextItem of iterable) {
       if (!IS_RECEIVER(nextItem)) {
-        throw MakeTypeError(kIteratorValueNotAnObject, nextItem);
+        throw %make_type_error(kIteratorValueNotAnObject, nextItem);
       }
       %_Call(adder, this, nextItem[0], nextItem[1]);
     }
   }
 }
 
 
 function MapGet(key) {
   if (!IS_MAP(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         'Map.prototype.get', this);
   }
   var table = %_JSCollectionGetTable(this);
   var numBuckets = ORDERED_HASH_TABLE_BUCKET_COUNT(table);
   var hash = GetExistingHash(key);
   if (IS_UNDEFINED(hash)) return UNDEFINED;
   var entry = MapFindEntry(table, numBuckets, key, hash);
   if (entry === NOT_FOUND) return UNDEFINED;
   return ORDERED_HASH_MAP_VALUE_AT(table, entry, numBuckets);
 }
 
 
 function MapSet(key, value) {
   if (!IS_MAP(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         'Map.prototype.set', this);
   }
   // Normalize -0 to +0 as required by the spec.
   // Even though we use SameValueZero as the comparison for the keys we don't
   // want to ever store -0 as the key since the key is directly exposed when
   // doing iteration.
   if (key === 0) {
     key = 0;
   }
 
@@ skipping 27 matching lines @@
   ORDERED_HASH_TABLE_SET_ELEMENT_COUNT(table, nof + 1);
   FIXED_ARRAY_SET(table, index, key);
   FIXED_ARRAY_SET(table, index + 1, value);
   FIXED_ARRAY_SET(table, index + 2, chainEntry);
   return this;
 }
 
 
 function MapHas(key) {
   if (!IS_MAP(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         'Map.prototype.has', this);
   }
   var table = %_JSCollectionGetTable(this);
   var numBuckets = ORDERED_HASH_TABLE_BUCKET_COUNT(table);
   var hash = GetHash(key);
   return MapFindEntry(table, numBuckets, key, hash) !== NOT_FOUND;
 }
 
 
 function MapDelete(key) {
   if (!IS_MAP(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         'Map.prototype.delete', this);
   }
   var table = %_JSCollectionGetTable(this);
   var numBuckets = ORDERED_HASH_TABLE_BUCKET_COUNT(table);
   var hash = GetHash(key);
   var entry = MapFindEntry(table, numBuckets, key, hash);
   if (entry === NOT_FOUND) return false;
 
   var nof = ORDERED_HASH_TABLE_ELEMENT_COUNT(table) - 1;
   var nod = ORDERED_HASH_TABLE_DELETED_COUNT(table) + 1;
   var index = ORDERED_HASH_MAP_ENTRY_TO_INDEX(entry, numBuckets);
   FIXED_ARRAY_SET(table, index, %_TheHole());
   FIXED_ARRAY_SET(table, index + 1, %_TheHole());
   ORDERED_HASH_TABLE_SET_ELEMENT_COUNT(table, nof);
   ORDERED_HASH_TABLE_SET_DELETED_COUNT(table, nod);
   if (nof < (numBuckets >>> 1)) %MapShrink(this);
   return true;
 }
 
 
 function MapGetSize() {
   if (!IS_MAP(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         'Map.prototype.size', this);
   }
   var table = %_JSCollectionGetTable(this);
   return ORDERED_HASH_TABLE_ELEMENT_COUNT(table);
 }
 
 
 function MapClearJS() {
   if (!IS_MAP(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         'Map.prototype.clear', this);
   }
   %_MapClear(this);
 }
 
 
 function MapForEach(f, receiver) {
   if (!IS_MAP(this)) {
-    throw MakeTypeError(kIncompatibleMethodReceiver,
+    throw %make_type_error(kIncompatibleMethodReceiver,
                         'Map.prototype.forEach', this);
   }
 
-  if (!IS_CALLABLE(f)) throw MakeTypeError(kCalledNonCallable, f);
+  if (!IS_CALLABLE(f)) throw %make_type_error(kCalledNonCallable, f);
 
   var iterator = new MapIterator(this, ITERATOR_KIND_ENTRIES);
   var value_array = [UNDEFINED, UNDEFINED];
   while (%MapIteratorNext(iterator, value_array)) {
     %_Call(f, receiver, value_array[1], value_array[0], this);
   }
 }
 
 
 function MapSpecies() {
@@ skipping 36 matching lines @@
   "set_has", SetHas,
   "set_delete", SetDelete,
 ]);
 
 utils.Export(function(to) {
   to.GetExistingHash = GetExistingHash;
   to.GetHash = GetHash;
 });
 
 })