[intl] Create the Intl constructors 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.
  */
 (function(global, utils) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
 // -------------------------------------------------------------------
 // Imports
 
 var ArrayJoin;
 var ArrayPush;
 var GlobalDate = global.Date;
+var GlobalIntl = global.Intl;
+var GlobalIntlDateTimeFormat = GlobalIntl.DateTimeFormat;
+var GlobalIntlNumberFormat = GlobalIntl.NumberFormat;
+var GlobalIntlCollator = GlobalIntl.Collator;
+var GlobalIntlv8BreakIterator = GlobalIntl.v8BreakIterator;
 var GlobalNumber = global.Number;
 var GlobalRegExp = global.RegExp;
 var GlobalString = global.String;
 var IntlFallbackSymbol = utils.ImportNow("intl_fallback_symbol");
 var InstallFunctions = utils.InstallFunctions;
 var InstallGetter = utils.InstallGetter;
 var InternalArray = utils.InternalArray;
 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 StringSubstr = GlobalString.prototype.substr;
 var StringSubstring = GlobalString.prototype.substring;
 
 utils.Import(function(from) {
   ArrayJoin = from.ArrayJoin;
   ArrayPush = from.ArrayPush;
 });
 
 // Utilities for definitions
 
 function InstallFunction(object, name, func) {
   InstallFunctions(object, DONT_ENUM, [name, func]);
 }
 
 
-function InstallConstructor(object, name, func) {
-  %CheckIsBootstrapping();
-  SetFunctionName(func, name);
-  %AddNamedProperty(object, name, func, DONT_ENUM);
-  %SetNativeFlag(func);
-  %ToFastProperties(object);
-}
-
 /**
  * Adds bound method to the prototype of the given object.
  */
 function AddBoundMethod(obj, methodName, implementation, length, typename, compat) {
   %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
@@ skipping 62 matching lines @@
       }
     }
     throw %make_type_error(kIncompatibleMethodReceiver, method, receiver);
   }
   return receiver;
 }
 
 
 // -------------------------------------------------------------------
 
-var Intl = {};
-
-%AddNamedProperty(global, "Intl", Intl, DONT_ENUM);
-
 /**
  * Caches available locales for each service.
  */
 var AVAILABLE_LOCALES = {
   'collator': UNDEFINED,
   'numberformat': UNDEFINED,
   'dateformat': UNDEFINED,
   'breakiterator': UNDEFINED
 };
 
@@ skipping 786 matching lines @@
   get() {
     %IncrementUseCounter(kIntlResolved);
     return this[resolvedSymbol];
   },
   set(value) {
     this[resolvedSymbol] = value;
   }
 };
 
 // ECMA 402 section 8.2.1
-InstallFunction(Intl, 'getCanonicalLocales', function(locales) {
+InstallFunction(GlobalIntl, 'getCanonicalLocales', function(locales) {
     return makeArray(canonicalizeLocaleList(locales));
   }
 );
 
 /**
  * Initializes the given object so it's a valid Collator instance.
  * Useful for subclassing.
  */
 function initializeCollator(collator, locales, options) {
   if (%IsInitializedIntlObject(collator)) {
@@ skipping 97 matching lines @@
   return collator;
 }
 
 
 /**
  * Constructs Intl.Collator object given optional locales and options
  * parameters.
  *
  * @constructor
  */
-function Collator() {
-  return IntlConstruct(this, Collator, initializeCollator, new.target,
+function CollatorConstructor() {
+  return IntlConstruct(this, GlobalIntlCollator, initializeCollator, new.target,
                        arguments);
 }
-InstallConstructor(Intl, 'Collator', Collator);
+%SetCode(GlobalIntlCollator, CollatorConstructor);
 
 
 /**
  * Collator resolvedOptions method.
  */
-InstallFunction(Intl.Collator.prototype, 'resolvedOptions', function() {
-    var coll = Unwrap(this, 'collator', Collator, 'resolvedOptions', false);
+InstallFunction(GlobalIntlCollator.prototype, 'resolvedOptions', function() {
+    var coll = Unwrap(this, 'collator', GlobalIntlCollator, 'resolvedOptions',
+                      false);
     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) {
+InstallFunction(GlobalIntlCollator, 'supportedLocalesOf', function(locales) {
     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
  * String comparison of x with y.
  * The result is intended to order String values in the sort order specified
  * by the effective locale and collation options computed during construction
  * of this Collator object, and will be negative, zero, or positive, depending
  * on whether x comes before y in the sort order, the Strings are equal under
  * the sort order, or x comes after y in the sort order, respectively.
  */
 function compare(collator, x, y) {
   return %InternalCompare(%GetImplFromInitializedIntlObject(collator),
                           TO_STRING(x), TO_STRING(y));
 };
 
 
-AddBoundMethod(Intl.Collator, 'compare', compare, 2, 'collator', false);
+AddBoundMethod(GlobalIntlCollator, 'compare', compare, 2, 'collator', false);
 
 /**
  * Verifies that the input is a well-formed ISO 4217 currency code.
  * Don't uppercase to test. It could convert invalid code into a valid one.
  * For example \u00DFP (Eszett+P) becomes SSP.
  */
 function isWellFormedCurrencyCode(currency) {
   return typeof currency == "string" && currency.length == 3 &&
       IS_NULL(%regexp_internal_match(/[^A-Za-z]/, currency));
 }
@@ skipping 145 matching lines @@
   return numberFormat;
 }
 
 
 /**
  * Constructs Intl.NumberFormat object given optional locales and options
  * parameters.
  *
  * @constructor
  */
-function NumberFormat() {
-  return IntlConstruct(this, NumberFormat, initializeNumberFormat, new.target,
-                       arguments, true);
+function NumberFormatConstructor() {
+  return IntlConstruct(this, GlobalIntlNumberFormat, initializeNumberFormat,
+                       new.target, arguments, true);
 }
-InstallConstructor(Intl, 'NumberFormat', NumberFormat);
+%SetCode(GlobalIntlNumberFormat, NumberFormatConstructor);
 
 
 /**
  * NumberFormat resolvedOptions method.
  */
-InstallFunction(Intl.NumberFormat.prototype, 'resolvedOptions', function() {
-    var format = Unwrap(this, 'numberformat', NumberFormat,
+InstallFunction(GlobalIntlNumberFormat.prototype, 'resolvedOptions',
+  function() {
+    var format = Unwrap(this, 'numberformat', GlobalIntlNumberFormat,
                         'resolvedOptions', true);
     var locale = getOptimalLanguageTag(format[resolvedSymbol].requestedLocale,
                                        format[resolvedSymbol].locale);
 
     var result = {
       locale: locale,
       numberingSystem: format[resolvedSymbol].numberingSystem,
       style: format[resolvedSymbol].style,
       useGrouping: format[resolvedSymbol].useGrouping,
       minimumIntegerDigits: format[resolvedSymbol].minimumIntegerDigits,
@@ skipping 21 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) {
+InstallFunction(GlobalIntlNumberFormat, 'supportedLocalesOf',
+  function(locales) {
     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
  * NumberFormat.
  */
 function formatNumber(formatter, value) {
   // Spec treats -0 and +0 as 0.
   var number = TO_NUMBER(value) + 0;
 
   return %InternalNumberFormat(%GetImplFromInitializedIntlObject(formatter),
                                number);
 }
 
 
-AddBoundMethod(Intl.NumberFormat, 'format', formatNumber, 1, 'numberformat', true);
+AddBoundMethod(GlobalIntlNumberFormat, 'format', formatNumber, 1,
+               'numberformat', true);
 
 /**
  * Returns a string that matches LDML representation of the options object.
  */
 function toLDMLString(options) {
   var getOption = getGetOption(options, 'dateformat');
 
   var ldmlString = '';
 
   var option = getOption('weekday', 'string', ['narrow', 'short', 'long']);
@@ skipping 272 matching lines @@
   return dateFormat;
 }
 
 
 /**
  * Constructs Intl.DateTimeFormat object given optional locales and options
  * parameters.
  *
  * @constructor
  */
-function DateTimeFormat() {
-  return IntlConstruct(this, DateTimeFormat, initializeDateTimeFormat,
+function DateTimeFormatConstructor() {
+  return IntlConstruct(this, GlobalIntlDateTimeFormat, initializeDateTimeFormat,
                        new.target, arguments, true);
 }
-InstallConstructor(Intl, 'DateTimeFormat', DateTimeFormat);
+%SetCode(GlobalIntlDateTimeFormat, DateTimeFormatConstructor);
 
 
 /**
  * DateTimeFormat resolvedOptions method.
  */
-InstallFunction(Intl.DateTimeFormat.prototype, 'resolvedOptions', function() {
-    var format = Unwrap(this, 'dateformat', DateTimeFormat,
+InstallFunction(GlobalIntlDateTimeFormat.prototype, 'resolvedOptions',
+  function() {
+    var format = Unwrap(this, 'dateformat', GlobalIntlDateTimeFormat,
                         'resolvedOptions', true);
 
     /**
      * Maps ICU calendar names to LDML/BCP47 types for key 'ca'.
      * See typeMap section in third_party/icu/source/data/misc/keyTypeData.txt
      * and
      * http://www.unicode.org/repos/cldr/tags/latest/common/bcp47/calendar.xml
      */
     var ICU_CALENDAR_MAP = {
       'gregorian': 'gregory',
@@ skipping 32 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) {
+InstallFunction(GlobalIntlDateTimeFormat, 'supportedLocalesOf',
+  function(locales) {
     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.
  */
@@ skipping 26 matching lines @@
   if (!NUMBER_IS_FINITE(dateMs)) throw %make_range_error(kDateRange);
 
   return %InternalDateFormatToParts(
       %GetImplFromInitializedIntlObject(this), new GlobalDate(dateMs));
 }
 
 %FunctionSetLength(FormatDateToParts, 0);
 
 
 // 0 because date is optional argument.
-AddBoundMethod(Intl.DateTimeFormat, 'format', formatDate, 0, 'dateformat', true);
+AddBoundMethod(GlobalIntlDateTimeFormat, 'format', formatDate, 0, 'dateformat',
+               true);
 
 
 /**
  * Returns canonical Area/Location(/Location) name, or throws an exception
  * if the zone name is invalid IANA name.
  */
 function canonicalizeTimeZoneID(tzID) {
   // Skip undefined zones.
   if (IS_UNDEFINED(tzID)) {
     return tzID;
@@ skipping 68 matching lines @@
   return iterator;
 }
 
 
 /**
  * Constructs Intl.v8BreakIterator object given optional locales and options
  * parameters.
  *
  * @constructor
  */
-function v8BreakIterator() {
-  return IntlConstruct(this, v8BreakIterator, initializeBreakIterator,
+function v8BreakIteratorConstructor() {
+  return IntlConstruct(this, GlobalIntlv8BreakIterator, initializeBreakIterator,
                        new.target, arguments);
 }
-InstallConstructor(Intl, 'v8BreakIterator', v8BreakIterator);
+%SetCode(GlobalIntlv8BreakIterator, v8BreakIteratorConstructor);
 
 
 /**
  * BreakIterator resolvedOptions method.
  */
-InstallFunction(Intl.v8BreakIterator.prototype, 'resolvedOptions',
+InstallFunction(GlobalIntlv8BreakIterator.prototype, 'resolvedOptions',
   function() {
     if (!IS_UNDEFINED(new.target)) {
       throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
     }
 
-    var segmenter = Unwrap(this, 'breakiterator', v8BreakIterator,
+    var segmenter = Unwrap(this, 'breakiterator', GlobalIntlv8BreakIterator,
                            'resolvedOptions', false);
 
     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',
+InstallFunction(GlobalIntlv8BreakIterator, 'supportedLocalesOf',
   function(locales) {
     if (!IS_UNDEFINED(new.target)) {
       throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
     }
 
     return supportedLocalesOf('breakiterator', locales, arguments[1]);
   }
 );
 
 
@@ skipping 32 matching lines @@
 
 
 /**
  * Returns type of the current break.
  */
 function breakType(iterator) {
   return %BreakIteratorBreakType(%GetImplFromInitializedIntlObject(iterator));
 }
 
 
-AddBoundMethod(Intl.v8BreakIterator, 'adoptText', adoptText, 1,
+AddBoundMethod(GlobalIntlv8BreakIterator, 'adoptText', adoptText, 1,
                'breakiterator');
-AddBoundMethod(Intl.v8BreakIterator, 'first', first, 0, 'breakiterator');
-AddBoundMethod(Intl.v8BreakIterator, 'next', next, 0, 'breakiterator');
-AddBoundMethod(Intl.v8BreakIterator, 'current', current, 0, 'breakiterator');
-AddBoundMethod(Intl.v8BreakIterator, 'breakType', breakType, 0,
+AddBoundMethod(GlobalIntlv8BreakIterator, 'first', first, 0, 'breakiterator');
+AddBoundMethod(GlobalIntlv8BreakIterator, 'next', next, 0, 'breakiterator');
+AddBoundMethod(GlobalIntlv8BreakIterator, 'current', current, 0,
+               'breakiterator');
+AddBoundMethod(GlobalIntlv8BreakIterator, 'breakType', breakType, 0,
                'breakiterator');
 
 // Save references to Intl objects and methods we use, for added security.
 var savedObjects = {
-  'collator': Intl.Collator,
-  'numberformat': Intl.NumberFormat,
-  'dateformatall': Intl.DateTimeFormat,
-  'dateformatdate': Intl.DateTimeFormat,
-  'dateformattime': Intl.DateTimeFormat
+  'collator': GlobalIntlCollator,
+  'numberformat': GlobalIntlNumberFormat,
+  'dateformatall': GlobalIntlDateTimeFormat,
+  'dateformatdate': GlobalIntlDateTimeFormat,
+  'dateformattime': GlobalIntlDateTimeFormat
 };
 
 
 // Default (created with undefined locales and options parameters) collator,
 // number and date format instances. They'll be created as needed.
 var defaultObjects = {
   'collator': UNDEFINED,
   'numberformat': UNDEFINED,
   'dateformatall': UNDEFINED,
   'dateformatdate': UNDEFINED,
@@ skipping 224 matching lines @@
   }
 );
 
 %FunctionRemovePrototype(FormatDateToParts);
 
 utils.Export(function(to) {
   to.FormatDateToParts = FormatDateToParts;
 });
 
 })