[bootstrapper] Remove Intl experimental natives files

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 217 matching lines @@
   bool InstallNatives(GlobalContextType context_type);
 
   void InstallTypedArray(const char* name, ElementsKind elements_kind,
                          Handle<JSFunction>* fun);
   bool InstallExperimentalNatives();
   bool InstallExtraNatives();
   bool InstallExperimentalExtraNatives();
   bool InstallDebuggerNatives();
   void InstallBuiltinFunctionIds();
   void InstallExperimentalBuiltinFunctionIds();
+  void InstallExperimentalExports();
   void InitializeNormalizedMapCaches();
 
   enum ExtensionTraversalState {
     UNVISITED, VISITED, INSTALLED
   };
 
   class ExtensionStates {
    public:
     ExtensionStates();
     ExtensionTraversalState get_state(RegisteredExtension* extension);
@@ skipping 278 matching lines @@
 
 void InstallSpeciesGetter(Handle<JSFunction> constructor) {
   Factory* factory = constructor->GetIsolate()->factory();
   // TODO(adamk): We should be able to share a SharedFunctionInfo
   // between all these JSFunctins.
   SimpleInstallGetter(constructor, factory->symbol_species_string(),
                       factory->species_symbol(), Builtins::kReturnReceiver,
                       true);
 }
 
+void SetFunction(Handle<JSObject> target, Handle<JSFunction> function,
+                 Handle<Name> name, PropertyAttributes attributes = DONT_ENUM) {
+  JSObject::SetOwnPropertyIgnoreAttributes(target, name, function, attributes)
+      .ToHandleChecked();
+}
+
 }  // namespace
 
 Handle<JSFunction> Genesis::CreateEmptyFunction(Isolate* isolate) {
   // Allocate the map for function instances. Maps are allocated first and their
   // prototypes patched later, once empty function is created.
 
   // Functions with this map will not have a 'prototype' property, and
   // can not be used as constructors.
   Handle<Map> function_without_prototype_map =
       factory()->CreateSloppyFunctionMap(FUNCTION_WITHOUT_PROTOTYPE);
@@ skipping 2948 matching lines @@
       }
 
       Accessors::FunctionSetPrototype(callsite_fun, proto).Assert();
     }
   }
 }
 
 
 void Bootstrapper::ExportExperimentalFromRuntime(Isolate* isolate,
                                                  Handle<JSObject> container) {
-  HandleScope scope(isolate);
-
-#ifdef V8_I18N_SUPPORT
-#define INITIALIZE_FLAG(FLAG)                                         \
-  {                                                                   \
-    Handle<String> name =                                             \
-        isolate->factory()->NewStringFromAsciiChecked(#FLAG);         \
-    JSObject::AddProperty(container, name,                            \
-                          isolate->factory()->ToBoolean(FLAG), NONE); \
-  }
-
-#undef INITIALIZE_FLAG
-#endif
+  isolate->native_context()->set_experimental_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)
 EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_regexp_property)
@@ skipping 98 matching lines @@
   Handle<JSFunction> type##_function = InstallFunction(                   \
       simd_object, #Type, JS_VALUE_TYPE, JSValue::kSize,                  \
       isolate->initial_object_prototype(), Builtins::kIllegal);           \
   native_context()->set_##type##_function(*type##_function);              \
   type##_function->shared()->set_instance_class_name(*factory->Type##_string());
   SIMD128_TYPES(SIMD128_INSTALL_FUNCTION)
 #undef SIMD128_INSTALL_FUNCTION
 }
 
 
 void Genesis::InitializeGlobal_harmony_array_prototype_values() {

[Yang, 2017/02/13 14:51:16]

could we install the experimental functions like this?

[Dan Ehrenberg, 2017/02/13 20:05:42]

Done.

   if (!FLAG_harmony_array_prototype_values) return;
   Handle<JSFunction> array_constructor(native_context()->array_function());
   Handle<JSObject> array_prototype(
       JSObject::cast(array_constructor->instance_prototype()));
   Handle<Object> values_iterator =
       JSObject::GetProperty(array_prototype, factory()->iterator_symbol())
           .ToHandleChecked();
   DCHECK(values_iterator->IsJSFunction());
   JSObject::AddProperty(array_prototype, factory()->values_string(),
                         values_iterator, DONT_ENUM);
@@ skipping 463 matching lines @@
       "native harmony-atomics.js", NULL};
   static const char* harmony_simd_natives[] = {"native harmony-simd.js",
                                                nullptr};
   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[] = {"native icu-case-mapping.js",
-                                                   nullptr};
-  static const char* datetime_format_to_parts_natives[] = {
-      "native datetime-format-to-parts.js", nullptr};
+  static const char* icu_case_mapping_natives[] = {nullptr};
+  static const char* datetime_format_to_parts_natives[] = {nullptr};
 #endif
   static const char* harmony_restrictive_generators_natives[] = {nullptr};
   static const char* harmony_trailing_commas_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};
 
   for (int i = ExperimentalNatives::GetDebuggerCount();
        i < ExperimentalNatives::GetBuiltinsCount(); i++) {
@@ skipping 11 matching lines @@
   }
     HARMONY_INPROGRESS(INSTALL_EXPERIMENTAL_NATIVES);
     HARMONY_STAGED(INSTALL_EXPERIMENTAL_NATIVES);
     HARMONY_SHIPPING(INSTALL_EXPERIMENTAL_NATIVES);
 #undef INSTALL_EXPERIMENTAL_NATIVES
   }
 
   if (!CallUtilsFunction(isolate(), "PostExperimentals")) return false;
 
   InstallExperimentalBuiltinFunctionIds();
+  InstallExperimentalExports();
   return true;
 }
 
 
 bool Genesis::InstallExtraNatives() {
   HandleScope scope(isolate());
 
   Handle<JSObject> extras_binding =
       factory()->NewJSObject(isolate()->object_function());
   native_context()->set_extras_binding_object(*extras_binding);
@@ skipping 73 matching lines @@
         ATOMIC_FUNCTIONS_WITH_ID_LIST(INSTALL_BUILTIN_ID)};
 
     for (const BuiltinFunctionIds& builtin : atomic_builtins) {
       Handle<JSObject> holder =
           ResolveBuiltinIdHolder(native_context(), builtin.holder_expr);
       InstallBuiltinFunctionId(holder, builtin.fun_name, builtin.id);
     }
   }
 }
 
+void Genesis::InstallExperimentalExports() {
+  HandleScope scope(isolate());
+
+  Handle<JSObject> experimental_container(
+      native_context()->experimental_container());
+
+#if V8_I18N_SUPPORT
+  if (FLAG_icu_case_mapping) {
+    Handle<JSObject> string_prototype(
+        JSObject::cast(native_context()->string_function()->prototype()));
+
+    Handle<JSFunction> to_lower_case = Handle<JSFunction>::cast(
+        JSReceiver::GetProperty(
+            experimental_container,
+            factory()->InternalizeUtf8String("ToLowerCaseI18N"))
+            .ToHandleChecked());
+    SetFunction(string_prototype, to_lower_case,
+                factory()->InternalizeUtf8String("toLowerCase"));
+
+    Handle<JSFunction> to_upper_case = Handle<JSFunction>::cast(
+        JSReceiver::GetProperty(
+            experimental_container,
+            factory()->InternalizeUtf8String("ToUpperCaseI18N"))
+            .ToHandleChecked());
+    SetFunction(string_prototype, to_upper_case,
+                factory()->InternalizeUtf8String("toUpperCase"));
+
+    Handle<JSFunction> to_locale_lower_case = Handle<JSFunction>::cast(
+        JSReceiver::GetProperty(
+            experimental_container,
+            factory()->InternalizeUtf8String("ToLocaleLowerCaseI18N"))
+            .ToHandleChecked());
+    SetFunction(string_prototype, to_locale_lower_case,
+                factory()->InternalizeUtf8String("toLocaleLowerCase"));
+
+    Handle<JSFunction> to_locale_upper_case = Handle<JSFunction>::cast(
+        JSReceiver::GetProperty(
+            experimental_container,
+            factory()->InternalizeUtf8String("ToLocaleUpperCaseI18N"))
+            .ToHandleChecked());
+    SetFunction(string_prototype, to_locale_upper_case,
+                factory()->InternalizeUtf8String("toLocaleUpperCase"));
+  }
+
+  if (FLAG_datetime_format_to_parts) {
+    Handle<JSObject> date_time_format_prototype(JSObject::cast(
+        native_context()->intl_date_time_format_function()->prototype()));
+    Handle<JSFunction> format_date_to_parts = Handle<JSFunction>::cast(
+        JSReceiver::GetProperty(
+            experimental_container,
+            factory()->InternalizeUtf8String("FormatDateToParts"))
+            .ToHandleChecked());
+    InstallFunction(date_time_format_prototype, format_date_to_parts,
+                    factory()->InternalizeUtf8String("formatToParts"));
+  }
+#endif  // V8_I18N_SUPPORT
+}
 
 #undef INSTALL_BUILTIN_ID
 
 
 void Genesis::InitializeNormalizedMapCaches() {
   Handle<NormalizedMapCache> cache = NormalizedMapCache::New(isolate());
   native_context()->set_normalized_map_cache(*cache);
 }
 
 
@@ skipping 618 matching lines @@
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   DCHECK(!IsActive());
 }
 
 }  // namespace internal
 }  // namespace v8