Move family of MakeError functions to C++

src/js/i18n.js

 // Copyright 2013 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.
 
 // ECMAScript 402 API implementation.
 
 /**
  * Intl object is a single object that has some named properties,
  * all of which are constructors.
  */
@@ skipping 13 matching lines @@
 var GlobalDate = global.Date;
 var GlobalNumber = global.Number;
 var GlobalRegExp = global.RegExp;
 var GlobalString = global.String;
 var InstallFunctions = utils.InstallFunctions;
 var InstallGetter = utils.InstallGetter;
 var InternalArray = utils.InternalArray;
 var InternalRegExpMatch;
 var InternalRegExpReplace
 var IsNaN;
-var MakeError;
-var MakeRangeError;
-var MakeTypeError;
 var ObjectHasOwnProperty = utils.ImportNow("ObjectHasOwnProperty");
 var OverrideFunction = utils.OverrideFunction;
 var patternSymbol = utils.ImportNow("intl_pattern_symbol");
 var resolvedSymbol = utils.ImportNow("intl_resolved_symbol");
 var SetFunctionName = utils.SetFunctionName;
 var StringIndexOf;
 var StringLastIndexOf;
 var StringSubstr;
 var StringSubstring;
 
 utils.Import(function(from) {
   ArrayIndexOf = from.ArrayIndexOf;
   ArrayJoin = from.ArrayJoin;
   ArrayPush = from.ArrayPush;
   IsNaN = from.IsNaN;
-  MakeError = from.MakeError;
-  MakeRangeError = from.MakeRangeError;
-  MakeTypeError = from.MakeTypeError;
   InternalRegExpMatch = from.InternalRegExpMatch;
   InternalRegExpReplace = from.InternalRegExpReplace;
   StringIndexOf = from.StringIndexOf;
   StringLastIndexOf = from.StringLastIndexOf;
   StringSubstr = from.StringSubstr;
   StringSubstring = from.StringSubstring;
 });
 
 utils.ImportFromExperimental(function(from) {
   FLAG_intl_extra = from.FLAG_intl_extra;
@@ skipping 20 matching lines @@
 function AddBoundMethod(obj, methodName, implementation, length, type) {
   %CheckIsBootstrapping();
   var internalName = %CreatePrivateSymbol(methodName);
   // Making getter an anonymous function will cause
   // %DefineGetterPropertyUnchecked to properly set the "name"
   // property on each JSFunction instance created here, rather
   // than (as utils.InstallGetter would) on the SharedFunctionInfo
   // associated with all functions returned from AddBoundMethod.
   var getter = ANONYMOUS_FUNCTION(function() {
     if (!%IsInitializedIntlObjectOfType(this, type)) {
-      throw MakeTypeError(kMethodCalledOnWrongObject, methodName);
+      throw %make_type_error(kMethodCalledOnWrongObject, methodName);
     }
     if (IS_UNDEFINED(this[internalName])) {
       var boundMethod;
       if (IS_UNDEFINED(length) || length === 2) {
         boundMethod = ANONYMOUS_FUNCTION((x, y) => implementation(this, x, y));
       } else if (length === 1) {
         boundMethod = ANONYMOUS_FUNCTION(x => implementation(this, x));
       } else {
         boundMethod = ANONYMOUS_FUNCTION((...args) => {
           // DateTimeFormat.format needs to be 0 arg method, but can still
@@ skipping 157 matching lines @@
   return TIMEZONE_NAME_LOCATION_PART_RE;
 }
 
 
 /**
  * Returns an intersection of locales and service supported locales.
  * Parameter locales is treated as a priority list.
  */
 function supportedLocalesOf(service, locales, options) {
   if (IS_NULL(InternalRegExpMatch(GetServiceRE(), service))) {
-    throw MakeError(kWrongServiceType, service);
+    throw %make_error(kWrongServiceType, service);
   }
 
   // Provide defaults if matcher was not specified.
   if (IS_UNDEFINED(options)) {
     options = {};
   } else {
     options = TO_OBJECT(options);
   }
 
   var matcher = options.localeMatcher;
   if (!IS_UNDEFINED(matcher)) {
     matcher = TO_STRING(matcher);
     if (matcher !== 'lookup' && matcher !== 'best fit') {
-      throw MakeRangeError(kLocaleMatcher, matcher);
+      throw %make_range_error(kLocaleMatcher, matcher);
     }
   } else {
     matcher = 'best fit';
   }
 
   var requestedLocales = initializeLocaleList(locales);
 
   // Cache these, they don't ever change per service.
   if (IS_UNDEFINED(AVAILABLE_LOCALES[service])) {
     AVAILABLE_LOCALES[service] = getAvailableLocalesOf(service);
@@ skipping 51 matching lines @@
   return lookupSupportedLocalesOf(requestedLocales, availableLocales);
 }
 
 
 /**
  * Returns a getOption function that extracts property value for given
  * options object. If property is missing it returns defaultValue. If value
  * is out of range for that property it throws RangeError.
  */
 function getGetOption(options, caller) {
-  if (IS_UNDEFINED(options)) throw MakeError(kDefaultOptionsMissing, caller);
+  if (IS_UNDEFINED(options)) throw %make_error(kDefaultOptionsMissing, caller);
 
   var getOption = function getOption(property, type, values, defaultValue) {
     if (!IS_UNDEFINED(options[property])) {
       var value = options[property];
       switch (type) {
         case 'boolean':
           value = TO_BOOLEAN(value);
           break;
         case 'string':
           value = TO_STRING(value);
           break;
         case 'number':
           value = TO_NUMBER(value);
           break;
         default:
-          throw MakeError(kWrongValueType);
+          throw %make_error(kWrongValueType);
       }
 
       if (!IS_UNDEFINED(values) && %_Call(ArrayIndexOf, values, value) === -1) {
-        throw MakeRangeError(kValueOutOfRange, value, caller, property);
+        throw %make_range_error(kValueOutOfRange, value, caller, property);
       }
 
       return value;
     }
 
     return defaultValue;
   }
 
   return getOption;
 }
@@ skipping 28 matching lines @@
   return resolved;
 }
 
 
 /**
  * Returns best matched supported locale and extension info using basic
  * lookup algorithm.
  */
 function lookupMatcher(service, requestedLocales) {
   if (IS_NULL(InternalRegExpMatch(GetServiceRE(), service))) {
-    throw MakeError(kWrongServiceType, service);
+    throw %make_error(kWrongServiceType, service);
   }
 
   // Cache these, they don't ever change per service.
   if (IS_UNDEFINED(AVAILABLE_LOCALES[service])) {
     AVAILABLE_LOCALES[service] = getAvailableLocalesOf(service);
   }
 
   for (var i = 0; i < requestedLocales.length; ++i) {
     // Remove all extensions.
     var locale = InternalRegExpReplace(
@@ skipping 256 matching lines @@
 }
 
 /**
  * Returns titlecased location, bueNos_airES -> Buenos_Aires
  * or ho_cHi_minH -> Ho_Chi_Minh. It is locale-agnostic and only
  * deals with ASCII only characters.
  * 'of', 'au' and 'es' are special-cased and lowercased.
  */
 function toTitleCaseTimezoneLocation(location) {
   var match = InternalRegExpMatch(GetTimezoneNameLocationPartRE(), location)
-  if (IS_NULL(match)) throw MakeRangeError(kExpectedLocation, location);
+  if (IS_NULL(match)) throw %make_range_error(kExpectedLocation, location);
 
   var result = toTitleCaseWord(match[1]);
   if (!IS_UNDEFINED(match[2]) && 2 < match.length) {
     // The first character is a separator, '_' or '-'.
     // None of IANA zone names has both '_' and '-'.
     var separator = %_Call(StringSubstring, match[2], 0, 1);
     var parts = %StringSplit(match[2], separator, kMaxUint32);
     for (var i = 1; i < parts.length; i++) {
       var part = parts[i]
       var lowercasedPart = %StringToLowerCase(part);
       result = result + separator +
           ((lowercasedPart !== 'es' &&
             lowercasedPart !== 'of' && lowercasedPart !== 'au') ?
           toTitleCaseWord(part) : lowercasedPart);
     }
   }
   return result;
 }
 
 /**
  * Canonicalizes the language tag, or throws in case the tag is invalid.
  */
 function canonicalizeLanguageTag(localeID) {
   // null is typeof 'object' so we have to do extra check.
   if ((!IS_STRING(localeID) && !IS_RECEIVER(localeID)) ||
       IS_NULL(localeID)) {
-    throw MakeTypeError(kLanguageID);
+    throw %make_type_error(kLanguageID);
   }
 
   // Optimize for the most common case; a language code alone in
   // the canonical form/lowercase (e.g. "en", "fil").
   if (IS_STRING(localeID) &&
       !IS_NULL(InternalRegExpMatch(/^[a-z]{2,3}$/, localeID))) {
     return localeID;
   }
 
   var localeString = TO_STRING(localeID);
 
   if (isValidLanguageTag(localeString) === false) {
-    throw MakeRangeError(kInvalidLanguageTag, localeString);
+    throw %make_range_error(kInvalidLanguageTag, localeString);
   }
 
   var tag = %CanonicalizeLanguageTag(localeString);
   if (tag === 'invalid-tag') {
-    throw MakeRangeError(kInvalidLanguageTag, localeString);
+    throw %make_range_error(kInvalidLanguageTag, localeString);
   }
 
   return tag;
 }
 
 
 /**
  * Returns an array where all locales are canonicalized and duplicates removed.
  * Throws on locales that are not well formed BCP47 tags.
  */
@@ skipping 129 matching lines @@
     this[resolvedSymbol] = value;
   }
 };
 
 /**
  * Initializes the given object so it's a valid Collator instance.
  * Useful for subclassing.
  */
 function initializeCollator(collator, locales, options) {
   if (%IsInitializedIntlObject(collator)) {
-    throw MakeTypeError(kReinitializeIntl, "Collator");
+    throw %make_type_error(kReinitializeIntl, "Collator");
   }
 
   if (IS_UNDEFINED(options)) {
     options = {};
   }
 
   var getOption = getGetOption(options, 'collator');
 
   var internalOptions = {};
 
@@ skipping 105 matching lines @@
     return initializeCollator(TO_OBJECT(this), locales, options);
   }
 );
 
 
 /**
  * Collator resolvedOptions method.
  */
 InstallFunction(Intl.Collator.prototype, 'resolvedOptions', function() {
     if (!IS_UNDEFINED(new.target)) {
-      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
+      throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
     }
 
     if (!%IsInitializedIntlObjectOfType(this, 'collator')) {
-      throw MakeTypeError(kResolvedOptionsCalledOnNonObject, "Collator");
+      throw %make_type_error(kResolvedOptionsCalledOnNonObject, "Collator");
     }
 
     var coll = this;
     var locale = getOptimalLanguageTag(coll[resolvedSymbol].requestedLocale,
                                        coll[resolvedSymbol].locale);
 
     return {
       locale: locale,
       usage: coll[resolvedSymbol].usage,
       sensitivity: coll[resolvedSymbol].sensitivity,
       ignorePunctuation: coll[resolvedSymbol].ignorePunctuation,
       numeric: coll[resolvedSymbol].numeric,
       caseFirst: coll[resolvedSymbol].caseFirst,
       collation: coll[resolvedSymbol].collation
     };
   }
 );
 
 
 /**
  * Returns the subset of the given locale list for which this locale list
  * has a matching (possibly fallback) locale. Locales appear in the same
  * order in the returned list as in the input list.
  * Options are optional parameter.
  */
 InstallFunction(Intl.Collator, 'supportedLocalesOf', function(locales) {
     if (!IS_UNDEFINED(new.target)) {
-      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
+      throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
     }
 
     return supportedLocalesOf('collator', locales, arguments[1]);
   }
 );
 
 
 /**
  * When the compare method is called with two arguments x and y, it returns a
  * Number other than NaN that represents the result of a locale-sensitive
@@ skipping 25 matching lines @@
 
 /**
  * Returns the valid digit count for a property, or throws RangeError on
  * a value out of the range.
  */
 function getNumberOption(options, property, min, max, fallback) {
   var value = options[property];
   if (!IS_UNDEFINED(value)) {
     value = TO_NUMBER(value);
     if (NUMBER_IS_NAN(value) || value < min || value > max) {
-      throw MakeRangeError(kPropertyValueOutOfRange, property);
+      throw %make_range_error(kPropertyValueOutOfRange, property);
     }
     return %math_floor(value);
   }
 
   return fallback;
 }
 
 var patternAccessor = {
   get() {
     %IncrementUseCounter(kIntlPattern);
     return this[patternSymbol];
   },
   set(value) {
     this[patternSymbol] = value;
   }
 };
 
 /**
  * Initializes the given object so it's a valid NumberFormat instance.
  * Useful for subclassing.
  */
 function initializeNumberFormat(numberFormat, locales, options) {
   if (%IsInitializedIntlObject(numberFormat)) {
-    throw MakeTypeError(kReinitializeIntl, "NumberFormat");
+    throw %make_type_error(kReinitializeIntl, "NumberFormat");
   }
 
   if (IS_UNDEFINED(options)) {
     options = {};
   }
 
   var getOption = getGetOption(options, 'numberformat');
 
   var locale = resolveLocale('numberformat', locales, options);
 
   var internalOptions = {};
   defineWEProperty(internalOptions, 'style', getOption(
     'style', 'string', ['decimal', 'percent', 'currency'], 'decimal'));
 
   var currency = getOption('currency', 'string');
   if (!IS_UNDEFINED(currency) && !isWellFormedCurrencyCode(currency)) {
-    throw MakeRangeError(kInvalidCurrencyCode, currency);
+    throw %make_range_error(kInvalidCurrencyCode, currency);
   }
 
   if (internalOptions.style === 'currency' && IS_UNDEFINED(currency)) {
-    throw MakeTypeError(kCurrencyCode);
+    throw %make_type_error(kCurrencyCode);
   }
 
   var currencyDisplay = getOption(
       'currencyDisplay', 'string', ['code', 'symbol', 'name'], 'symbol');
   if (internalOptions.style === 'currency') {
     defineWEProperty(internalOptions, 'currency', %StringToUpperCase(currency));
     defineWEProperty(internalOptions, 'currencyDisplay', currencyDisplay);
   }
 
   // Digit ranges.
@@ skipping 101 matching lines @@
     return initializeNumberFormat(TO_OBJECT(this), locales, options);
   }
 );
 
 
 /**
  * NumberFormat resolvedOptions method.
  */
 InstallFunction(Intl.NumberFormat.prototype, 'resolvedOptions', function() {
     if (!IS_UNDEFINED(new.target)) {
-      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
+      throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
     }
 
     if (!%IsInitializedIntlObjectOfType(this, 'numberformat')) {
-      throw MakeTypeError(kResolvedOptionsCalledOnNonObject, "NumberFormat");
+      throw %make_type_error(kResolvedOptionsCalledOnNonObject, "NumberFormat");
     }
 
     var format = this;
     var locale = getOptimalLanguageTag(format[resolvedSymbol].requestedLocale,
                                        format[resolvedSymbol].locale);
 
     var result = {
       locale: locale,
       numberingSystem: format[resolvedSymbol].numberingSystem,
       style: format[resolvedSymbol].style,
@@ skipping 25 matching lines @@
 
 
 /**
  * Returns the subset of the given locale list for which this locale list
  * has a matching (possibly fallback) locale. Locales appear in the same
  * order in the returned list as in the input list.
  * Options are optional parameter.
  */
 InstallFunction(Intl.NumberFormat, 'supportedLocalesOf', function(locales) {
     if (!IS_UNDEFINED(new.target)) {
-      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
+      throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
     }
 
     return supportedLocalesOf('numberformat', locales, arguments[1]);
   }
 );
 
 
 /**
  * Returns a String value representing the result of calling ToNumber(value)
  * according to the effective locale and the formatting options of this
@@ skipping 216 matching lines @@
 }
 
 
 /**
  * Initializes the given object so it's a valid DateTimeFormat instance.
  * Useful for subclassing.
  */
 function initializeDateTimeFormat(dateFormat, locales, options) {
 
   if (%IsInitializedIntlObject(dateFormat)) {
-    throw MakeTypeError(kReinitializeIntl, "DateTimeFormat");
+    throw %make_type_error(kReinitializeIntl, "DateTimeFormat");
   }
 
   if (IS_UNDEFINED(options)) {
     options = {};
   }
 
   var locale = resolveLocale('dateformat', locales, options);
 
   options = toDateTimeOptions(options, 'any', 'date');
 
@@ skipping 47 matching lines @@
     timeZoneName: {writable: true},
     tz: {value: tz, writable: true},
     weekday: {writable: true},
     year: {writable: true}
   });
 
   var formatter = %CreateDateTimeFormat(
     requestedLocale, {skeleton: ldmlString, timeZone: tz}, resolved);
 
   if (resolved.timeZone === "Etc/Unknown") {
-    throw MakeRangeError(kUnsupportedTimeZone, tz);
+    throw %make_range_error(kUnsupportedTimeZone, tz);
   }
 
   %MarkAsInitializedIntlObjectOfType(dateFormat, 'dateformat', formatter);
   dateFormat[resolvedSymbol] = resolved;
   if (FLAG_intl_extra) {
     %object_define_property(resolved, 'pattern', patternAccessor);
     %object_define_property(dateFormat, 'resolved', resolvedAccessor);
   }
 
   return dateFormat;
@@ skipping 18 matching lines @@
     return initializeDateTimeFormat(TO_OBJECT(this), locales, options);
   }
 );
 
 
 /**
  * DateTimeFormat resolvedOptions method.
  */
 InstallFunction(Intl.DateTimeFormat.prototype, 'resolvedOptions', function() {
     if (!IS_UNDEFINED(new.target)) {
-      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
+      throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
     }
 
     if (!%IsInitializedIntlObjectOfType(this, 'dateformat')) {
-      throw MakeTypeError(kResolvedOptionsCalledOnNonObject, "DateTimeFormat");
+      throw %make_type_error(kResolvedOptionsCalledOnNonObject, "DateTimeFormat");
     }
 
     /**
      * Maps ICU calendar names into LDML type.
      */
     var ICU_CALENDAR_MAP = {
       'gregorian': 'gregory',
       'japanese': 'japanese',
       'buddhist': 'buddhist',
       'roc': 'roc',
@@ skipping 44 matching lines @@
 
 
 /**
  * Returns the subset of the given locale list for which this locale list
  * has a matching (possibly fallback) locale. Locales appear in the same
  * order in the returned list as in the input list.
  * Options are optional parameter.
  */
 InstallFunction(Intl.DateTimeFormat, 'supportedLocalesOf', function(locales) {
     if (!IS_UNDEFINED(new.target)) {
-      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
+      throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
     }
 
     return supportedLocalesOf('dateformat', locales, arguments[1]);
   }
 );
 
 
 /**
  * Returns a String value representing the result of calling ToNumber(date)
  * according to the effective locale and the formatting options of this
  * DateTimeFormat.
  */
 function formatDate(formatter, dateValue) {
   var dateMs;
   if (IS_UNDEFINED(dateValue)) {
     dateMs = %DateCurrentTime();
   } else {
     dateMs = TO_NUMBER(dateValue);
   }
 
-  if (!NUMBER_IS_FINITE(dateMs)) throw MakeRangeError(kDateRange);
+  if (!NUMBER_IS_FINITE(dateMs)) throw %make_range_error(kDateRange);
 
   return %InternalDateFormat(%GetImplFromInitializedIntlObject(formatter),
                              new GlobalDate(dateMs));
 }
 
 
 /**
  * Returns a Date object representing the result of calling ToString(value)
  * according to the effective locale and the formatting options of this
  * DateTimeFormat.
@@ skipping 27 matching lines @@
   if (upperID === 'UTC' || upperID === 'GMT' ||
       upperID === 'ETC/UTC' || upperID === 'ETC/GMT') {
     return 'UTC';
   }
 
   // TODO(jshin): Add support for Etc/GMT[+-]([1-9]|1[0-2])
 
   // We expect only _, '-' and / beside ASCII letters.
   // All inputs should conform to Area/Location(/Location)* from now on.
   var match = InternalRegExpMatch(GetTimezoneNameCheckRE(), tzID);
-  if (IS_NULL(match)) throw MakeRangeError(kExpectedTimezoneID, tzID);
+  if (IS_NULL(match)) throw %make_range_error(kExpectedTimezoneID, tzID);
 
   var result = toTitleCaseTimezoneLocation(match[1]) + '/' +
                toTitleCaseTimezoneLocation(match[2]);
 
   if (!IS_UNDEFINED(match[3]) && 3 < match.length) {
     var locations = %StringSplit(match[3], '/', kMaxUint32);
     // The 1st element is empty. Starts with i=1.
     for (var i = 1; i < locations.length; i++) {
       result = result + '/' + toTitleCaseTimezoneLocation(locations[i]);
     }
   }
 
   return result;
 }
 
 /**
  * Initializes the given object so it's a valid BreakIterator instance.
  * Useful for subclassing.
  */
 function initializeBreakIterator(iterator, locales, options) {
   if (%IsInitializedIntlObject(iterator)) {
-    throw MakeTypeError(kReinitializeIntl, "v8BreakIterator");
+    throw %make_type_error(kReinitializeIntl, "v8BreakIterator");
   }
 
   if (IS_UNDEFINED(options)) {
     options = {};
   }
 
   var getOption = getGetOption(options, 'breakiterator');
 
   var internalOptions = {};
 
@@ skipping 41 matching lines @@
   }
 );
 
 
 /**
  * BreakIterator resolvedOptions method.
  */
 InstallFunction(Intl.v8BreakIterator.prototype, 'resolvedOptions',
   function() {
     if (!IS_UNDEFINED(new.target)) {
-      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
+      throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
     }
 
     if (!%IsInitializedIntlObjectOfType(this, 'breakiterator')) {
-      throw MakeTypeError(kResolvedOptionsCalledOnNonObject, "v8BreakIterator");
+      throw %make_type_error(kResolvedOptionsCalledOnNonObject, "v8BreakIterator");
     }
 
     var segmenter = this;
     var locale =
         getOptimalLanguageTag(segmenter[resolvedSymbol].requestedLocale,
                               segmenter[resolvedSymbol].locale);
 
     return {
       locale: locale,
       type: segmenter[resolvedSymbol].type
     };
   }
 );
 
 
 /**
  * Returns the subset of the given locale list for which this locale list
  * has a matching (possibly fallback) locale. Locales appear in the same
  * order in the returned list as in the input list.
  * Options are optional parameter.
  */
 InstallFunction(Intl.v8BreakIterator, 'supportedLocalesOf',
   function(locales) {
     if (!IS_UNDEFINED(new.target)) {
-      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
+      throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
     }
 
     return supportedLocalesOf('breakiterator', locales, arguments[1]);
   }
 );
 
 
 /**
  * Adopts text to segment using the iterator. Old text, if present,
  * gets discarded.
@@ skipping 128 matching lines @@
   return %StringLocaleConvertCase(s, isToUpper,
                                   CUSTOM_CASE_LANGUAGES[langIndex]);
 }
 
 /**
  * Compares this and that, and returns less than 0, 0 or greater than 0 value.
  * Overrides the built-in method.
  */
 OverrideFunction(GlobalString.prototype, 'localeCompare', function(that) {
     if (!IS_UNDEFINED(new.target)) {
-      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
+      throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
     }
 
     if (IS_NULL_OR_UNDEFINED(this)) {
-      throw MakeTypeError(kMethodInvokedOnNullOrUndefined);
+      throw %make_type_error(kMethodInvokedOnNullOrUndefined);
     }
 
     var locales = arguments[1];
     var options = arguments[2];
     var collator = cachedOrNewService('collator', locales, options);
     return compare(collator, this, that);
   }
 );
 
 
 /**
  * Unicode normalization. This method is called with one argument that
  * specifies the normalization form.
  * If none is specified, "NFC" is assumed.
  * If the form is not one of "NFC", "NFD", "NFKC", or "NFKD", then throw
  * a RangeError Exception.
  */
 
 OverrideFunction(GlobalString.prototype, 'normalize', function() {
     if (!IS_UNDEFINED(new.target)) {
-      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
+      throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
     }
 
     CHECK_OBJECT_COERCIBLE(this, "String.prototype.normalize");
     var s = TO_STRING(this);
 
     var formArg = arguments[0];
     var form = IS_UNDEFINED(formArg) ? 'NFC' : TO_STRING(formArg);
 
     var NORMALIZATION_FORMS = ['NFC', 'NFD', 'NFKC', 'NFKD'];
 
     var normalizationForm = %_Call(ArrayIndexOf, NORMALIZATION_FORMS, form);
     if (normalizationForm === -1) {
-      throw MakeRangeError(kNormalizationForm,
+      throw %make_range_error(kNormalizationForm,
           %_Call(ArrayJoin, NORMALIZATION_FORMS, ', '));
     }
 
     return %StringNormalize(s, normalizationForm);
   }
 );
 
 function ToLowerCaseI18N() {
   if (!IS_UNDEFINED(new.target)) {
-    throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
+    throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
   }
   CHECK_OBJECT_COERCIBLE(this, "String.prototype.toLowerCase");
   var s = TO_STRING(this);
   return %StringToLowerCaseI18N(s);
 }
 
 function ToUpperCaseI18N() {
   if (!IS_UNDEFINED(new.target)) {
-    throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
+    throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
   }
   CHECK_OBJECT_COERCIBLE(this, "String.prototype.toUpperCase");
   var s = TO_STRING(this);
   return %StringToUpperCaseI18N(s);
 }
 
 function ToLocaleLowerCaseI18N(locales) {
   if (!IS_UNDEFINED(new.target)) {
-    throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
+    throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
   }
   CHECK_OBJECT_COERCIBLE(this, "String.prototype.toLocaleLowerCase");
   return LocaleConvertCase(TO_STRING(this), locales, false);
 }
 
 %FunctionSetLength(ToLocaleLowerCaseI18N, 0);
 
 function ToLocaleUpperCaseI18N(locales) {
   if (!IS_UNDEFINED(new.target)) {
-    throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
+    throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
   }
   CHECK_OBJECT_COERCIBLE(this, "String.prototype.toLocaleUpperCase");
   return LocaleConvertCase(TO_STRING(this), locales, true);
 }
 
 %FunctionSetLength(ToLocaleUpperCaseI18N, 0);
 
 %FunctionRemovePrototype(ToLowerCaseI18N);
 %FunctionRemovePrototype(ToUpperCaseI18N);
 %FunctionRemovePrototype(ToLocaleLowerCaseI18N);
 %FunctionRemovePrototype(ToLocaleUpperCaseI18N);
 
 utils.Export(function(to) {
   to.ToLowerCaseI18N = ToLowerCaseI18N;
   to.ToUpperCaseI18N = ToUpperCaseI18N;
   to.ToLocaleLowerCaseI18N = ToLocaleLowerCaseI18N;
   to.ToLocaleUpperCaseI18N = ToLocaleUpperCaseI18N;
 });
 
 
 /**
  * Formats a Number object (this) using locale and options values.
  * If locale or options are omitted, defaults are used.
  */
 OverrideFunction(GlobalNumber.prototype, 'toLocaleString', function() {
     if (!IS_UNDEFINED(new.target)) {
-      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
+      throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
     }
 
     if (!(this instanceof GlobalNumber) && typeof(this) !== 'number') {
-      throw MakeTypeError(kMethodInvokedOnWrongType, "Number");
+      throw %make_type_error(kMethodInvokedOnWrongType, "Number");
     }
 
     var locales = arguments[0];
     var options = arguments[1];
     var numberFormat = cachedOrNewService('numberformat', locales, options);
     return formatNumber(numberFormat, this);
   }
 );
 
 
 /**
  * Returns actual formatted date or fails if date parameter is invalid.
  */
 function toLocaleDateTime(date, locales, options, required, defaults, service) {
   if (!(date instanceof GlobalDate)) {
-    throw MakeTypeError(kMethodInvokedOnWrongType, "Date");
+    throw %make_type_error(kMethodInvokedOnWrongType, "Date");
   }
 
   if (IsNaN(date)) return 'Invalid Date';
 
   var internalOptions = toDateTimeOptions(options, required, defaults);
 
   var dateFormat =
       cachedOrNewService(service, locales, options, internalOptions);
 
   return formatDate(dateFormat, date);
 }
 
 
 /**
  * Formats a Date object (this) using locale and options values.
  * If locale or options are omitted, defaults are used - both date and time are
  * present in the output.
  */
 OverrideFunction(GlobalDate.prototype, 'toLocaleString', function() {
     if (!IS_UNDEFINED(new.target)) {
-      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
+      throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
     }
 
     var locales = arguments[0];
     var options = arguments[1];
     return toLocaleDateTime(
         this, locales, options, 'any', 'all', 'dateformatall');
   }
 );
 
 
 /**
  * Formats a Date object (this) using locale and options values.
  * If locale or options are omitted, defaults are used - only date is present
  * in the output.
  */
 OverrideFunction(GlobalDate.prototype, 'toLocaleDateString', function() {
     if (!IS_UNDEFINED(new.target)) {
-      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
+      throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
     }
 
     var locales = arguments[0];
     var options = arguments[1];
     return toLocaleDateTime(
         this, locales, options, 'date', 'date', 'dateformatdate');
   }
 );
 
 
 /**
  * Formats a Date object (this) using locale and options values.
  * If locale or options are omitted, defaults are used - only time is present
  * in the output.
  */
 OverrideFunction(GlobalDate.prototype, 'toLocaleTimeString', function() {
     if (!IS_UNDEFINED(new.target)) {
-      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
+      throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
     }
 
     var locales = arguments[0];
     var options = arguments[1];
     return toLocaleDateTime(
         this, locales, options, 'time', 'time', 'dateformattime');
   }
 );
 
 utils.Export(function(to) {
   to.AddBoundMethod = AddBoundMethod;
   to.IntlParseDate = IntlParseDate;
   to.IntlParseNumber = IntlParseNumber;
 });
 
 })