[intl] Implement Intl.PluralRules

src/runtime/runtime-i18n.cc

 // Copyright 2014 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.
 
 
 #ifdef V8_I18N_SUPPORT
 #include "src/runtime/runtime-utils.h"
 
 #include <memory>
 
@@ skipping 15 matching lines @@
 #include "unicode/dcfmtsym.h"
 #include "unicode/decimfmt.h"
 #include "unicode/dtfmtsym.h"
 #include "unicode/dtptngen.h"
 #include "unicode/fieldpos.h"
 #include "unicode/fpositer.h"
 #include "unicode/locid.h"
 #include "unicode/normalizer2.h"
 #include "unicode/numfmt.h"
 #include "unicode/numsys.h"
+#include "unicode/plurrule.h"
 #include "unicode/rbbi.h"
 #include "unicode/smpdtfmt.h"
 #include "unicode/timezone.h"
 #include "unicode/translit.h"
 #include "unicode/uchar.h"
 #include "unicode/ucol.h"
 #include "unicode/ucurr.h"
 #include "unicode/uloc.h"
 #include "unicode/unistr.h"
 #include "unicode/unum.h"
@@ skipping 70 matching lines @@
   int32_t count = 0;
 
   if (service->IsUtf8EqualTo(CStrVector("collator"))) {
     available_locales = icu::Collator::getAvailableLocales(count);
   } else if (service->IsUtf8EqualTo(CStrVector("numberformat"))) {
     available_locales = icu::NumberFormat::getAvailableLocales(count);
   } else if (service->IsUtf8EqualTo(CStrVector("dateformat"))) {
     available_locales = icu::DateFormat::getAvailableLocales(count);
   } else if (service->IsUtf8EqualTo(CStrVector("breakiterator"))) {
     available_locales = icu::BreakIterator::getAvailableLocales(count);
+  } else if (service->IsUtf8EqualTo(CStrVector("pluralrules"))) {
+    // TODO(littledan): For PluralRules, filter out locales that
+    // don't support PluralRules.
+    // PluralRules is missing an appropriate getAvailableLocales method,
+    // so we should filter from all locales, but it's not clear how; see
+    // https://ssl.icu-project.org/trac/ticket/12756
+    available_locales = icu::Locale::getAvailableLocales(count);
+  } else {
+    UNREACHABLE();
   }
 
   UErrorCode error = U_ZERO_ERROR;
   char result[ULOC_FULLNAME_CAPACITY];
   Handle<JSObject> locales = factory->NewJSObject(isolate->object_function());
 
   for (int32_t i = 0; i < count; ++i) {
     const char* icu_name = available_locales[i].getName();
 
     error = U_ZERO_ERROR;
@@ skipping 495 matching lines @@
     const UChar* string_val1 = GetUCharBufferFromFlat(flat1, &sap1, length1);
     const UChar* string_val2 = GetUCharBufferFromFlat(flat2, &sap2, length2);
     result =
         collator->compare(string_val1, length1, string_val2, length2, status);
   }
   if (U_FAILURE(status)) return isolate->ThrowIllegalOperation();
 
   return *isolate->factory()->NewNumberFromInt(result);
 }
 
+RUNTIME_FUNCTION(Runtime_CreatePluralRules) {
+  HandleScope scope(isolate);
+
+  DCHECK_EQ(3, args.length());
+
+  CONVERT_ARG_HANDLE_CHECKED(String, locale, 0);
+  CONVERT_ARG_HANDLE_CHECKED(JSObject, options, 1);
+  CONVERT_ARG_HANDLE_CHECKED(JSObject, resolved, 2);
+
+  Handle<JSFunction> constructor(
+      isolate->native_context()->intl_plural_rules_function());
+
+  Handle<JSObject> local_object;
+  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, local_object,
+                                     JSObject::New(constructor, constructor));
+
+  // Set pluralRules as internal field of the resulting JS object.
+  icu::PluralRules* plural_rules;
+  icu::DecimalFormat* decimal_format;
+  bool success = PluralRules::InitializePluralRules(
+      isolate, locale, options, resolved, &plural_rules, &decimal_format);
+
+  if (!success) return isolate->ThrowIllegalOperation();
+
+  local_object->SetInternalField(0, reinterpret_cast<Smi*>(plural_rules));
+  local_object->SetInternalField(1, reinterpret_cast<Smi*>(decimal_format));
+
+  Handle<Object> wrapper = isolate->global_handles()->Create(*local_object);
+  GlobalHandles::MakeWeak(wrapper.location(), wrapper.location(),
+                          PluralRules::DeletePluralRules,
+                          WeakCallbackType::kInternalFields);
+  return *local_object;
+}
+
+RUNTIME_FUNCTION(Runtime_PluralRulesSelect) {
+  HandleScope scope(isolate);
+
+  DCHECK_EQ(2, args.length());
+
+  CONVERT_ARG_HANDLE_CHECKED(JSObject, plural_rules_holder, 0);
+  CONVERT_ARG_HANDLE_CHECKED(Object, number, 1);
+
+  icu::PluralRules* plural_rules =
+      PluralRules::UnpackPluralRules(isolate, plural_rules_holder);
+  CHECK_NOT_NULL(plural_rules);
+
+  icu::DecimalFormat* number_format =
+      PluralRules::UnpackNumberFormat(isolate, plural_rules_holder);
+  CHECK_NOT_NULL(number_format);
+
+  // Currently, PluralRules doesn't implement all the options for rounding that
+  // the Intl spec provides; format and parse the number to round to the
+  // appropriate amount, then apply PluralRules.
+  //
+  // TODO(littledan): If a future ICU version supports an extended API to avoid
+  // this step, then switch to that API. Bug thread:
+  // http://bugs.icu-project.org/trac/ticket/12763

[jungshik at Google, 2017/05/08 19:16:54]

Fixed in ICU 59.1. Either wait for me to update Chrome/V8's ICU to 59.1 (will
happen before long) or land first and fix it later. 

[Dan Ehrenberg, 2017/07/14 08:31:50]

Looks like that API is C-only. I posted a comment on that bug asking for a C++
API; until then, do you think there are any problems from continuing with the
current approach?

+  icu::UnicodeString rounded_string;
+  number_format->format(number->Number(), rounded_string);
+
+  icu::Formattable formattable;
+  UErrorCode status = U_ZERO_ERROR;
+  number_format->parse(rounded_string, formattable, status);
+  if (!U_SUCCESS(status)) return isolate->ThrowIllegalOperation();

[jungshik at Google, 2017/05/08 19:16:54]

again, check at line 717 would suffice. If you want to know where it fails, you
can add DCHECK here.  And can even use u_errorName() to log a human-readable
error description along with DCHECK. (include 'unicode/utypes.h' for
u_errorName() ). 

+
+  double rounded = formattable.getDouble(status);
+  if (!U_SUCCESS(status)) return isolate->ThrowIllegalOperation();
+
+  icu::UnicodeString result = plural_rules->select(rounded);
+  return *isolate->factory()
+              ->NewStringFromTwoByte(Vector<const uint16_t>(
+                  reinterpret_cast<const uint16_t*>(result.getBuffer()),
+                  result.length()))
+              .ToHandleChecked();
+}
 
 RUNTIME_FUNCTION(Runtime_StringNormalize) {
   HandleScope scope(isolate);
   static const struct {
     const char* name;
     UNormalization2Mode mode;
   } normalizationForms[] = {
       {"nfc", UNORM2_COMPOSE},
       {"nfc", UNORM2_DECOMPOSE},
       {"nfkc", UNORM2_COMPOSE},
@@ skipping 548 matching lines @@
   Handle<FixedArray> date_cache_version =
       Handle<FixedArray>::cast(isolate->eternal_handles()->GetSingleton(
           EternalHandles::DATE_CACHE_VERSION));
   return date_cache_version->get(0);
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_I18N_SUPPORT