Reland "Migrate error messages, part 2."

src/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() {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
@@ skipping 81 matching lines @@
 function SetConstructor(iterable) {
   if (!%_IsConstructCall()) {
     throw MakeTypeError('constructor_not_function', ['Set']);
   }
 
   %_SetInitialize(this);
 
   if (!IS_NULL_OR_UNDEFINED(iterable)) {
     var adder = this.add;
     if (!IS_SPEC_FUNCTION(adder)) {
-      throw MakeTypeError(kPropertyNotFunction, ['add', this]);
+      throw MakeTypeError(kPropertyNotFunction, 'add', this);
     }
 
     for (var value of iterable) {
       %_CallFunction(this, value, adder);
     }
   }
 }
 
 
 function SetAdd(key) {
   if (!IS_SET(this)) {
-    throw MakeTypeError('incompatible_method_receiver',
-                        ['Set.prototype.add', this]);
+    throw MakeTypeError(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('incompatible_method_receiver',
-                        ['Set.prototype.has', this]);
+    throw MakeTypeError(kIncompatibleMethodReceiver, 'Set.prototype.has', this);
   }
   var table = %_JSCollectionGetTable(this);
   var numBuckets = ORDERED_HASH_TABLE_BUCKET_COUNT(table);
   var hash = GetHash(key);
   return SetFindEntry(table, numBuckets, key, hash) !== NOT_FOUND;
 }
 
 
 function SetDelete(key) {
   if (!IS_SET(this)) {
-    throw MakeTypeError('incompatible_method_receiver',
-                        ['Set.prototype.delete', this]);
+    throw MakeTypeError(kIncompatibleMethodReceiver,
+                        'Set.prototype.delete', this);
   }
   var table = %_JSCollectionGetTable(this);
   var numBuckets = ORDERED_HASH_TABLE_BUCKET_COUNT(table);
   var hash = GetHash(key);
   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('incompatible_method_receiver',
-                        ['Set.prototype.size', this]);
+    throw MakeTypeError(kIncompatibleMethodReceiver,
+                        'Set.prototype.size', this);
   }
   var table = %_JSCollectionGetTable(this);
   return ORDERED_HASH_TABLE_ELEMENT_COUNT(table);
 }
 
 
 function SetClearJS() {
   if (!IS_SET(this)) {
-    throw MakeTypeError('incompatible_method_receiver',
-                        ['Set.prototype.clear', this]);
+    throw MakeTypeError(kIncompatibleMethodReceiver,
+                        'Set.prototype.clear', this);
   }
   %_SetClear(this);
 }
 
 
 function SetForEach(f, receiver) {
   if (!IS_SET(this)) {
-    throw MakeTypeError('incompatible_method_receiver',
-                        ['Set.prototype.forEach', this]);
+    throw MakeTypeError(kIncompatibleMethodReceiver,
+                        'Set.prototype.forEach', this);
   }
 
-  if (!IS_SPEC_FUNCTION(f)) {
-    throw MakeTypeError('called_non_callable', [f]);
-  }
+  if (!IS_SPEC_FUNCTION(f)) throw MakeTypeError(kCalledNonCallable, f);
   var needs_wrapper = false;
   if (IS_NULL_OR_UNDEFINED(receiver)) {
     receiver = %GetDefaultReceiver(f) || receiver;
   } else {
     needs_wrapper = SHOULD_CREATE_WRAPPER(f, receiver);
   }
 
   var iterator = new SetIterator(this, ITERATOR_KIND_VALUES);
   var key;
   var stepping = DEBUG_IS_ACTIVE && %DebugCallbackSupportsStepping(f);
@@ skipping 34 matching lines @@
 function MapConstructor(iterable) {
   if (!%_IsConstructCall()) {
     throw MakeTypeError('constructor_not_function', ['Map']);
   }
 
   %_MapInitialize(this);
 
   if (!IS_NULL_OR_UNDEFINED(iterable)) {
     var adder = this.set;
     if (!IS_SPEC_FUNCTION(adder)) {
-      throw MakeTypeError(kPropertyNotFunction, ['set', this]);
+      throw MakeTypeError(kPropertyNotFunction, 'set', this);
     }
 
     for (var nextItem of iterable) {
       if (!IS_SPEC_OBJECT(nextItem)) {
         throw MakeTypeError('iterator_value_not_an_object', [nextItem]);
       }
       %_CallFunction(this, nextItem[0], nextItem[1], adder);
     }
   }
 }
 
 
 function MapGet(key) {
   if (!IS_MAP(this)) {
-    throw MakeTypeError('incompatible_method_receiver',
-                        ['Map.prototype.get', this]);
+    throw MakeTypeError(kIncompatibleMethodReceiver,
+                        'Map.prototype.get', 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 UNDEFINED;
   return ORDERED_HASH_MAP_VALUE_AT(table, entry, numBuckets);
 }
 
 
 function MapSet(key, value) {
   if (!IS_MAP(this)) {
-    throw MakeTypeError('incompatible_method_receiver',
-                        ['Map.prototype.set', this]);
+    throw MakeTypeError(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;
   }
 
   var table = %_JSCollectionGetTable(this);
@@ skipping 26 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('incompatible_method_receiver',
-                        ['Map.prototype.has', this]);
+    throw MakeTypeError(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('incompatible_method_receiver',
-                        ['Map.prototype.delete', this]);
+    throw MakeTypeError(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('incompatible_method_receiver',
-                        ['Map.prototype.size', this]);
+    throw MakeTypeError(kIncompatibleMethodReceiver,
+                        'Map.prototype.size', this);
   }
   var table = %_JSCollectionGetTable(this);
   return ORDERED_HASH_TABLE_ELEMENT_COUNT(table);
 }
 
 
 function MapClearJS() {
   if (!IS_MAP(this)) {
-    throw MakeTypeError('incompatible_method_receiver',
-                        ['Map.prototype.clear', this]);
+    throw MakeTypeError(kIncompatibleMethodReceiver,
+                        'Map.prototype.clear', this);
   }
   %_MapClear(this);
 }
 
 
 function MapForEach(f, receiver) {
   if (!IS_MAP(this)) {
-    throw MakeTypeError('incompatible_method_receiver',
-                        ['Map.prototype.forEach', this]);
+    throw MakeTypeError(kIncompatibleMethodReceiver,
+                        'Map.prototype.forEach', this);
   }
 
-  if (!IS_SPEC_FUNCTION(f)) {
-    throw MakeTypeError('called_non_callable', [f]);
-  }
+  if (!IS_SPEC_FUNCTION(f)) throw MakeTypeError(kCalledNonCallable, f);
   var needs_wrapper = false;
   if (IS_NULL_OR_UNDEFINED(receiver)) {
     receiver = %GetDefaultReceiver(f) || receiver;
   } else {
     needs_wrapper = SHOULD_CREATE_WRAPPER(f, receiver);
   }
 
   var iterator = new MapIterator(this, ITERATOR_KIND_ENTRIES);
   var stepping = DEBUG_IS_ACTIVE && %DebugCallbackSupportsStepping(f);
   var value_array = [UNDEFINED, UNDEFINED];
@@ skipping 20 matching lines @@
 InstallFunctions(GlobalMap.prototype, DONT_ENUM, [
   "get", MapGet,
   "set", MapSet,
   "has", MapHas,
   "delete", MapDelete,
   "clear", MapClearJS,
   "forEach", MapForEach
 ]);
 
 })();