Migrate error messages, part 5 (array.js and i18n.js).

src/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 201 matching lines @@
 var ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR =
   'Function object that\'s not a constructor was created with new';
 
 
 /**
  * Adds bound method to the prototype of the given object.
  */
 function addBoundMethod(obj, methodName, implementation, length) {
   function getter() {
     if (!%IsInitializedIntlObject(this)) {
-        throw new $TypeError('Method ' + methodName + ' called on a ' +
-                            'non-object or on a wrong type of object.');
+      throw MakeTypeError(kMethodCalledOnWrongObject, methodName);
     }
     var internalName = '__bound' + methodName + '__';
     if (this[internalName] === undefined) {
       var that = this;
       var boundMethod;
       if (length === undefined || length === 2) {
         boundMethod = function(x, y) {
           if (%_IsConstructCall()) {
-            throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
+            throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
           }
           return implementation(that, x, y);
         }
       } else if (length === 1) {
         boundMethod = function(x) {
           if (%_IsConstructCall()) {
-            throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
+            throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
           }
           return implementation(that, x);
         }
       } else {
         boundMethod = function() {
           if (%_IsConstructCall()) {
-            throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
+            throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
           }
           // DateTimeFormat.format needs to be 0 arg method, but can stil
           // receive optional dateValue param. If one was provided, pass it
           // along.
           if (%_ArgumentsLength() > 0) {
             return implementation(that, %_Arguments(0));
           } else {
             return implementation(that);
           }
         }
@@ skipping 17 matching lines @@
   });
 }
 
 
 /**
  * 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(service.match(GetServiceRE()))) {
-    throw new $Error('Internal error, wrong service type: ' + service);
+    throw MakeError(kWrongServiceType, service);
   }
 
   // Provide defaults if matcher was not specified.
   if (options === undefined) {
     options = {};
   } else {
     options = ToObject(options);
   }
 
   var matcher = options.localeMatcher;
   if (matcher !== undefined) {
     matcher = GlobalString(matcher);
     if (matcher !== 'lookup' && matcher !== 'best fit') {
-      throw new $RangeError('Illegal value for localeMatcher:' + matcher);
+      throw MakeRangeError(kLocaleMatcher, matcher);
     }
   } else {
     matcher = 'best fit';
   }
 
   var requestedLocales = initializeLocaleList(locales);
 
   // Cache these, they don't ever change per service.
   if (AVAILABLE_LOCALES[service] === undefined) {
     AVAILABLE_LOCALES[service] = getAvailableLocalesOf(service);
@@ skipping 50 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 (options === undefined) {
-    throw new $Error('Internal ' + caller + ' error. ' +
-                    'Default options are missing.');
-  }
+  if (options === undefined) throw MakeError(kDefaultOptionsMissing, caller);
 
   var getOption = function getOption(property, type, values, defaultValue) {
     if (options[property] !== undefined) {
       var value = options[property];
       switch (type) {
         case 'boolean':
           value = GlobalBoolean(value);
           break;
         case 'string':
           value = GlobalString(value);
           break;
         case 'number':
           value = GlobalNumber(value);
           break;
         default:
-          throw new $Error('Internal error. Wrong value type.');
+          throw MakeError(kWrongValueType);
       }
       if (values !== undefined && values.indexOf(value) === -1) {
-        throw new $RangeError('Value ' + value + ' out of range for ' + caller +
-                             ' options property ' + property);
+        throw MakeRangeError(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(service.match(GetServiceRE()))) {
-    throw new $Error('Internal error, wrong service type: ' + service);
+    throw MakeError(kWrongServiceType, service);
   }
 
   // Cache these, they don't ever change per service.
   if (AVAILABLE_LOCALES[service] === undefined) {
     AVAILABLE_LOCALES[service] = getAvailableLocalesOf(service);
   }
 
   for (var i = 0; i < requestedLocales.length; ++i) {
     // Remove all extensions.
     var locale = requestedLocales[i].replace(GetAnyExtensionRE(), '');
@@ skipping 252 matching lines @@
   return word.substr(0, 1).toUpperCase() + word.substr(1).toLowerCase();
 }
 
 /**
  * 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 (typeof localeID !== 'string' && typeof localeID !== 'object' ||
       IS_NULL(localeID)) {
-    throw new $TypeError('Language ID should be string or object.');
+    throw MakeTypeError(kLanguageID);
   }
 
   var localeString = GlobalString(localeID);
 
   if (isValidLanguageTag(localeString) === false) {
-    throw new $RangeError('Invalid language tag: ' + localeString);
+    throw MakeRangeError(kInvalidLanguageTag, localeString);
   }
 
   // This call will strip -kn but not -kn-true extensions.
   // ICU bug filled - http://bugs.icu-project.org/trac/ticket/9265.
   // TODO(cira): check if -u-kn-true-kc-true-kh-true still throws after
   // upgrade to ICU 4.9.
   var tag = %CanonicalizeLanguageTag(localeString);
   if (tag === 'invalid-tag') {
-    throw new $RangeError('Invalid language tag: ' + localeString);
+    throw MakeRangeError(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 122 matching lines @@
       '^(' + langTag + '|' + privateUse + '|' + grandfathered + ')$';
   LANGUAGE_TAG_RE = new GlobalRegExp(languageTag, 'i');
 }
 
 /**
  * Initializes the given object so it's a valid Collator instance.
  * Useful for subclassing.
  */
 function initializeCollator(collator, locales, options) {
   if (%IsInitializedIntlObject(collator)) {
-    throw new $TypeError('Trying to re-initialize Collator object.');
+    throw MakeTypeError(kReinitializeIntl, "Collator");
   }
 
   if (options === undefined) {
     options = {};
   }
 
   var getOption = getGetOption(options, 'collator');
 
   var internalOptions = {};
 
@@ skipping 82 matching lines @@
   },
   DONT_ENUM
 );
 
 
 /**
  * Collator resolvedOptions method.
  */
 %AddNamedProperty(Intl.Collator.prototype, 'resolvedOptions', function() {
     if (%_IsConstructCall()) {
-      throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
+      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     if (!%IsInitializedIntlObjectOfType(this, 'collator')) {
-      throw new $TypeError('resolvedOptions method called on a non-object ' +
-                           'or on a object that is not Intl.Collator.');
+      throw MakeTypeError(kResolvedOptionsCalledOnNonObject, "Collator");
     }
 
     var coll = this;
     var locale = getOptimalLanguageTag(coll.resolved.requestedLocale,
                                        coll.resolved.locale);
 
     return {
       locale: locale,
       usage: coll.resolved.usage,
       sensitivity: coll.resolved.sensitivity,
@@ skipping 11 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.
  */
 %AddNamedProperty(Intl.Collator, 'supportedLocalesOf', function(locales) {
     if (%_IsConstructCall()) {
-      throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
+      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     return supportedLocalesOf('collator', locales, %_Arguments(1));
   },
   DONT_ENUM
 );
 %FunctionSetName(Intl.Collator.supportedLocalesOf, 'supportedLocalesOf');
 %FunctionRemovePrototype(Intl.Collator.supportedLocalesOf);
 %SetNativeFlag(Intl.Collator.supportedLocalesOf);
 
@@ skipping 30 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 (value !== undefined) {
     value = GlobalNumber(value);
     if ($isNaN(value) || value < min || value > max) {
-      throw new $RangeError(property + ' value is out of range.');
+      throw MakeRangeError(kPropertyValueOutOfRange, property);
     }
     return $floor(value);
   }
 
   return fallback;
 }
 
 
 /**
  * Initializes the given object so it's a valid NumberFormat instance.
  * Useful for subclassing.
  */
 function initializeNumberFormat(numberFormat, locales, options) {
   if (%IsInitializedIntlObject(numberFormat)) {
-    throw new $TypeError('Trying to re-initialize NumberFormat object.');
+    throw MakeTypeError(kReinitializeIntl, "NumberFormat");
   }
 
   if (options === undefined) {
     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 (currency !== undefined && !isWellFormedCurrencyCode(currency)) {
-    throw new $RangeError('Invalid currency code: ' + currency);
+    throw MakeRangeError(kInvalidCurrencyCode, currency);
   }
 
   if (internalOptions.style === 'currency' && currency === undefined) {
-    throw new $TypeError('Currency code is required with currency style.');
+    throw MakeTypeError(kCurrencyCode);
   }
 
   var currencyDisplay = getOption(
       'currencyDisplay', 'string', ['code', 'symbol', 'name'], 'symbol');
   if (internalOptions.style === 'currency') {
     defineWEProperty(internalOptions, 'currency', currency.toUpperCase());
     defineWEProperty(internalOptions, 'currencyDisplay', currencyDisplay);
   }
 
   // Digit ranges.
@@ skipping 82 matching lines @@
   },
   DONT_ENUM
 );
 
 
 /**
  * NumberFormat resolvedOptions method.
  */
 %AddNamedProperty(Intl.NumberFormat.prototype, 'resolvedOptions', function() {
     if (%_IsConstructCall()) {
-      throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
+      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     if (!%IsInitializedIntlObjectOfType(this, 'numberformat')) {
-      throw new $TypeError('resolvedOptions method called on a non-object' +
-          ' or on a object that is not Intl.NumberFormat.');
+      throw MakeTypeError(kResolvedOptionsCalledOnNonObject, "NumberFormat");
     }
 
     var format = this;
     var locale = getOptimalLanguageTag(format.resolved.requestedLocale,
                                        format.resolved.locale);
 
     var result = {
       locale: locale,
       numberingSystem: format.resolved.numberingSystem,
       style: format.resolved.style,
@@ skipping 30 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.
  */
 %AddNamedProperty(Intl.NumberFormat, 'supportedLocalesOf', function(locales) {
     if (%_IsConstructCall()) {
-      throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
+      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     return supportedLocalesOf('numberformat', locales, %_Arguments(1));
   },
   DONT_ENUM
 );
 %FunctionSetName(Intl.NumberFormat.supportedLocalesOf, 'supportedLocalesOf');
 %FunctionRemovePrototype(Intl.NumberFormat.supportedLocalesOf);
 %SetNativeFlag(Intl.NumberFormat.supportedLocalesOf);
 
@@ skipping 222 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 new $TypeError('Trying to re-initialize DateTimeFormat object.');
+    throw MakeTypeError(kReinitializeIntl, "DateTimeFormat");
   }
 
   if (options === undefined) {
     options = {};
   }
 
   var locale = resolveLocale('dateformat', locales, options);
 
   options = toDateTimeOptions(options, 'any', 'date');
 
@@ skipping 37 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 (tz !== undefined && tz !== resolved.timeZone) {
-    throw new $RangeError('Unsupported time zone specified ' + tz);
+    throw MakeRangeError(kUnsupportedTimeZone, tz);
   }
 
   %MarkAsInitializedIntlObjectOfType(dateFormat, 'dateformat', formatter);
   ObjectDefineProperty(dateFormat, 'resolved', {value: resolved});
 
   return dateFormat;
 }
 
 
 /**
@@ skipping 15 matching lines @@
   },
   DONT_ENUM
 );
 
 
 /**
  * DateTimeFormat resolvedOptions method.
  */
 %AddNamedProperty(Intl.DateTimeFormat.prototype, 'resolvedOptions', function() {
     if (%_IsConstructCall()) {
-      throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
+      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     if (!%IsInitializedIntlObjectOfType(this, 'dateformat')) {
-      throw new $TypeError('resolvedOptions method called on a non-object or ' +
-          'on a object that is not Intl.DateTimeFormat.');
+      throw MakeTypeError(kResolvedOptionsCalledOnNonObject, "DateTimeFormat");
     }
 
     var format = this;
     var fromPattern = fromLDMLString(format.resolved.pattern);
     var userCalendar = ICU_CALENDAR_MAP[format.resolved.calendar];
     if (userCalendar === undefined) {
       // Use ICU name if we don't have a match. It shouldn't happen, but
       // it would be too strict to throw for this.
       userCalendar = format.resolved.calendar;
     }
@@ skipping 30 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.
  */
 %AddNamedProperty(Intl.DateTimeFormat, 'supportedLocalesOf', function(locales) {
     if (%_IsConstructCall()) {
-      throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
+      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     return supportedLocalesOf('dateformat', locales, %_Arguments(1));
   },
   DONT_ENUM
 );
 %FunctionSetName(Intl.DateTimeFormat.supportedLocalesOf, 'supportedLocalesOf');
 %FunctionRemovePrototype(Intl.DateTimeFormat.supportedLocalesOf);
 %SetNativeFlag(Intl.DateTimeFormat.supportedLocalesOf);
 
 
 /**
  * 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 (dateValue === undefined) {
     dateMs = GlobalDate.now();
   } else {
     dateMs = GlobalNumber(dateValue);
   }
 
-  if (!$isFinite(dateMs)) {
-    throw new $RangeError('Provided date is not in valid range.');
-  }
+  if (!$isFinite(dateMs)) throw MakeRangeError(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 23 matching lines @@
   // Special case handling (UTC, GMT).
   var upperID = tzID.toUpperCase();
   if (upperID === 'UTC' || upperID === 'GMT' ||
       upperID === 'ETC/UTC' || upperID === 'ETC/GMT') {
     return 'UTC';
   }
 
   // We expect only _ and / beside ASCII letters.
   // All inputs should conform to Area/Location from now on.
   var match = GetTimezoneNameCheckRE().exec(tzID);
-  if (IS_NULL(match)) {
-    throw new $RangeError('Expected Area/Location for time zone, got ' + tzID);
-  }
+  if (IS_NULL(match)) throw MakeRangeError(kExpectedLocation, tzID);
 
   var result = toTitleCaseWord(match[1]) + '/' + toTitleCaseWord(match[2]);
   var i = 3;
   while (match[i] !== undefined && i < match.length) {
     result = result + '_' + toTitleCaseWord(match[i]);
     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 new $TypeError('Trying to re-initialize v8BreakIterator object.');
+    throw MakeTypeError(kReinitializeIntl, "v8BreakIterator");
   }
 
   if (options === undefined) {
     options = {};
   }
 
   var getOption = getGetOption(options, 'breakiterator');
 
   var internalOptions = {};
 
@@ skipping 39 matching lines @@
   DONT_ENUM
 );
 
 
 /**
  * BreakIterator resolvedOptions method.
  */
 %AddNamedProperty(Intl.v8BreakIterator.prototype, 'resolvedOptions',
   function() {
     if (%_IsConstructCall()) {
-      throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
+      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     if (!%IsInitializedIntlObjectOfType(this, 'breakiterator')) {
-      throw new $TypeError('resolvedOptions method called on a non-object or ' +
-          'on a object that is not Intl.v8BreakIterator.');
+      throw MakeTypeError(kResolvedOptionsCalledOnNonObject, "v8BreakIterator");
     }
 
     var segmenter = this;
     var locale = getOptimalLanguageTag(segmenter.resolved.requestedLocale,
                                        segmenter.resolved.locale);
 
     return {
       locale: locale,
       type: segmenter.resolved.type
     };
   },
   DONT_ENUM
 );
 %FunctionSetName(Intl.v8BreakIterator.prototype.resolvedOptions,
                  'resolvedOptions');
 %FunctionRemovePrototype(Intl.v8BreakIterator.prototype.resolvedOptions);
 %SetNativeFlag(Intl.v8BreakIterator.prototype.resolvedOptions);
 
 
 /**
  * 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.
  */
 %AddNamedProperty(Intl.v8BreakIterator, 'supportedLocalesOf',
   function(locales) {
     if (%_IsConstructCall()) {
-      throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
+      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     return supportedLocalesOf('breakiterator', locales, %_Arguments(1));
   },
   DONT_ENUM
 );
 %FunctionSetName(Intl.v8BreakIterator.supportedLocalesOf, 'supportedLocalesOf');
 %FunctionRemovePrototype(Intl.v8BreakIterator.supportedLocalesOf);
 %SetNativeFlag(Intl.v8BreakIterator.supportedLocalesOf);
 
@@ skipping 82 matching lines @@
   return new savedObjects[service](locales, useOptions);
 }
 
 
 /**
  * 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 (%_IsConstructCall()) {
-      throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
+      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     if (IS_NULL_OR_UNDEFINED(this)) {
-      throw new $TypeError('Method invoked on undefined or null value.');
+      throw MakeTypeError(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(that) {
     if (%_IsConstructCall()) {
-      throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
+      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     CHECK_OBJECT_COERCIBLE(this, "String.prototype.normalize");
 
     var form = GlobalString(%_Arguments(0) || 'NFC');
 
     var normalizationForm = NORMALIZATION_FORMS.indexOf(form);
     if (normalizationForm === -1) {
-      throw new $RangeError('The normalization form should be one of '
-          + NORMALIZATION_FORMS.join(', ') + '.');
+      throw MakeRangeError(kNormalizationForm, NORMALIZATION_FORMS.join(', '));
     }
 
     return %StringNormalize(this, normalizationForm);
   }
 );
 
 
 /**
  * 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 (%_IsConstructCall()) {
-      throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
+      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     if (!(this instanceof GlobalNumber) && typeof(this) !== 'number') {
-      throw new $TypeError('Method invoked on an object that is not Number.');
+      throw MakeTypeError(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 new $TypeError('Method invoked on an object that is not Date.');
+    throw MakeTypeError(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 (%_IsConstructCall()) {
-      throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
+      throw MakeTypeError(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 (%_IsConstructCall()) {
-      throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
+      throw MakeTypeError(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 (%_IsConstructCall()) {
-      throw new $TypeError(ORDINARY_FUNCTION_CALLED_AS_CONSTRUCTOR);
+      throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
     var locales = %_Arguments(0);
     var options = %_Arguments(1);
     return toLocaleDateTime(
         this, locales, options, 'time', 'time', 'dateformattime');
   }
 );
 
 })();