Expose getCanonicalLocales() for Intl object

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 566 matching lines @@
                                          configurable: false,
                                          writable: false,
                                          enumerable: true});
     }
   }
 
   %object_define_property(array, 'length', {value: l, writable: false});
   return array;
 }
 
+/* Make JS array[] out of InternalArray */
+function makeArray(input) {
+  var array = [];
+  %MoveArrayContents(input, array);
+  return array;
+}
+
 
 /**
  * It's sometimes desireable to leave user requested locale instead of ICU
  * supported one (zh-TW is equivalent to zh-Hant-TW, so we should keep shorter
  * one, if that was what user requested).
  * This function returns user specified tag if its maximized form matches ICU
  * resolved locale. If not we return ICU result.
  */
 function getOptimalLanguageTag(original, resolved) {
   // Returns Array<Object>, where each object has maximized and base properties.
@@ skipping 114 matching lines @@
           ((lowercasedPart !== 'es' &&
             lowercasedPart !== 'of' && lowercasedPart !== 'au') ?
           toTitleCaseWord(part) : lowercasedPart);
     }
   }
   return result;
 }
 
 /**
  * Canonicalizes the language tag, or throws in case the tag is invalid.
+ * ECMA 402 9.2.1 steps 7.c ii ~ v.
  */
 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 %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) {
+  if (isStructuallyValidLanguageTag(localeString) === false) {
     throw %make_range_error(kInvalidLanguageTag, localeString);
   }
 
+  // ECMA 402 6.2.3
   var tag = %CanonicalizeLanguageTag(localeString);
+  // TODO(jshin): This should not happen because the structual validity
+  // is already checked. If that's the case, remove this.
   if (tag === 'invalid-tag') {
     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.
+ * ECMA 402 8.2.1 steps 1 (ECMA 402 9.2.1) and 2.
  */
-function initializeLocaleList(locales) {
+function canonicalizeLocaleList(locales) {
   var seen = new InternalArray();
   if (!IS_UNDEFINED(locales)) {
     // We allow single string localeID.
     if (typeof locales === 'string') {
       %_Call(ArrayPush, seen, canonicalizeLanguageTag(locales));
-      return freezeArray(seen);
+      return makeArray(seen);
     }
 
     var o = TO_OBJECT(locales);
-    var len = TO_UINT32(o.length);
+    var len = TO_LENGTH(o.length);
 
     for (var k = 0; k < len; k++) {
       if (k in o) {
         var value = o[k];
 
         var tag = canonicalizeLanguageTag(value);
 
         if (%_Call(ArrayIndexOf, seen, tag) === -1) {
           %_Call(ArrayPush, seen, tag);
         }
       }
     }
   }
 
-  return freezeArray(seen);
+  return makeArray(seen);
 }
 
+function initializeLocaleList(locales) {
+  return freezeArray(canonicalizeLocaleList(locales));

[Dan Ehrenberg, 2016/08/12 18:59:19]

This seems to make an extra copy of the array, which is slower but probably OK
as these functions are not performance-sensitive.

+}
 
 /**
- * Validates the language tag. Section 2.2.9 of the bcp47 spec
- * defines a valid tag.
+ * Check the structual Validity of the language tag per ECMA 402 6.2.2:
+ *   - Well-formed per RFC 5646 2.1
+ *   - There are no duplicate variant subtags
+ *   - There are no duplicate singletion (extension) subtags
+ *
+ * One extra-check is done (from RFC 5646 2.2.9): the tag is compared
+ * against the list of grandfathered tags. However, subtags for
+ * primary/extended language, script, region, variant are not checked
+ * against the IANA language subtag registry.
  *
  * ICU is too permissible and lets invalid tags, like
  * hant-cmn-cn, through.
  *
  * Returns false if the language tag is invalid.
  */
-function isValidLanguageTag(locale) {
+function isStructuallyValidLanguageTag(locale) {
   // Check if it's well-formed, including grandfadered tags.
   if (IS_NULL(InternalRegExpMatch(GetLanguageTagRE(), locale))) {
     return false;
   }
 
   // Just return if it's a x- form. It's all private.
   if (%_Call(StringIndexOf, locale, 'x-') === 0) {
     return true;
   }
 
@@ skipping 74 matching lines @@
 var resolvedAccessor = {
   get() {
     %IncrementUseCounter(kIntlResolved);
     return this[resolvedSymbol];
   },
   set(value) {
     this[resolvedSymbol] = value;
   }
 };
 
+// ECMA 402 section 8.2.1
+InstallFunction(Intl, 'getCanonicalLocales', function(locales) {
+    if (!IS_UNDEFINED(new.target)) {
+      throw %make_type_error(kOrdinaryFunctionCalledAsConstructor);
+    }
+
+    return 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");
   }
 
   if (IS_UNDEFINED(options)) {
@@ skipping 1348 matching lines @@
   }
 );
 
 utils.Export(function(to) {
   to.AddBoundMethod = AddBoundMethod;
   to.IntlParseDate = IntlParseDate;
   to.IntlParseNumber = IntlParseNumber;
 });
 
 })