Migrate error messages, part 4 (v8natives.js).

src/v8natives.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.
 
 // This file relies on the fact that the following declarations have been made
 // in runtime.js:
 // var $Object = global.Object;
 // var $Boolean = global.Boolean;
 // var $Number = global.Number;
 // var $Function = global.Function;
@@ skipping 282 matching lines @@
 }
 
 
 // Extensions for providing property getters and setters.
 function ObjectDefineGetter(name, fun) {
   var receiver = this;
   if (receiver == null && !IS_UNDETECTABLE(receiver)) {
     receiver = %GlobalProxy(global);
   }
   if (!IS_SPEC_FUNCTION(fun)) {
-    throw new $TypeError(
-        'Object.prototype.__defineGetter__: Expecting function');
+    throw MakeTypeError(kObjectGetterExpectingFunction);
   }
   var desc = new PropertyDescriptor();
   desc.setGet(fun);
   desc.setEnumerable(true);
   desc.setConfigurable(true);
   DefineOwnProperty(TO_OBJECT_INLINE(receiver), ToName(name), desc, false);
 }
 
 
 function ObjectLookupGetter(name) {
   var receiver = this;
   if (receiver == null && !IS_UNDETECTABLE(receiver)) {
     receiver = %GlobalProxy(global);
   }
   return %LookupAccessor(TO_OBJECT_INLINE(receiver), ToName(name), GETTER);
 }
 
 
 function ObjectDefineSetter(name, fun) {
   var receiver = this;
   if (receiver == null && !IS_UNDETECTABLE(receiver)) {
     receiver = %GlobalProxy(global);
   }
   if (!IS_SPEC_FUNCTION(fun)) {
-    throw new $TypeError(
-        'Object.prototype.__defineSetter__: Expecting function');
+    throw MakeTypeError(kObjectSetterExpectingFunction);
   }
   var desc = new PropertyDescriptor();
   desc.setSet(fun);
   desc.setEnumerable(true);
   desc.setConfigurable(true);
   DefineOwnProperty(TO_OBJECT_INLINE(receiver), ToName(name), desc, false);
 }
 
 
 function ObjectLookupSetter(name) {
@@ skipping 82 matching lines @@
   }
   if (desc.hasConfigurable()) {
     %AddNamedProperty(obj, "configurable", desc.isConfigurable(), NONE);
   }
   return obj;
 }
 
 
 // ES5 8.10.5.
 function ToPropertyDescriptor(obj) {
-  if (!IS_SPEC_OBJECT(obj)) {
-    throw MakeTypeError("property_desc_object", [obj]);
-  }
+  if (!IS_SPEC_OBJECT(obj)) throw MakeTypeError(kPropertyDescObject, obj);
+
   var desc = new PropertyDescriptor();
 
   if ("enumerable" in obj) {
     desc.setEnumerable(ToBoolean(obj.enumerable));
   }
 
   if ("configurable" in obj) {
     desc.setConfigurable(ToBoolean(obj.configurable));
   }
 
   if ("value" in obj) {
     desc.setValue(obj.value);
   }
 
   if ("writable" in obj) {
     desc.setWritable(ToBoolean(obj.writable));
   }
 
   if ("get" in obj) {
     var get = obj.get;
     if (!IS_UNDEFINED(get) && !IS_SPEC_FUNCTION(get)) {
-      throw MakeTypeError("getter_must_be_callable", [get]);
+      throw MakeTypeError(kObjectGetterCallable, get);
     }
     desc.setGet(get);
   }
 
   if ("set" in obj) {
     var set = obj.set;
     if (!IS_UNDEFINED(set) && !IS_SPEC_FUNCTION(set)) {
-      throw MakeTypeError("setter_must_be_callable", [set]);
+      throw MakeTypeError(kObjectSetterCallable, set);
     }
     desc.setSet(set);
   }
 
   if (IsInconsistentDescriptor(desc)) {
-    throw MakeTypeError("value_and_accessor", [obj]);
+    throw MakeTypeError(kValueAndAccessor, obj);
   }
   return desc;
 }
 
 
 // For Harmony proxies.
 function ToCompletePropertyDescriptor(obj) {
   var desc = ToPropertyDescriptor(obj);
   if (IsGenericDescriptor(desc) || IsDataDescriptor(desc)) {
     if (!desc.hasValue()) desc.setValue(UNDEFINED);
@@ skipping 129 matching lines @@
 
   return desc;
 }
 
 
 // For Harmony proxies.
 function GetTrap(handler, name, defaultTrap) {
   var trap = handler[name];
   if (IS_UNDEFINED(trap)) {
     if (IS_UNDEFINED(defaultTrap)) {
-      throw MakeTypeError("handler_trap_missing", [handler, name]);
+      throw MakeTypeError(kProxyHandlerTrapMissing, handler, name);
     }
     trap = defaultTrap;
   } else if (!IS_SPEC_FUNCTION(trap)) {
-    throw MakeTypeError("handler_trap_must_be_callable", [handler, name]);
+    throw MakeTypeError(kProxyHandlerTrapMustBeCallable, handler, name);
   }
   return trap;
 }
 
 
 function CallTrap0(handler, name, defaultTrap) {
   return %_CallFunction(handler, GetTrap(handler, name, defaultTrap));
 }
 
 
@@ skipping 13 matching lines @@
   if (%_IsJSProxy(obj)) {
     // TODO(rossberg): adjust once there is a story for symbols vs proxies.
     if (IS_SYMBOL(v)) return UNDEFINED;
 
     var handler = %GetHandler(obj);
     var descriptor = CallTrap1(
                          handler, "getOwnPropertyDescriptor", UNDEFINED, p);
     if (IS_UNDEFINED(descriptor)) return descriptor;
     var desc = ToCompletePropertyDescriptor(descriptor);
     if (!desc.isConfigurable()) {
-      throw MakeTypeError("proxy_prop_not_configurable",
-                          [handler, "getOwnPropertyDescriptor", p, descriptor]);
+      throw MakeTypeError(kProxyPropNotConfigurable,
+                          handler, p, "getOwnPropertyDescriptor");
     }
     return desc;
   }
 
   // GetOwnProperty returns an array indexed by the constants
   // defined in macros.py.
   // If p is not a property on obj undefined is returned.
   var props = %GetOwnProperty(TO_OBJECT_INLINE(obj), p);
 
   return ConvertDescriptorArrayToDescriptor(props);
 }
 
 
 // ES5 section 8.12.7.
 function Delete(obj, p, should_throw) {
   var desc = GetOwnPropertyJS(obj, p);
   if (IS_UNDEFINED(desc)) return true;
   if (desc.isConfigurable()) {
     %DeleteProperty(obj, p, 0);
     return true;
   } else if (should_throw) {
-    throw MakeTypeError("define_disallowed", [p]);
+    throw MakeTypeError(kDefineDisallowed, p);
   } else {
     return;
   }
 }
 
 
 // ES6, draft 12-24-14, section 7.3.8
 function GetMethod(obj, p) {
   var func = obj[p];
   if (IS_NULL_OR_UNDEFINED(func)) return UNDEFINED;
   if (IS_SPEC_FUNCTION(func)) return func;
   throw MakeTypeError(kCalledNonCallable, typeof func);
 }
 
 
 // Harmony proxies.
 function DefineProxyProperty(obj, p, attributes, should_throw) {
   // TODO(rossberg): adjust once there is a story for symbols vs proxies.
   if (IS_SYMBOL(p)) return false;
 
   var handler = %GetHandler(obj);
   var result = CallTrap2(handler, "defineProperty", UNDEFINED, p, attributes);
   if (!ToBoolean(result)) {
     if (should_throw) {
-      throw MakeTypeError("handler_returned_false",
-                          [handler, "defineProperty"]);
+      throw MakeTypeError(kProxyHandlerReturned,
+                          handler, "false", "defineProperty");
     } else {
       return false;
     }
   }
   return true;
 }
 
 
 // ES5 8.12.9.
 function DefineObjectProperty(obj, p, desc, should_throw) {
   var current_array = %GetOwnProperty(obj, ToName(p));
   var current = ConvertDescriptorArrayToDescriptor(current_array);
   var extensible = %IsExtensible(obj);
 
   // Error handling according to spec.
   // Step 3
   if (IS_UNDEFINED(current) && !extensible) {
     if (should_throw) {
-      throw MakeTypeError("define_disallowed", [p]);
+      throw MakeTypeError(kDefineDisallowed, p);
     } else {
       return false;
     }
   }
 
   if (!IS_UNDEFINED(current)) {
     // Step 5 and 6
     if ((IsGenericDescriptor(desc) ||
          IsDataDescriptor(desc) == IsDataDescriptor(current)) &&
         (!desc.hasEnumerable() ||
          SameValue(desc.isEnumerable(), current.isEnumerable())) &&
         (!desc.hasConfigurable() ||
          SameValue(desc.isConfigurable(), current.isConfigurable())) &&
         (!desc.hasWritable() ||
          SameValue(desc.isWritable(), current.isWritable())) &&
         (!desc.hasValue() ||
          SameValue(desc.getValue(), current.getValue())) &&
         (!desc.hasGetter() ||
          SameValue(desc.getGet(), current.getGet())) &&
         (!desc.hasSetter() ||
          SameValue(desc.getSet(), current.getSet()))) {
       return true;
     }
     if (!current.isConfigurable()) {
       // Step 7
       if (desc.isConfigurable() ||
           (desc.hasEnumerable() &&
            desc.isEnumerable() != current.isEnumerable())) {
         if (should_throw) {
-          throw MakeTypeError("redefine_disallowed", [p]);
+          throw MakeTypeError(kRedefineDisallowed, p);
         } else {
           return false;
         }
       }
       // Step 8
       if (!IsGenericDescriptor(desc)) {
         // Step 9a
         if (IsDataDescriptor(current) != IsDataDescriptor(desc)) {
           if (should_throw) {
-            throw MakeTypeError("redefine_disallowed", [p]);
+            throw MakeTypeError(kRedefineDisallowed, p);
           } else {
             return false;
           }
         }
         // Step 10a
         if (IsDataDescriptor(current) && IsDataDescriptor(desc)) {
           if (!current.isWritable() && desc.isWritable()) {
             if (should_throw) {
-              throw MakeTypeError("redefine_disallowed", [p]);
+              throw MakeTypeError(kRedefineDisallowed, p);
             } else {
               return false;
             }
           }
           if (!current.isWritable() && desc.hasValue() &&
               !SameValue(desc.getValue(), current.getValue())) {
             if (should_throw) {
-              throw MakeTypeError("redefine_disallowed", [p]);
+              throw MakeTypeError(kRedefineDisallowed, p);
             } else {
               return false;
             }
           }
         }
         // Step 11
         if (IsAccessorDescriptor(desc) && IsAccessorDescriptor(current)) {
           if (desc.hasSetter() && !SameValue(desc.getSet(), current.getSet())) {
             if (should_throw) {
-              throw MakeTypeError("redefine_disallowed", [p]);
+              throw MakeTypeError(kRedefineDisallowed, p);
             } else {
               return false;
             }
           }
           if (desc.hasGetter() && !SameValue(desc.getGet(),current.getGet())) {
             if (should_throw) {
-              throw MakeTypeError("redefine_disallowed", [p]);
+              throw MakeTypeError(kRedefineDisallowed, p);
             } else {
               return false;
             }
           }
         }
       }
     }
   }
 
   // Send flags - enumerable and configurable are common - writable is
@@ skipping 75 matching lines @@
 
   // Step 3 - Special handling for length property.
   if (p === "length") {
     var length = obj.length;
     var old_length = length;
     if (!desc.hasValue()) {
       return DefineObjectProperty(obj, "length", desc, should_throw);
     }
     var new_length = ToUint32(desc.getValue());
     if (new_length != ToNumber(desc.getValue())) {
-      throw new $RangeError('defineProperty() array length out of range');
+      throw MakeRangeError(kArrayLengthOutOfRange);
     }
     var length_desc = GetOwnPropertyJS(obj, "length");
     if (new_length != length && !length_desc.isWritable()) {
       if (should_throw) {
-        throw MakeTypeError("redefine_disallowed", [p]);
+        throw MakeTypeError(kRedefineDisallowed, p);
       } else {
         return false;
       }
     }
     var threw = false;
 
     var emit_splice = %IsObserved(obj) && new_length !== old_length;
     var removed;
     if (emit_splice) {
       $observeBeginPerformSplice(obj);
@@ skipping 18 matching lines @@
     threw = !DefineObjectProperty(obj, "length", desc, should_throw) || threw;
     if (emit_splice) {
       $observeEndPerformSplice(obj);
       $observeEnqueueSpliceRecord(obj,
           new_length < old_length ? new_length : old_length,
           removed,
           new_length > old_length ? new_length - old_length : 0);
     }
     if (threw) {
       if (should_throw) {
-        throw MakeTypeError("redefine_disallowed", [p]);
+        throw MakeTypeError(kRedefineDisallowed, p);
       } else {
         return false;
       }
     }
     return true;
   }
 
   // Step 4 - Special handling for array index.
   if (!IS_SYMBOL(p)) {
     var index = ToUint32(p);
     var emit_splice = false;
     if (ToString(index) == p && index != 4294967295) {
       var length = obj.length;
       if (index >= length && %IsObserved(obj)) {
         emit_splice = true;
         $observeBeginPerformSplice(obj);
       }
 
       var length_desc = GetOwnPropertyJS(obj, "length");
       if ((index >= length && !length_desc.isWritable()) ||
           !DefineObjectProperty(obj, p, desc, true)) {
         if (emit_splice)
           $observeEndPerformSplice(obj);
         if (should_throw) {
-          throw MakeTypeError("define_disallowed", [p]);
+          throw MakeTypeError(kDefineDisallowed, p);
         } else {
           return false;
         }
       }
       if (index >= length) {
         obj.length = index + 1;
       }
       if (emit_splice) {
         $observeEndPerformSplice(obj);
         $observeEnqueueSpliceRecord(obj, length, [], index + 1 - length);
@@ skipping 26 matching lines @@
 // ES6 section 19.1.2.9
 function ObjectGetPrototypeOf(obj) {
   return %_GetPrototype(TO_OBJECT_INLINE(obj));
 }
 
 // ES6 section 19.1.2.19.
 function ObjectSetPrototypeOf(obj, proto) {
   CHECK_OBJECT_COERCIBLE(obj, "Object.setPrototypeOf");
 
   if (proto !== null && !IS_SPEC_OBJECT(proto)) {
-    throw MakeTypeError("proto_object_or_null", [proto]);
+    throw MakeTypeError(kProtoObjectOrNull, proto);
   }
 
   if (IS_SPEC_OBJECT(obj)) {
     %SetPrototype(obj, proto);
   }
 
   return obj;
 }
 
 
 // ES6 section 19.1.2.6
 function ObjectGetOwnPropertyDescriptor(obj, p) {
   var desc = GetOwnPropertyJS(TO_OBJECT_INLINE(obj), p);
   return FromPropertyDescriptor(desc);
 }
 
 
 // For Harmony proxies
 function ToNameArray(obj, trap, includeSymbols) {
   if (!IS_SPEC_OBJECT(obj)) {
-    throw MakeTypeError("proxy_non_object_prop_names", [obj, trap]);
+    throw MakeTypeError(kProxyNonObjectPropNames, trap, obj);
   }
   var n = ToUint32(obj.length);
   var array = new $Array(n);
   var realLength = 0;
   var names = { __proto__: null };  // TODO(rossberg): use sets once ready.
   for (var index = 0; index < n; index++) {
     var s = ToName(obj[index]);
     // TODO(rossberg): adjust once there is a story for symbols vs proxies.
     if (IS_SYMBOL(s) && !includeSymbols) continue;
     if (%HasOwnProperty(names, s)) {
-      throw MakeTypeError("proxy_repeated_prop_name", [obj, trap, s]);
+      throw MakeTypeError(kProxyRepeatedPropName, trap, s);
     }
     array[index] = s;
     ++realLength;
     names[s] = 0;
   }
   array.length = realLength;
   return array;
 }
 
 
@@ skipping 74 matching lines @@
     return ToNameArray(names, "getOwnPropertyNames", false);
   }
 
   return ObjectGetOwnPropertyKeys(obj, PROPERTY_ATTRIBUTES_SYMBOLIC);
 }
 
 
 // ES5 section 15.2.3.5.
 function ObjectCreate(proto, properties) {
   if (!IS_SPEC_OBJECT(proto) && proto !== null) {
-    throw MakeTypeError("proto_object_or_null", [proto]);
+    throw MakeTypeError(kProtoObjectOrNull, proto);
   }
   var obj = {};
   %InternalSetPrototype(obj, proto);
   if (!IS_UNDEFINED(properties)) ObjectDefineProperties(obj, properties);
   return obj;
 }
 
 
 // ES5 section 15.2.3.6.
 function ObjectDefineProperty(obj, p, attributes) {
   if (!IS_SPEC_OBJECT(obj)) {
-    throw MakeTypeError("called_on_non_object", ["Object.defineProperty"]);
+    throw MakeTypeError(kCalledOnNonObject, "Object.defineProperty");
   }
   var name = ToName(p);
   if (%_IsJSProxy(obj)) {
     // Clone the attributes object for protection.
     // TODO(rossberg): not spec'ed yet, so not sure if this should involve
     // non-own properties as it does (or non-enumerable ones, as it doesn't?).
     var attributesClone = { __proto__: null };
     for (var a in attributes) {
       attributesClone[a] = attributes[a];
     }
@@ skipping 42 matching lines @@
     }
   }
 
   return names;
 }
 
 
 // ES5 section 15.2.3.7.
 function ObjectDefineProperties(obj, properties) {
   if (!IS_SPEC_OBJECT(obj)) {
-    throw MakeTypeError("called_on_non_object", ["Object.defineProperties"]);
+    throw MakeTypeError(kCalledOnNonObject, "Object.defineProperties");
   }
   var props = TO_OBJECT_INLINE(properties);
   var names = GetOwnEnumerablePropertyNames(props);
   var descriptors = new InternalArray();
   for (var i = 0; i < names.length; i++) {
     descriptors.push(ToPropertyDescriptor(props[names[i]]));
   }
   for (var i = 0; i < names.length; i++) {
     DefineOwnProperty(obj, names[i], descriptors[i], true);
   }
   return obj;
 }
 
 
 // Harmony proxies.
 function ProxyFix(obj) {
   var handler = %GetHandler(obj);
   var props = CallTrap0(handler, "fix", UNDEFINED);
   if (IS_UNDEFINED(props)) {
-    throw MakeTypeError("handler_returned_undefined", [handler, "fix"]);
+    throw MakeTypeError(kProxyHandlerReturned, handler, "undefined", "fix");
   }
 
   if (%IsJSFunctionProxy(obj)) {
     var callTrap = %GetCallTrap(obj);
     var constructTrap = %GetConstructTrap(obj);
     var code = $proxyDelegateCallAndConstruct(callTrap, constructTrap);
     %Fix(obj);  // becomes a regular function
     %SetCode(obj, code);
     // TODO(rossberg): What about length and other properties? Not specified.
     // We just put in some half-reasonable defaults for now.
     var prototype = new $Object();
     $Object.defineProperty(prototype, "constructor",
       {value: obj, writable: true, enumerable: false, configurable: true});
     // TODO(v8:1530): defineProperty does not handle prototype and length.
     %FunctionSetPrototype(obj, prototype);
     obj.length = 0;
   } else {
     %Fix(obj);
   }
   ObjectDefineProperties(obj, props);
 }
 
 
 // ES5 section 15.2.3.8.
 function ObjectSealJS(obj) {
   if (!IS_SPEC_OBJECT(obj)) {
-    throw MakeTypeError("called_on_non_object", ["Object.seal"]);
+    throw MakeTypeError(kCalledOnNonObject, "Object.seal");
   }
   var isProxy = %_IsJSProxy(obj);
   if (isProxy || %HasSloppyArgumentsElements(obj) || %IsObserved(obj)) {
     if (isProxy) {
       ProxyFix(obj);
     }
     var names = ObjectGetOwnPropertyNames(obj);
     for (var i = 0; i < names.length; i++) {
       var name = names[i];
       var desc = GetOwnPropertyJS(obj, name);
       if (desc.isConfigurable()) {
         desc.setConfigurable(false);
         DefineOwnProperty(obj, name, desc, true);
       }
     }
     %PreventExtensions(obj);
   } else {
     // TODO(adamk): Is it worth going to this fast path if the
     // object's properties are already in dictionary mode?
     %ObjectSeal(obj);
   }
   return obj;
 }
 
 
 // ES5 section 15.2.3.9.
 function ObjectFreezeJS(obj) {
   if (!IS_SPEC_OBJECT(obj)) {
-    throw MakeTypeError("called_on_non_object", ["Object.freeze"]);
+    throw MakeTypeError(kCalledOnNonObject, "Object.freeze");
   }
   var isProxy = %_IsJSProxy(obj);
   if (isProxy || %HasSloppyArgumentsElements(obj) || %IsObserved(obj)) {
     if (isProxy) {
       ProxyFix(obj);
     }
     var names = ObjectGetOwnPropertyNames(obj);
     for (var i = 0; i < names.length; i++) {
       var name = names[i];
       var desc = GetOwnPropertyJS(obj, name);
       if (desc.isWritable() || desc.isConfigurable()) {
         if (IsDataDescriptor(desc)) desc.setWritable(false);
         desc.setConfigurable(false);
         DefineOwnProperty(obj, name, desc, true);
       }
     }
     %PreventExtensions(obj);
   } else {
     // TODO(adamk): Is it worth going to this fast path if the
     // object's properties are already in dictionary mode?
     %ObjectFreeze(obj);
   }
   return obj;
 }
 
 
 // ES5 section 15.2.3.10
 function ObjectPreventExtension(obj) {
   if (!IS_SPEC_OBJECT(obj)) {
-    throw MakeTypeError("called_on_non_object", ["Object.preventExtension"]);
+    throw MakeTypeError(kCalledOnNonObject, "Object.preventExtension");
   }
   if (%_IsJSProxy(obj)) {
     ProxyFix(obj);
   }
   %PreventExtensions(obj);
   return obj;
 }
 
 
 // ES5 section 15.2.3.11
 function ObjectIsSealed(obj) {
   if (!IS_SPEC_OBJECT(obj)) {
-    throw MakeTypeError("called_on_non_object", ["Object.isSealed"]);
+    throw MakeTypeError(kCalledOnNonObject, "Object.isSealed");
   }
   if (%_IsJSProxy(obj)) {
     return false;
   }
   if (%IsExtensible(obj)) {
     return false;
   }
   var names = ObjectGetOwnPropertyNames(obj);
   for (var i = 0; i < names.length; i++) {
     var name = names[i];
     var desc = GetOwnPropertyJS(obj, name);
     if (desc.isConfigurable()) {
       return false;
     }
   }
   return true;
 }
 
 
 // ES5 section 15.2.3.12
 function ObjectIsFrozen(obj) {
   if (!IS_SPEC_OBJECT(obj)) {
-    throw MakeTypeError("called_on_non_object", ["Object.isFrozen"]);
+    throw MakeTypeError(kCalledOnNonObject, "Object.isFrozen");
   }
   if (%_IsJSProxy(obj)) {
     return false;
   }
   if (%IsExtensible(obj)) {
     return false;
   }
   var names = ObjectGetOwnPropertyNames(obj);
   for (var i = 0; i < names.length; i++) {
     var name = names[i];
     var desc = GetOwnPropertyJS(obj, name);
     if (IsDataDescriptor(desc) && desc.isWritable()) return false;
     if (desc.isConfigurable()) return false;
   }
   return true;
 }
 
 
 // ES5 section 15.2.3.13
 function ObjectIsExtensible(obj) {
   if (!IS_SPEC_OBJECT(obj)) {
-    throw MakeTypeError("called_on_non_object", ["Object.isExtensible"]);
+    throw MakeTypeError(kCalledOnNonObject, "Object.isExtensible");
   }
   if (%_IsJSProxy(obj)) {
     return true;
   }
   return %IsExtensible(obj);
 }
 
 
 // ECMA-262, Edition 6, section 19.1.2.10
 function ObjectIs(obj1, obj2) {
@@ skipping 92 matching lines @@
   }
 }
 
 
 function BooleanToString() {
   // NOTE: Both Boolean objects and values can enter here as
   // 'this'. This is not as dictated by ECMA-262.
   var b = this;
   if (!IS_BOOLEAN(b)) {
     if (!IS_BOOLEAN_WRAPPER(b)) {
-      throw new $TypeError('Boolean.prototype.toString is not generic');
+      throw MakeTypeError(kNotGeneric, 'Boolean.prototype.toString');
     }
     b = %_ValueOf(b);
   }
   return b ? 'true' : 'false';
 }
 
 
 function BooleanValueOf() {
   // NOTE: Both Boolean objects and values can enter here as
   // 'this'. This is not as dictated by ECMA-262.
   if (!IS_BOOLEAN(this) && !IS_BOOLEAN_WRAPPER(this)) {
-    throw new $TypeError('Boolean.prototype.valueOf is not generic');
+    throw MakeTypeError(kNotGeneric, 'Boolean.prototype.valueOf');
   }
   return %_ValueOf(this);
 }
 
 
 // ----------------------------------------------------------------------------
 
 function SetUpBoolean () {
   %CheckIsBootstrapping();
 
@@ skipping 23 matching lines @@
 }
 
 
 // ECMA-262 section 15.7.4.2.
 function NumberToStringJS(radix) {
   // NOTE: Both Number objects and values can enter here as
   // 'this'. This is not as dictated by ECMA-262.
   var number = this;
   if (!IS_NUMBER(this)) {
     if (!IS_NUMBER_WRAPPER(this)) {
-      throw new $TypeError('Number.prototype.toString is not generic');
+      throw MakeTypeError(kNotGeneric, 'Number.prototype.toString');
     }
     // Get the value of this number in case it's an object.
     number = %_ValueOf(this);
   }
   // Fast case: Convert number in radix 10.
   if (IS_UNDEFINED(radix) || radix === 10) {
     return %_NumberToString(number);
   }
 
   // Convert the radix to an integer and check the range.
@@ skipping 10 matching lines @@
 function NumberToLocaleString() {
   return %_CallFunction(this, NumberToStringJS);
 }
 
 
 // ECMA-262 section 15.7.4.4
 function NumberValueOf() {
   // NOTE: Both Number objects and values can enter here as
   // 'this'. This is not as dictated by ECMA-262.
   if (!IS_NUMBER(this) && !IS_NUMBER_WRAPPER(this)) {
-    throw new $TypeError('Number.prototype.valueOf is not generic');
+    throw MakeTypeError(kNotGeneric, 'Number.prototype.valueOf');
   }
   return %_ValueOf(this);
 }
 
 
 // ECMA-262 section 15.7.4.5
 function NumberToFixedJS(fractionDigits) {
   var x = this;
   if (!IS_NUMBER(this)) {
     if (!IS_NUMBER_WRAPPER(this)) {
       throw MakeTypeError(kIncompatibleMethodReceiver,
                           "Number.prototype.toFixed", this);
     }
     // Get the value of this number in case it's an object.
     x = %_ValueOf(this);
   }
   var f = TO_INTEGER(fractionDigits);
 
   if (f < 0 || f > 20) {
-    throw new $RangeError("toFixed() digits argument must be between 0 and 20");
+    throw MakeRangeError(kNumberFormatRange, "toFixed() digits");
   }
 
   if (NUMBER_IS_NAN(x)) return "NaN";
   if (x == INFINITY) return "Infinity";
   if (x == -INFINITY) return "-Infinity";
 
   return %NumberToFixed(x, f);
 }
 
 
@@ skipping 10 matching lines @@
   }
   var f = IS_UNDEFINED(fractionDigits) ? UNDEFINED : TO_INTEGER(fractionDigits);
 
   if (NUMBER_IS_NAN(x)) return "NaN";
   if (x == INFINITY) return "Infinity";
   if (x == -INFINITY) return "-Infinity";
 
   if (IS_UNDEFINED(f)) {
     f = -1;  // Signal for runtime function that f is not defined.
   } else if (f < 0 || f > 20) {
-    throw new $RangeError("toExponential() argument must be between 0 and 20");
+    throw MakeRangeError(kNumberFormatRange, "toExponential()");
   }
   return %NumberToExponential(x, f);
 }
 
 
 // ECMA-262 section 15.7.4.7
 function NumberToPrecisionJS(precision) {
   var x = this;
   if (!IS_NUMBER(this)) {
     if (!IS_NUMBER_WRAPPER(this)) {
       throw MakeTypeError(kIncompatibleMethodReceiver,
                           "Number.prototype.toPrecision", this);
     }
     // Get the value of this number in case it's an object.
     x = %_ValueOf(this);
   }
   if (IS_UNDEFINED(precision)) return ToString(%_ValueOf(this));
   var p = TO_INTEGER(precision);
 
   if (NUMBER_IS_NAN(x)) return "NaN";
   if (x == INFINITY) return "Infinity";
   if (x == -INFINITY) return "-Infinity";
 
   if (p < 1 || p > 21) {
-    throw new $RangeError("toPrecision() argument must be between 1 and 21");
+    throw MakeRangeError(kToPrecisionFormatRange);
   }
   return %NumberToPrecision(x, p);
 }
 
 
 // Harmony isFinite.
 function NumberIsFinite(number) {
   return IS_NUMBER(number) && NUMBER_IS_FINITE(number);
 }
 
@@ skipping 79 matching lines @@
 
 // ----------------------------------------------------------------------------
 // Function
 
 function FunctionSourceString(func) {
   while (%IsJSFunctionProxy(func)) {
     func = %GetCallTrap(func);
   }
 
   if (!IS_FUNCTION(func)) {
-    throw new $TypeError('Function.prototype.toString is not generic');
+    throw MakeTypeError(kNotGeneric, 'Function.prototype.toString');
   }
 
   var classSource = %ClassGetSourceCode(func);
   if (IS_STRING(classSource)) {
     return classSource;
   }
 
   var source = %FunctionGetSourceCode(func);
   if (!IS_STRING(source) || %FunctionIsBuiltin(func)) {
     var name = %FunctionGetName(func);
@@ skipping 21 matching lines @@
 }
 
 
 function FunctionToString() {
   return FunctionSourceString(this);
 }
 
 
 // ES5 15.3.4.5
 function FunctionBind(this_arg) { // Length is 1.
-  if (!IS_SPEC_FUNCTION(this)) {
-    throw new $TypeError('Bind must be called on a function');
-  }
+  if (!IS_SPEC_FUNCTION(this)) throw MakeTypeError(kFunctionBind);
+
   var boundFunction = function () {
     // Poison .arguments and .caller, but is otherwise not detectable.
     "use strict";
     // This function must not use any object literals (Object, Array, RegExp),
     // since the literals-array is being used to store the bound data.
     if (%_IsConstructCall()) {
       return %NewObjectFromBound(boundFunction);
     }
     var bindings = %BoundFunctionGetBindings(boundFunction);
 
@@ skipping 46 matching lines @@
   var p = '';
   if (n > 1) {
     p = ToString(arguments[0]);
     for (var i = 1; i < n - 1; i++) {
       p += ',' + ToString(arguments[i]);
     }
     // If the formal parameters string include ) - an illegal
     // character - it may make the combined function expression
     // compile. We avoid this problem by checking for this early on.
     if (%_CallFunction(p, ')', $stringIndexOf) != -1) {
-      throw MakeSyntaxError('paren_in_arg_string', []);
+      throw MakeSyntaxError(kParenthesisInArgString);
     }
     // If the formal parameters include an unbalanced block comment, the
     // function must be rejected. Since JavaScript does not allow nested
     // comments we can include a trailing block comment to catch this.
     p += '\n/' + '**/';
   }
   var body = (n > 0) ? ToString(arguments[n - 1]) : '';
   return '(' + function_token + '(' + p + ') {\n' + body + '\n})';
 }
 
@@ skipping 29 matching lines @@
 // ----------------------------------------------------------------------------
 // Iterator related spec functions.
 
 // ES6 rev 33, 2015-02-12
 // 7.4.1 GetIterator ( obj, method )
 function GetIterator(obj, method) {
   if (IS_UNDEFINED(method)) {
     method = obj[symbolIterator];
   }
   if (!IS_SPEC_FUNCTION(method)) {
-    throw MakeTypeError('not_iterable', [obj]);
+    throw MakeTypeError(kNotIterable, obj);
   }
   var iterator = %_CallFunction(obj, method);
   if (!IS_SPEC_OBJECT(iterator)) {
-    throw MakeTypeError('not_an_iterator', [iterator]);
+    throw MakeTypeError(kNotAnIterator, iterator);
   }
   return iterator;
 }