[intl] Remove indirection in Intl objects

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 78 matching lines @@
       receiver[internalName] = boundMethod;
     }
     return receiver[internalName];
   });
 
   %FunctionRemovePrototype(getter);
   %DefineGetterPropertyUnchecked(obj.prototype, methodName, getter, DONT_ENUM);
   %SetNativeFlag(getter);
 }
 
-function IntlConstruct(receiver, constructor, initializer, newTarget, args,
+function IntlConstruct(receiver, constructor, create, newTarget, args,
                        compat) {
   var locales = args[0];
   var options = args[1];
 
   if (IS_UNDEFINED(newTarget)) {
     if (compat && receiver instanceof constructor) {
       let success = %object_define_property(receiver, IntlFallbackSymbol,
                            { value: new constructor(locales, options) });
       if (!success) {
         throw %make_type_error(kReinitializeIntl, constructor);
       }
       return receiver;
     }
 
     return new constructor(locales, options);
   }
 
-  return initializer(receiver, locales, options);
+  return create(locales, options);
 }
 
 
 
 function Unwrap(receiver, typename, constructor, method, compat) {
   if (!%IsInitializedIntlObjectOfType(receiver, typename)) {
     if (compat && receiver instanceof constructor) {
       let fallback = receiver[IntlFallbackSymbol];
       if (%IsInitializedIntlObjectOfType(fallback, typename)) {
         return fallback;
@@ skipping 815 matching lines @@
 // ECMA 402 section 8.2.1
 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)) {
-    throw %make_type_error(kReinitializeIntl, "Collator");
-  }
-
+function CreateCollator(locales, options) {
   if (IS_UNDEFINED(options)) {
     options = {};
   }
 
   var getOption = getGetOption(options, 'collator');
 
   var internalOptions = {};
 
   defineWEProperty(internalOptions, 'usage', getOption(
     'usage', 'string', ['sort', 'search'], 'sort'));
@@ skipping 66 matching lines @@
     collation: {value: internalOptions.collation, writable: true},
     ignorePunctuation: {writable: true},
     locale: {writable: true},
     numeric: {writable: true},
     requestedLocale: {value: requestedLocale, writable: true},
     sensitivity: {writable: true},
     strength: {writable: true},
     usage: {value: internalOptions.usage, writable: true}
   });
 
-  var internalCollator = %CreateCollator(requestedLocale,
-                                         internalOptions,
-                                         resolved);
+  var collator = %CreateCollator(requestedLocale, internalOptions, resolved);
 
-  // Writable, configurable and enumerable are set to false by default.
-  %MarkAsInitializedIntlObjectOfType(collator, 'collator', internalCollator);
+  %MarkAsInitializedIntlObjectOfType(collator, 'collator');
   collator[resolvedSymbol] = resolved;
 
   return collator;
 }
 
 
 /**
  * Constructs Intl.Collator object given optional locales and options
  * parameters.
  *
  * @constructor
  */
 function CollatorConstructor() {
-  return IntlConstruct(this, GlobalIntlCollator, initializeCollator, new.target,
+  return IntlConstruct(this, GlobalIntlCollator, CreateCollator, new.target,
                        arguments);
 }
 %SetCode(GlobalIntlCollator, CollatorConstructor);
 
 
 /**
  * Collator resolvedOptions method.
  */
 InstallFunction(GlobalIntlCollator.prototype, 'resolvedOptions', function() {
     var coll = Unwrap(this, 'collator', GlobalIntlCollator, 'resolvedOptions',
@@ skipping 30 matching lines @@
  * 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));
+  return %InternalCompare(collator, TO_STRING(x), TO_STRING(y));
 };
 
 
 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.
  */
@@ skipping 27 matching lines @@
   },
   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 %make_type_error(kReinitializeIntl, "NumberFormat");
-  }
-
+function CreateNumberFormat(locales, options) {
   if (IS_UNDEFINED(options)) {
     options = {};
   }
 
   var getOption = getGetOption(options, 'numberformat');
 
   var locale = resolveLocale('numberformat', locales, options);
 
   var internalOptions = {};
   defineWEProperty(internalOptions, 'style', getOption(
@@ skipping 75 matching lines @@
     requestedLocale: {value: requestedLocale, writable: true},
     style: {value: internalOptions.style, writable: true},
     useGrouping: {writable: true}
   });
   if (HAS_OWN_PROPERTY(internalOptions, 'minimumSignificantDigits')) {
     defineWEProperty(resolved, 'minimumSignificantDigits', UNDEFINED);
   }
   if (HAS_OWN_PROPERTY(internalOptions, 'maximumSignificantDigits')) {
     defineWEProperty(resolved, 'maximumSignificantDigits', UNDEFINED);
   }
-  var formatter = %CreateNumberFormat(requestedLocale,
-                                      internalOptions,
-                                      resolved);
+  var numberFormat = %CreateNumberFormat(requestedLocale, internalOptions,
+                                         resolved);
 
   if (internalOptions.style === 'currency') {
     %object_define_property(resolved, 'currencyDisplay',
         {value: currencyDisplay, writable: true});
   }
 
-  %MarkAsInitializedIntlObjectOfType(numberFormat, 'numberformat', formatter);
+  %MarkAsInitializedIntlObjectOfType(numberFormat, 'numberformat');
   numberFormat[resolvedSymbol] = resolved;
 
   return numberFormat;
 }
 
 
 /**
  * Constructs Intl.NumberFormat object given optional locales and options
  * parameters.
  *
  * @constructor
  */
 function NumberFormatConstructor() {
-  return IntlConstruct(this, GlobalIntlNumberFormat, initializeNumberFormat,
+  return IntlConstruct(this, GlobalIntlNumberFormat, CreateNumberFormat,
                        new.target, arguments, true);
 }
 %SetCode(GlobalIntlNumberFormat, NumberFormatConstructor);
 
 
 /**
  * NumberFormat resolvedOptions method.
  */
 InstallFunction(GlobalIntlNumberFormat.prototype, 'resolvedOptions',
   function() {
@@ skipping 48 matching lines @@
 
 /**
  * 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);
+  return %InternalNumberFormat(formatter, number);
 }
 
 
 AddBoundMethod(GlobalIntlNumberFormat, 'format', formatNumber, 1,
                'numberformat', true);
 
 /**
  * Returns a string that matches LDML representation of the options object.
  */
 function toLDMLString(options) {
@@ skipping 190 matching lines @@
   }
 
   return options;
 }
 
 
 /**
  * Initializes the given object so it's a valid DateTimeFormat instance.
  * Useful for subclassing.
  */
-function initializeDateTimeFormat(dateFormat, locales, options) {
-
-  if (%IsInitializedIntlObject(dateFormat)) {
-    throw %make_type_error(kReinitializeIntl, "DateTimeFormat");
-  }
-
+function CreateDateTimeFormat(locales, options) {
   if (IS_UNDEFINED(options)) {
     options = {};
   }
 
   var locale = resolveLocale('dateformat', locales, options);
 
   options = toDateTimeOptions(options, 'any', 'date');
 
   var getOption = getGetOption(options, 'dateformat');
 
@@ skipping 41 matching lines @@
     [patternSymbol]: {writable: true},
     requestedLocale: {value: requestedLocale, writable: true},
     second: {writable: true},
     timeZone: {writable: true},
     timeZoneName: {writable: true},
     tz: {value: tz, writable: true},
     weekday: {writable: true},
     year: {writable: true}
   });
 
-  var formatter = %CreateDateTimeFormat(
+  var dateFormat = %CreateDateTimeFormat(
     requestedLocale, {skeleton: ldmlString, timeZone: tz}, resolved);
 
   if (resolved.timeZone === "Etc/Unknown") {
     throw %make_range_error(kUnsupportedTimeZone, tz);
   }
 
-  %MarkAsInitializedIntlObjectOfType(dateFormat, 'dateformat', formatter);
+  %MarkAsInitializedIntlObjectOfType(dateFormat, 'dateformat');
   dateFormat[resolvedSymbol] = resolved;
 
   return dateFormat;
 }
 
 
 /**
  * Constructs Intl.DateTimeFormat object given optional locales and options
  * parameters.
  *
  * @constructor
  */
 function DateTimeFormatConstructor() {
-  return IntlConstruct(this, GlobalIntlDateTimeFormat, initializeDateTimeFormat,
+  return IntlConstruct(this, GlobalIntlDateTimeFormat, CreateDateTimeFormat,
                        new.target, arguments, true);
 }
 %SetCode(GlobalIntlDateTimeFormat, DateTimeFormatConstructor);
 
 
 /**
  * DateTimeFormat resolvedOptions method.
  */
 InstallFunction(GlobalIntlDateTimeFormat.prototype, 'resolvedOptions',
   function() {
@@ skipping 65 matching lines @@
 function formatDate(formatter, dateValue) {
   var dateMs;
   if (IS_UNDEFINED(dateValue)) {
     dateMs = %DateCurrentTime();
   } else {
     dateMs = TO_NUMBER(dateValue);
   }
 
   if (!NUMBER_IS_FINITE(dateMs)) throw %make_range_error(kDateRange);
 
-  return %InternalDateFormat(%GetImplFromInitializedIntlObject(formatter),
-                             new GlobalDate(dateMs));
+  return %InternalDateFormat(formatter, new GlobalDate(dateMs));
 }
 
 function FormatDateToParts(dateValue) {
   CHECK_OBJECT_COERCIBLE(this, "Intl.DateTimeFormat.prototype.formatToParts");
   if (!IS_OBJECT(this)) {
     throw %make_type_error(kCalledOnNonObject, this);
   }
   if (!%IsInitializedIntlObjectOfType(this, 'dateformat')) {
     throw %make_type_error(kIncompatibleMethodReceiver,
                           'Intl.DateTimeFormat.prototype.formatToParts',
                           this);
   }
   var dateMs;
   if (IS_UNDEFINED(dateValue)) {
     dateMs = %DateCurrentTime();
   } else {
     dateMs = TO_NUMBER(dateValue);
   }
 
   if (!NUMBER_IS_FINITE(dateMs)) throw %make_range_error(kDateRange);
 
-  return %InternalDateFormatToParts(
-      %GetImplFromInitializedIntlObject(this), new GlobalDate(dateMs));
+  return %InternalDateFormatToParts(this, new GlobalDate(dateMs));
 }
 
 %FunctionSetLength(FormatDateToParts, 0);
 
 
 // 0 because date is optional argument.
 AddBoundMethod(GlobalIntlDateTimeFormat, 'format', formatDate, 0, 'dateformat',
                true);
 
 
@@ skipping 35 matching lines @@
     }
   }
 
   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 %make_type_error(kReinitializeIntl, "v8BreakIterator");
-  }
-
+function CreateBreakIterator(locales, options) {
   if (IS_UNDEFINED(options)) {
     options = {};
   }
 
   var getOption = getGetOption(options, 'breakiterator');
 
   var internalOptions = {};
 
   defineWEProperty(internalOptions, 'type', getOption(
     'type', 'string', ['character', 'word', 'sentence', 'line'], 'word'));
 
   var locale = resolveLocale('breakiterator', locales, options);
   var resolved = %object_define_properties({}, {
     requestedLocale: {value: locale.locale, writable: true},
     type: {value: internalOptions.type, writable: true},
     locale: {writable: true}
   });
 
-  var internalIterator = %CreateBreakIterator(locale.locale,
-                                              internalOptions,
-                                              resolved);
+  var iterator = %CreateBreakIterator(locale.locale, internalOptions, resolved);
 
-  %MarkAsInitializedIntlObjectOfType(iterator, 'breakiterator',
-                                     internalIterator);
+  %MarkAsInitializedIntlObjectOfType(iterator, 'breakiterator');
   iterator[resolvedSymbol] = resolved;
 
   return iterator;
 }
 
 
 /**
  * Constructs Intl.v8BreakIterator object given optional locales and options
  * parameters.
  *
  * @constructor
  */
 function v8BreakIteratorConstructor() {
-  return IntlConstruct(this, GlobalIntlv8BreakIterator, initializeBreakIterator,
+  return IntlConstruct(this, GlobalIntlv8BreakIterator, CreateBreakIterator,
                        new.target, arguments);
 }
 %SetCode(GlobalIntlv8BreakIterator, v8BreakIteratorConstructor);
 
 
 /**
  * BreakIterator resolvedOptions method.
  */
 InstallFunction(GlobalIntlv8BreakIterator.prototype, 'resolvedOptions',
   function() {
@@ skipping 31 matching lines @@
     return supportedLocalesOf('breakiterator', locales, arguments[1]);
   }
 );
 
 
 /**
  * Adopts text to segment using the iterator. Old text, if present,
  * gets discarded.
  */
 function adoptText(iterator, text) {
-  %BreakIteratorAdoptText(%GetImplFromInitializedIntlObject(iterator),
-                          TO_STRING(text));
+  %BreakIteratorAdoptText(iterator, TO_STRING(text));
 }
 
 
 /**
  * Returns index of the first break in the string and moves current pointer.
  */
 function first(iterator) {
-  return %BreakIteratorFirst(%GetImplFromInitializedIntlObject(iterator));
+  return %BreakIteratorFirst(iterator);
 }
 
 
 /**
  * Returns the index of the next break and moves the pointer.
  */
 function next(iterator) {
-  return %BreakIteratorNext(%GetImplFromInitializedIntlObject(iterator));
+  return %BreakIteratorNext(iterator);
 }
 
 
 /**
  * Returns index of the current break.
  */
 function current(iterator) {
-  return %BreakIteratorCurrent(%GetImplFromInitializedIntlObject(iterator));
+  return %BreakIteratorCurrent(iterator);
 }
 
 
 /**
  * Returns type of the current break.
  */
 function breakType(iterator) {
-  return %BreakIteratorBreakType(%GetImplFromInitializedIntlObject(iterator));
+  return %BreakIteratorBreakType(iterator);
 }
 
 
 AddBoundMethod(GlobalIntlv8BreakIterator, 'adoptText', adoptText, 1,
                'breakiterator');
 AddBoundMethod(GlobalIntlv8BreakIterator, 'first', first, 0, 'breakiterator');
 AddBoundMethod(GlobalIntlv8BreakIterator, 'next', next, 0, 'breakiterator');
 AddBoundMethod(GlobalIntlv8BreakIterator, 'current', current, 0,
                'breakiterator');
 AddBoundMethod(GlobalIntlv8BreakIterator, 'breakType', breakType, 0,
@@ skipping 236 matching lines @@
   }
 );
 
 %FunctionRemovePrototype(FormatDateToParts);
 
 utils.Export(function(to) {
   to.FormatDateToParts = FormatDateToParts;
 });
 
 })