Add new semantics + compat fallback to Intl constructor

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 11 matching lines @@
 var ArrayPush;
 var InstallFunctions = utils.InstallFunctions;
 var InstallGetter = utils.InstallGetter;
 var IsFinite;
 var IsNaN;
 var GlobalBoolean = global.Boolean;
 var GlobalDate = global.Date;
 var GlobalNumber = global.Number;
 var GlobalRegExp = global.RegExp;
 var GlobalString = global.String;
+var GlobalSymbol = global.Symbol;
 var MakeError;
 var MakeRangeError;
 var MakeTypeError;
 var MathFloor;
 var ObjectDefineProperties = utils.ImportNow("ObjectDefineProperties");
 var ObjectDefineProperty = utils.ImportNow("ObjectDefineProperty");
 var ObjectHasOwnProperty = utils.ImportNow("ObjectHasOwnProperty");
 var OverrideFunction = utils.OverrideFunction;
 var patternSymbol = utils.ImportNow("intl_pattern_symbol");
 var RegExpTest;
@@ skipping 35 matching lines @@
 
 
 function InstallConstructor(object, name, func) {
   %CheckIsBootstrapping();
   SetFunctionName(func, name);
   %AddNamedProperty(object, name, func, DONT_ENUM);
   %SetNativeFlag(func);
   %ToFastProperties(object);
 }
 
+var fallbackSymbol = GlobalSymbol("intl fallback");
+
 /**
  * Adds bound method to the prototype of the given object.
  */
-function AddBoundMethod(obj, methodName, implementation, length) {
+function AddBoundMethod(obj, methodName, implementation, length, typename, compat) {
   %CheckIsBootstrapping();
   var internalName = %CreatePrivateSymbol(methodName);
   var getter = function() {
-    if (!%IsInitializedIntlObject(this)) {
-      throw MakeTypeError(kMethodCalledOnWrongObject, methodName);
-    }
-    if (IS_UNDEFINED(this[internalName])) {
+    var receiver = Unwrap(this, typename, obj, methodName, compat);
+    if (IS_UNDEFINED(receiver[internalName])) {
       var boundMethod;
       if (IS_UNDEFINED(length) || length === 2) {
-        boundMethod = (x, y) => implementation(this, x, y);
+        boundMethod = (x, y) => implementation(receiver, x, y);
       } else if (length === 1) {
-        boundMethod = x => implementation(this, x);
+        boundMethod = x => implementation(receiver, x);
       } else {
         boundMethod = (...args) => {
           // DateTimeFormat.format needs to be 0 arg method, but can stil
           // receive optional dateValue param. If one was provided, pass it
           // along.
           if (args.length > 0) {
-            return implementation(this, args[0]);
+            return implementation(receiver, args[0]);
           } else {
-            return implementation(this);
+            return implementation(receiver);
           }
         }
       }
       // TODO(littledan): Once function name reform is shipped, remove the
       // following line and wrap the boundMethod definition in an anonymous
       // function macro.
       %FunctionSetName(boundMethod, '__bound' + methodName + '__');
       %FunctionRemovePrototype(boundMethod);
       %SetNativeFlag(boundMethod);
-      this[internalName] = boundMethod;
+      receiver[internalName] = boundMethod;
     }
-    return this[internalName];
+    return receiver[internalName];
   };
 
   InstallGetter(obj.prototype, methodName, getter, DONT_ENUM);
 }
 
+function IntlConstruct(receiver, constructor, initializer, newTarget, args,
+                       compat) {
+  var locales = args[0];
+  var options = args[1];
+
+  if (IS_UNDEFINED(newTarget)) {
+    if (compat && receiver instanceof constructor) {
+      let success = ObjectDefineProperty(receiver, fallbackSymbol,
+                           { value: new constructor(locales, options) });
+      if (!success) {
+        throw MakeTypeError(kReinitializeIntl, constructor);
+      }
+      return receiver;
+    }
+
+    return new constructor(locales, options);
+  }
+
+  return initializer(receiver, locales, options);
+}
+
+
+
+function Unwrap(receiver, typename, constructor, method, compat) {
+  if (!%IsInitializedIntlObjectOfType(receiver, typename)) {
+    if (compat && receiver instanceof constructor) {
+      let fallback = receiver[fallbackSymbol];
+      if (%IsInitializedIntlObjectOfType(fallback, typename)) {
+        return fallback;
+      }
+    }
+    throw MakeTypeError(kIncompatibleMethodReceiver, method, receiver);
+  }
+  return receiver;
+}
+
+
 // -------------------------------------------------------------------
 
 var Intl = {};
 
 %AddNamedProperty(global, "Intl", Intl, DONT_ENUM);
 
 /**
  * Caches available locales for each service.
  */
 var AVAILABLE_LOCALES = {
@@ skipping 856 matching lines @@
   return collator;
 }
 
 
 /**
  * Constructs Intl.Collator object given optional locales and options
  * parameters.
  *
  * @constructor
  */
-InstallConstructor(Intl, 'Collator', function() {
-    var locales = arguments[0];
-    var options = arguments[1];
-
-    if (!this || this === Intl) {
-      // Constructor is called as a function.
-      return new Intl.Collator(locales, options);
-    }
-
-    return initializeCollator(TO_OBJECT(this), locales, options);
-  }
-);
+function Collator() {
+  return IntlConstruct(this, Collator, initializeCollator, new.target,
+                       arguments);
+}
+InstallConstructor(Intl, 'Collator', Collator);
 
 
 /**
  * Collator resolvedOptions method.
  */
 InstallFunction(Intl.Collator.prototype, 'resolvedOptions', function() {
     if (!IS_UNDEFINED(new.target)) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
-    if (!%IsInitializedIntlObjectOfType(this, 'collator')) {
-      throw MakeTypeError(kResolvedOptionsCalledOnNonObject, "Collator");
-    }
-
-    var coll = this;
+    var coll = Unwrap(this, 'collator', Collator, 'resolvedOptions', true);
     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,
@@ skipping 28 matching lines @@
  * 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),
                           GlobalString(x), GlobalString(y));
 };
 
 
-AddBoundMethod(Intl.Collator, 'compare', compare, 2);
+AddBoundMethod(Intl.Collator, 'compare', compare, 2, 'collator', Collator);
 
 /**
  * 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 &&
       %_Call(StringMatch, currency, /[^A-Za-z]/) == null;
@@ skipping 148 matching lines @@
   return numberFormat;
 }
 
 
 /**
  * Constructs Intl.NumberFormat object given optional locales and options
  * parameters.
  *
  * @constructor
  */
-InstallConstructor(Intl, 'NumberFormat', function() {
-    var locales = arguments[0];
-    var options = arguments[1];
-
-    if (!this || this === Intl) {
-      // Constructor is called as a function.
-      return new Intl.NumberFormat(locales, options);
-    }
-
-    return initializeNumberFormat(TO_OBJECT(this), locales, options);
-  }
-);
+function NumberFormat() {
+  return IntlConstruct(this, NumberFormat, initializeNumberFormat, new.target,
+                       arguments, true);
+}
+InstallConstructor(Intl, 'NumberFormat', NumberFormat);
 
 
 /**
  * NumberFormat resolvedOptions method.
  */
 InstallFunction(Intl.NumberFormat.prototype, 'resolvedOptions', function() {
     if (!IS_UNDEFINED(new.target)) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
-    if (!%IsInitializedIntlObjectOfType(this, 'numberformat')) {
-      throw MakeTypeError(kResolvedOptionsCalledOnNonObject, "NumberFormat");
-    }
-
-    var format = this;
+    var format = Unwrap(this, 'numberformat', NumberFormat,
+                        '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,
       minimumFractionDigits: format[resolvedSymbol].minimumFractionDigits,
@@ skipping 53 matching lines @@
 
 /**
  * Returns a Number that represents string value that was passed in.
  */
 function parseNumber(formatter, value) {
   return %InternalNumberParse(%GetImplFromInitializedIntlObject(formatter),
                               GlobalString(value));
 }
 
 
-AddBoundMethod(Intl.NumberFormat, 'format', formatNumber, 1);
-AddBoundMethod(Intl.NumberFormat, 'v8Parse', parseNumber, 1);
+AddBoundMethod(Intl.NumberFormat, 'format', formatNumber, 1, 'numberformat', true);
+AddBoundMethod(Intl.NumberFormat, 'v8Parse', parseNumber, 1, 'numberformat');
 
 /**
  * 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
  */
-InstallConstructor(Intl, 'DateTimeFormat', function() {
-    var locales = arguments[0];
-    var options = arguments[1];
-
-    if (!this || this === Intl) {
-      // Constructor is called as a function.
-      return new Intl.DateTimeFormat(locales, options);
-    }
-
-    return initializeDateTimeFormat(TO_OBJECT(this), locales, options);
-  }
-);
+function DateTimeFormat() {
+  return IntlConstruct(this, DateTimeFormat, initializeDateTimeFormat,
+                       new.target, arguments, true);
+}
+InstallConstructor(Intl, 'DateTimeFormat', DateTimeFormat);
 
 
 /**
  * DateTimeFormat resolvedOptions method.
  */
 InstallFunction(Intl.DateTimeFormat.prototype, 'resolvedOptions', function() {
     if (!IS_UNDEFINED(new.target)) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
-    if (!%IsInitializedIntlObjectOfType(this, 'dateformat')) {
-      throw MakeTypeError(kResolvedOptionsCalledOnNonObject, "DateTimeFormat");
-    }
+    var format = Unwrap(this, 'dateformat', DateTimeFormat,
+                        'resolvedOptions', true);
 
     /**
      * Maps ICU calendar names into LDML type.
      */
     var ICU_CALENDAR_MAP = {
       'gregorian': 'gregory',
       'japanese': 'japanese',
       'buddhist': 'buddhist',
       'roc': 'roc',
       'persian': 'persian',
@@ skipping 84 matching lines @@
  * DateTimeFormat.
  * Returns undefined if date string cannot be parsed.
  */
 function parseDate(formatter, value) {
   return %InternalDateParse(%GetImplFromInitializedIntlObject(formatter),
                             GlobalString(value));
 }
 
 
 // 0 because date is optional argument.
-AddBoundMethod(Intl.DateTimeFormat, 'format', formatDate, 0);
-AddBoundMethod(Intl.DateTimeFormat, 'v8Parse', parseDate, 1);
+AddBoundMethod(Intl.DateTimeFormat, 'format', formatDate, 0, 'dateformat', true);
+AddBoundMethod(Intl.DateTimeFormat, 'v8Parse', parseDate, 1, 'dateformat');
 
 
 /**
  * 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 66 matching lines @@
   return iterator;
 }
 
 
 /**
  * Constructs Intl.v8BreakIterator object given optional locales and options
  * parameters.
  *
  * @constructor
  */
-InstallConstructor(Intl, 'v8BreakIterator', function() {
-    var locales = arguments[0];
-    var options = arguments[1];
-
-    if (!this || this === Intl) {
-      // Constructor is called as a function.
-      return new Intl.v8BreakIterator(locales, options);
-    }
-
-    return initializeBreakIterator(TO_OBJECT(this), locales, options);
-  }
-);
+function v8BreakIterator() {
+  return IntlConstruct(this, v8BreakIterator, initializeBreakIterator,
+                       new.target, arguments);
+}
+InstallConstructor(Intl, 'v8BreakIterator', v8BreakIterator);
 
 
 /**
  * BreakIterator resolvedOptions method.
  */
 InstallFunction(Intl.v8BreakIterator.prototype, 'resolvedOptions',
   function() {
     if (!IS_UNDEFINED(new.target)) {
       throw MakeTypeError(kOrdinaryFunctionCalledAsConstructor);
     }
 
-    if (!%IsInitializedIntlObjectOfType(this, 'breakiterator')) {
-      throw MakeTypeError(kResolvedOptionsCalledOnNonObject, "v8BreakIterator");
-    }
+    var format = Unwrap(this, 'breakiterator', v8BreakIterator, 'resolvedOptions');
 
     var segmenter = this;
     var locale =
         getOptimalLanguageTag(segmenter[resolvedSymbol].requestedLocale,
                               segmenter[resolvedSymbol].locale);
 
     return {
       locale: locale,
       type: segmenter[resolvedSymbol].type
     };
@@ skipping 53 matching lines @@
 
 
 /**
  * Returns type of the current break.
  */
 function breakType(iterator) {
   return %BreakIteratorBreakType(%GetImplFromInitializedIntlObject(iterator));
 }
 
 
-AddBoundMethod(Intl.v8BreakIterator, 'adoptText', adoptText, 1);
-AddBoundMethod(Intl.v8BreakIterator, 'first', first, 0);
-AddBoundMethod(Intl.v8BreakIterator, 'next', next, 0);
-AddBoundMethod(Intl.v8BreakIterator, 'current', current, 0);
-AddBoundMethod(Intl.v8BreakIterator, 'breakType', breakType, 0);
+AddBoundMethod(Intl.v8BreakIterator, '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, '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
 };
 
@@ skipping 164 matching lines @@
     }
 
     var locales = arguments[0];
     var options = arguments[1];
     return toLocaleDateTime(
         this, locales, options, 'time', 'time', 'dateformattime');
   }
 );
 
 })