[intl] Implement Intl.PluralRules

src/bootstrapper.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.
 
 #include "src/bootstrapper.h"
 
 #include "src/accessors.h"
 #include "src/api-natives.h"
 #include "src/base/ieee754.h"
 #include "src/code-stubs.h"
@@ skipping 3611 matching lines @@
           static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
 
       Handle<JSFunction> fun;
       for (const FunctionInfo& info : infos) {
         SimpleInstallFunction(proto, info.name, info.id, 0, true, attrs);
       }
 
       Accessors::FunctionSetPrototype(callsite_fun, proto).Assert();
     }
   }
+
+  {  // I n t l  P l u r a l R u l e s
+    Handle<JSObject> plural_rules_prototype =
+        factory->NewJSObject(isolate->object_function(), TENURED);
+    // Install the @@toStringTag property on the {prototype}.
+    JSObject::AddProperty(
+        plural_rules_prototype, factory->to_string_tag_symbol(),
+        factory->Object_string(),
+        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
+    Handle<JSFunction> plural_rules_constructor = InstallFunction(
+        container, "PluralRules", JS_OBJECT_TYPE, PluralRules::kSize,
+        plural_rules_prototype, Builtins::kIllegal);
+    JSObject::AddProperty(plural_rules_prototype, factory->constructor_string(),
+                          plural_rules_constructor, DONT_ENUM);
+    InstallWithIntrinsicDefaultProto(isolate, plural_rules_constructor,
+                                     Context::INTL_PLURAL_RULES_FUNCTION_INDEX);
+  }
+
   isolate->native_context()->set_exports_container(*container);
 }
 
 
 #define EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(id) \
   void Genesis::InitializeGlobal_##id() {}
 
 EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_do_expressions)
 EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_regexp_lookbehind)
 EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_regexp_named_captures)
@@ skipping 224 matching lines @@
               factory()->InternalizeUtf8String("toLocaleLowerCase"));
 
   Handle<JSFunction> to_locale_upper_case = Handle<JSFunction>::cast(
       JSReceiver::GetProperty(
           exports_container,
           factory()->InternalizeUtf8String("ToLocaleUpperCaseI18N"))
           .ToHandleChecked());
   SetFunction(string_prototype, to_locale_upper_case,
               factory()->InternalizeUtf8String("toLocaleUpperCase"));
 }
+
+void Genesis::InitializeGlobal_harmony_plural_rules() {
+  if (!FLAG_harmony_plural_rules) return;
+
+  Handle<JSReceiver> exports_container(
+      JSReceiver::cast(native_context()->exports_container()));
+  Handle<JSFunction> plural_rules(
+      native_context()->intl_plural_rules_function());
+  Handle<JSObject> intl = Handle<JSObject>::cast(
+      JSReceiver::GetProperty(
+          Handle<JSReceiver>(native_context()->global_object()),
+          factory()->InternalizeUtf8String("Intl"))
+          .ToHandleChecked());
+  JSObject::AddProperty(intl, factory()->InternalizeUtf8String("PluralRules"),
+                        plural_rules, DONT_ENUM);
+}
 #endif
 
 Handle<JSFunction> Genesis::InstallArrayBuffer(Handle<JSObject> target,
                                                const char* name,
                                                Builtins::Name call,
                                                BuiltinFunctionId id,
                                                bool is_shared) {
   // Create the %ArrayBufferPrototype%
   // Setup the {prototype} with the given {name} for @@toStringTag.
   Handle<JSObject> prototype =
@@ skipping 446 matching lines @@
       "native harmony-atomics.js", NULL};
   static const char* harmony_do_expressions_natives[] = {nullptr};
   static const char* harmony_regexp_lookbehind_natives[] = {nullptr};
   static const char* harmony_regexp_named_captures_natives[] = {nullptr};
   static const char* harmony_regexp_property_natives[] = {nullptr};
   static const char* harmony_function_sent_natives[] = {nullptr};
   static const char* harmony_array_prototype_values_natives[] = {nullptr};
 #ifdef V8_I18N_SUPPORT
   static const char* icu_case_mapping_natives[] = {nullptr};
   static const char* datetime_format_to_parts_natives[] = {nullptr};
+  static const char* harmony_plural_rules_natives[] = {nullptr};
 #endif
   static const char* harmony_restrictive_generators_natives[] = {nullptr};
   static const char* harmony_trailing_commas_natives[] = {nullptr};
   static const char* harmony_function_tostring_natives[] = {nullptr};
   static const char* harmony_class_fields_natives[] = {nullptr};
   static const char* harmony_object_rest_spread_natives[] = {nullptr};
   static const char* harmony_async_iteration_natives[] = {nullptr};
   static const char* harmony_dynamic_import_natives[] = {nullptr};
   static const char* harmony_promise_finally_natives[] = {nullptr};
   static const char* harmony_template_escapes_natives[] = {nullptr};
@@ skipping 755 matching lines @@
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   DCHECK(!IsActive());
 }
 
 }  // namespace internal
 }  // namespace v8