[Intl] Add quarter, dayPeriod and fractionalSecondDigits options

quarter option- see https://github.com/tc39/ecma402/pull/345
dayPeriod option- see https://github.com/tc39/ecma402/pull/346
fractionalSecondDigits option- see https://github.com/tc39/ecma402/pull/347
2019-6-5 TC39 presentation- http://shorturl.at/mtB12
test262: https://github.com/tc39/test262/pull/2194
I2I: http://shorturl.at/beCNV (for quarter)
I2I: http://shorturl.at/bekrZ (for dayPeriod)
I2I: http://shorturl.at/flwF5 (for fractionalSecondDigits)

Bug: v8:9282,v8:9283,v8:9284

Change-Id: I99f4c0f861507c7451497b735a276780bb8aead6
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1621445
Commit-Queue: Frank Tang <ftang@chromium.org>
Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
Cr-Commit-Position: refs/heads/master@{#62041}

src/flags/flag-definitions.h

@@ -209,7 +209,13 @@ DEFINE_IMPLICATION(harmony_import_meta, harmony_dynamic_import)
   V(harmony_weak_refs, "harmony weak references")
 
 #ifdef V8_INTL_SUPPORT
-#define HARMONY_INPROGRESS(V) HARMONY_INPROGRESS_BASE(V)
+#define HARMONY_INPROGRESS(V)                              \
+  HARMONY_INPROGRESS_BASE(V)                               \
+  V(harmony_intl_dateformat_day_period,                    \
+    "Add dayPeriod option to DateTimeFormat")              \
+  V(harmony_intl_dateformat_fractional_second_digits,      \
+    "Add fractionalSecondDigits option to DateTimeFormat") \
+  V(harmony_intl_dateformat_quarter, "Add quarter option to DateTimeFormat")
 #else
 #define HARMONY_INPROGRESS(V) HARMONY_INPROGRESS_BASE(V)
 #endif

src/init/bootstrapper.cc

@@ -4236,6 +4236,10 @@ EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_hashbang)
 #ifdef V8_INTL_SUPPORT
 EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_intl_add_calendar_numbering_system)
 EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_intl_bigint)
+EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_intl_dateformat_day_period)
+EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(
+    harmony_intl_dateformat_fractional_second_digits)
+EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_intl_dateformat_quarter)
 EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_intl_datetime_style)
 EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_intl_numberformat_unified)
 #endif  // V8_INTL_SUPPORT

src/init/heap-symbols.h

@@ -31,11 +31,13 @@
   V(_, era_string, "era")                                           \
   V(_, first_string, "first")                                       \
   V(_, format_string, "format")                                     \
+  V(_, fractionalSecond_string, "fractionalSecond")                 \
   V(_, except_zero_string, "except-zero")                           \
   V(_, exponentInteger_string, "exponentInteger")                   \
   V(_, exponentMinusSign_string, "exponentMinusSign")               \
   V(_, exponentSeparator_string, "exponentSeparator")               \
   V(_, fraction_string, "fraction")                                 \
+  V(_, fractionalSecondDigits_string, "fractionalSecondDigits")     \
   V(_, full_string, "full")                                         \
   V(_, granularity_string, "granularity")                           \
   V(_, grapheme_string, "grapheme")                                 \

src/objects/intl-objects.cc

@@ -1117,10 +1117,12 @@ Maybe<int> DefaultNumberOption(Isolate* isolate, Handle<Object> value, int min,
   return Just(FastD2I(floor(value_num->Number())));
 }
 
+}  // namespace
+
 // ecma402/#sec-getnumberoption
-Maybe<int> GetNumberOption(Isolate* isolate, Handle<JSReceiver> options,
-                           Handle<String> property, int min, int max,
-                           int fallback) {
+Maybe<int> Intl::GetNumberOption(Isolate* isolate, Handle<JSReceiver> options,
+                                 Handle<String> property, int min, int max,
+                                 int fallback) {
   // 1. Let value be ? Get(options, property).
   Handle<Object> value;
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
@@ -1131,25 +1133,17 @@ Maybe<int> GetNumberOption(Isolate* isolate, Handle<JSReceiver> options,
   return DefaultNumberOption(isolate, value, min, max, fallback, property);
 }
 
-Maybe<int> GetNumberOption(Isolate* isolate, Handle<JSReceiver> options,
-                           const char* property, int min, int max,
-                           int fallback) {
-  Handle<String> property_str =
-      isolate->factory()->NewStringFromAsciiChecked(property);
-  return GetNumberOption(isolate, options, property_str, min, max, fallback);
-}
-
-}  // namespace
-
 Maybe<Intl::NumberFormatDigitOptions> Intl::SetNumberFormatDigitOptions(
     Isolate* isolate, Handle<JSReceiver> options, int mnfd_default,
     int mxfd_default) {
+  Factory* factory = isolate->factory();
   Intl::NumberFormatDigitOptions digit_options;
 
   // 5. Let mnid be ? GetNumberOption(options, "minimumIntegerDigits,", 1, 21,
   // 1).
   int mnid;
-  if (!GetNumberOption(isolate, options, "minimumIntegerDigits", 1, 21, 1)
+  if (!Intl::GetNumberOption(isolate, options,
+                             factory->minimumIntegerDigits_string(), 1, 21, 1)
            .To(&mnid)) {
     return Nothing<NumberFormatDigitOptions>();
   }
@@ -1157,8 +1151,9 @@ Maybe<Intl::NumberFormatDigitOptions> Intl::SetNumberFormatDigitOptions(
   // 6. Let mnfd be ? GetNumberOption(options, "minimumFractionDigits", 0, 20,
   // mnfdDefault).
   int mnfd;
-  if (!GetNumberOption(isolate, options, "minimumFractionDigits", 0, 20,
-                       mnfd_default)
+  if (!Intl::GetNumberOption(isolate, options,
+                             factory->minimumFractionDigits_string(), 0, 20,
+                             mnfd_default)
            .To(&mnfd)) {
     return Nothing<NumberFormatDigitOptions>();
   }
@@ -1169,24 +1164,23 @@ Maybe<Intl::NumberFormatDigitOptions> Intl::SetNumberFormatDigitOptions(
   // 8. Let mxfd be ? GetNumberOption(options,
   // "maximumFractionDigits", mnfd, 20, mxfdActualDefault).
   int mxfd;
-  if (!GetNumberOption(isolate, options, "maximumFractionDigits", mnfd, 20,
-                       mxfd_actual_default)
+  if (!Intl::GetNumberOption(isolate, options,
+                             factory->maximumFractionDigits_string(), mnfd, 20,
+                             mxfd_actual_default)
            .To(&mxfd)) {
     return Nothing<NumberFormatDigitOptions>();
   }
 
   // 9.  Let mnsd be ? Get(options, "minimumSignificantDigits").
   Handle<Object> mnsd_obj;
-  Handle<String> mnsd_str =
-      isolate->factory()->minimumSignificantDigits_string();
+  Handle<String> mnsd_str = factory->minimumSignificantDigits_string();
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, mnsd_obj, JSReceiver::GetProperty(isolate, options, mnsd_str),
       Nothing<NumberFormatDigitOptions>());
 
   // 10. Let mxsd be ? Get(options, "maximumSignificantDigits").
   Handle<Object> mxsd_obj;
-  Handle<String> mxsd_str =
-      isolate->factory()->maximumSignificantDigits_string();
+  Handle<String> mxsd_str = factory->maximumSignificantDigits_string();
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, mxsd_obj, JSReceiver::GetProperty(isolate, options, mxsd_str),
       Nothing<NumberFormatDigitOptions>());

src/objects/intl-objects.h

@@ -126,6 +126,10 @@ class Intl {
       Isolate* isolate, Handle<JSReceiver> options, const char* property,
       const char* service, bool* result);
 
+  V8_EXPORT_PRIVATE V8_WARN_UNUSED_RESULT static Maybe<int> GetNumberOption(
+      Isolate* isolate, Handle<JSReceiver> options, Handle<String> property,
+      int min, int max, int fallback);
+
   // Canonicalize the locale.
   // https://tc39.github.io/ecma402/#sec-canonicalizelanguagetag,
   // including type check and structural validity check.

src/objects/js-date-time-format.cc

@@ -56,13 +56,13 @@ class PatternItem {
   std::vector<const char*> allowed_values;
 };
 
-static const std::vector<PatternItem> BuildPatternItems() {
+static std::vector<PatternItem> BuildPatternItems() {
   const std::vector<const char*> kLongShort = {"long", "short"};
   const std::vector<const char*> kNarrowLongShort = {"narrow", "long", "short"};
   const std::vector<const char*> k2DigitNumeric = {"2-digit", "numeric"};
   const std::vector<const char*> kNarrowLongShort2DigitNumeric = {
       "narrow", "long", "short", "2-digit", "numeric"};
-  const std::vector<PatternItem> kPatternItems = {
+  std::vector<PatternItem> items = {
       PatternItem("weekday",
                   {{"EEEEE", "narrow"},
                    {"EEEE", "long"},
@@ -75,38 +75,59 @@ static const std::vector<PatternItem> BuildPatternItems() {
                   {{"GGGGG", "narrow"}, {"GGGG", "long"}, {"GGG", "short"}},
                   kNarrowLongShort),
       PatternItem("year", {{"yy", "2-digit"}, {"y", "numeric"}},
-                  k2DigitNumeric),
-      // Sometimes we get L instead of M for month - standalone name.
-      PatternItem("month",
-                  {{"MMMMM", "narrow"},
-                   {"MMMM", "long"},
-                   {"MMM", "short"},
-                   {"MM", "2-digit"},
-                   {"M", "numeric"},
-                   {"LLLLL", "narrow"},
-                   {"LLLL", "long"},
-                   {"LLL", "short"},
-                   {"LL", "2-digit"},
-                   {"L", "numeric"}},
-                  kNarrowLongShort2DigitNumeric),
-      PatternItem("day", {{"dd", "2-digit"}, {"d", "numeric"}}, k2DigitNumeric),
-      PatternItem("hour",
-                  {{"HH", "2-digit"},
-                   {"H", "numeric"},
-                   {"hh", "2-digit"},
-                   {"h", "numeric"},
-                   {"kk", "2-digit"},
-                   {"k", "numeric"},
-                   {"KK", "2-digit"},
-                   {"K", "numeric"}},
-                  k2DigitNumeric),
-      PatternItem("minute", {{"mm", "2-digit"}, {"m", "numeric"}},
-                  k2DigitNumeric),
-      PatternItem("second", {{"ss", "2-digit"}, {"s", "numeric"}},
-                  k2DigitNumeric),
-      PatternItem("timeZoneName", {{"zzzz", "long"}, {"z", "short"}},
-                  kLongShort)};
-  return kPatternItems;
+                  k2DigitNumeric)};
+  if (FLAG_harmony_intl_dateformat_quarter) {
+    items.push_back(PatternItem("quarter",
+                                {{"QQQQQ", "narrow"},
+                                 {"QQQQ", "long"},
+                                 {"QQQ", "short"},
+                                 {"qqqqq", "narrow"},
+                                 {"qqqq", "long"},
+                                 {"qqq", "short"}},
+                                kNarrowLongShort));
+  }
+  // Sometimes we get L instead of M for month - standalone name.
+  items.push_back(PatternItem("month",
+                              {{"MMMMM", "narrow"},
+                               {"MMMM", "long"},
+                               {"MMM", "short"},
+                               {"MM", "2-digit"},
+                               {"M", "numeric"},
+                               {"LLLLL", "narrow"},
+                               {"LLLL", "long"},
+                               {"LLL", "short"},
+                               {"LL", "2-digit"},
+                               {"L", "numeric"}},
+                              kNarrowLongShort2DigitNumeric));
+  items.push_back(PatternItem("day", {{"dd", "2-digit"}, {"d", "numeric"}},
+                              k2DigitNumeric));
+  if (FLAG_harmony_intl_dateformat_day_period) {
+    items.push_back(PatternItem("dayPeriod",
+                                {{"BBBBB", "narrow"},
+                                 {"bbbbb", "narrow"},
+                                 {"BBBB", "long"},
+                                 {"bbbb", "long"},
+                                 {"B", "short"},
+                                 {"b", "short"}},
+                                kNarrowLongShort));
+  }
+  items.push_back(PatternItem("hour",
+                              {{"HH", "2-digit"},
+                               {"H", "numeric"},
+                               {"hh", "2-digit"},
+                               {"h", "numeric"},
+                               {"kk", "2-digit"},
+                               {"k", "numeric"},
+                               {"KK", "2-digit"},
+                               {"K", "numeric"}},
+                              k2DigitNumeric));
+  items.push_back(PatternItem("minute", {{"mm", "2-digit"}, {"m", "numeric"}},
+                              k2DigitNumeric));
+  items.push_back(PatternItem("second", {{"ss", "2-digit"}, {"s", "numeric"}},
+                              k2DigitNumeric));
+  items.push_back(PatternItem("timeZoneName",
+                              {{"zzzz", "long"}, {"z", "short"}}, kLongShort));
+  return items;
 }
 
 class PatternItems {
@@ -348,6 +369,16 @@ Handle<String> DateTimeStyleAsString(Isolate* isolate,
   }
 }
 
+int FractionalSecondDigitsFromPattern(const std::string& pattern) {
+  int result = 0;
+  for (size_t i = 0; i < pattern.length() && result < 3; i++) {
+    if (pattern[i] == 'S') {
+      result++;
+    }
+  }
+  return result;
+}
+
 }  // namespace
 
 // ecma402 #sec-intl.datetimeformat.prototype.resolvedoptions
@@ -532,6 +563,13 @@ MaybeHandle<JSObject> JSDateTimeFormat::ResolvedOptions(
               Just(kDontThrow))
               .FromJust());
   }
+  if (FLAG_harmony_intl_dateformat_fractional_second_digits) {
+    int fsd = FractionalSecondDigitsFromPattern(pattern);
+    CHECK(JSReceiver::CreateDataProperty(
+              isolate, options, factory->fractionalSecondDigits_string(),
+              factory->NewNumberFromInt(fsd), Just(kDontThrow))
+              .FromJust());
+  }
 
   return options;
 }
@@ -669,27 +707,23 @@ MaybeHandle<String> JSDateTimeFormat::ToLocaleDateTime(
 namespace {
 
 Maybe<bool> IsPropertyUndefined(Isolate* isolate, Handle<JSObject> options,
-                                const char* property) {
-  Factory* factory = isolate->factory();
+                                Handle<String> property) {
   // i. Let prop be the property name.
   // ii. Let value be ? Get(options, prop).
   Handle<Object> value;
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-      isolate, value,
-      Object::GetPropertyOrElement(
-          isolate, options, factory->NewStringFromAsciiChecked(property)),
+      isolate, value, Object::GetPropertyOrElement(isolate, options, property),
       Nothing<bool>());
   return Just(value->IsUndefined(isolate));
 }
 
 Maybe<bool> NeedsDefault(Isolate* isolate, Handle<JSObject> options,
-                         const std::vector<std::string>& props) {
+                         const std::vector<Handle<String>>& props) {
   bool needs_default = true;
   for (const auto& prop : props) {
     //  i. Let prop be the property name.
     // ii. Let value be ? Get(options, prop)
-    Maybe<bool> maybe_undefined =
-        IsPropertyUndefined(isolate, options, prop.c_str());
+    Maybe<bool> maybe_undefined = IsPropertyUndefined(isolate, options, prop);
     MAYBE_RETURN(maybe_undefined, Nothing<bool>());
     // iii. If value is not undefined, let needDefaults be false.
     if (!maybe_undefined.FromJust()) {
@@ -741,8 +775,15 @@ MaybeHandle<JSObject> JSDateTimeFormat::ToDateTimeOptions(
 
   // 4. If required is "date" or "any", then
   if (required == RequiredOption::kAny || required == RequiredOption::kDate) {
-    // a. For each of the property names "weekday", "year", "month", "day", do
-    const std::vector<std::string> list({"weekday", "year", "month", "day"});
+    // a. For each of the property names "weekday", "year", "quarter", "month",
+    // "day", do
+    std::vector<Handle<String>> list(
+        {factory->weekday_string(), factory->year_string()});
+    if (FLAG_harmony_intl_dateformat_quarter) {
+      list.push_back(factory->quarter_string());
+    }
+    list.push_back(factory->month_string());
+    list.push_back(factory->day_string());
     Maybe<bool> maybe_needs_default = NeedsDefault(isolate, options, list);
     MAYBE_RETURN(maybe_needs_default, Handle<JSObject>());
     needs_default = maybe_needs_default.FromJust();
@@ -750,8 +791,18 @@ MaybeHandle<JSObject> JSDateTimeFormat::ToDateTimeOptions(
 
   // 5. If required is "time" or "any", then
   if (required == RequiredOption::kAny || required == RequiredOption::kTime) {
-    // a. For each of the property names "hour", "minute", "second", do
-    const std::vector<std::string> list({"hour", "minute", "second"});
+    // a. For each of the property names "dayPeriod", "hour", "minute",
+    // "second", "fractionalSecondDigits", do
+    std::vector<Handle<String>> list;
+    if (FLAG_harmony_intl_dateformat_day_period) {
+      list.push_back(factory->dayPeriod_string());
+    }
+    list.push_back(factory->hour_string());
+    list.push_back(factory->minute_string());
+    list.push_back(factory->second_string());
+    if (FLAG_harmony_intl_dateformat_fractional_second_digits) {
+      list.push_back(factory->fractionalSecondDigits_string());
+    }
     Maybe<bool> maybe_needs_default = NeedsDefault(isolate, options, list);
     MAYBE_RETURN(maybe_needs_default, Handle<JSObject>());
     needs_default &= maybe_needs_default.FromJust();
@@ -1419,6 +1470,16 @@ MaybeHandle<JSDateTimeFormat> JSDateTimeFormat::Initialize(
         skeleton += item.map.find(input.get())->second;
       }
     }
+    if (FLAG_harmony_intl_dateformat_fractional_second_digits) {
+      Maybe<int> maybe_fsd = Intl::GetNumberOption(
+          isolate, options, factory->fractionalSecondDigits_string(), 0, 3, 0);
+      MAYBE_RETURN(maybe_fsd, MaybeHandle<JSDateTimeFormat>());
+      // Convert fractionalSecondDigits to skeleton.
+      int fsd = maybe_fsd.FromJust();
+      for (int i = 0; i < fsd; i++) {
+        skeleton += "S";
+      }
+    }
 
     enum FormatMatcherOption { kBestFit, kBasic };
     // We implement only best fit algorithm, but still need to check
@@ -1516,6 +1577,9 @@ Handle<String> IcuDateFieldIdToDateType(int32_t field_id, Isolate* isolate) {
     case UDAT_EXTENDED_YEAR_FIELD:
     case UDAT_YEAR_NAME_FIELD:
       return isolate->factory()->year_string();
+    case UDAT_QUARTER_FIELD:
+    case UDAT_STANDALONE_QUARTER_FIELD:
+      return isolate->factory()->quarter_string();
     case UDAT_MONTH_FIELD:
     case UDAT_STANDALONE_MONTH_FIELD:
       return isolate->factory()->month_string();
@@ -1535,6 +1599,8 @@ Handle<String> IcuDateFieldIdToDateType(int32_t field_id, Isolate* isolate) {
     case UDAT_STANDALONE_DAY_FIELD:
       return isolate->factory()->weekday_string();
     case UDAT_AM_PM_FIELD:
+    case UDAT_AM_PM_MIDNIGHT_NOON_FIELD:
+    case UDAT_FLEXIBLE_DAY_PERIOD_FIELD:
       return isolate->factory()->dayPeriod_string();
     case UDAT_TIMEZONE_FIELD:
     case UDAT_TIMEZONE_RFC_FIELD:
@@ -1546,6 +1612,8 @@ Handle<String> IcuDateFieldIdToDateType(int32_t field_id, Isolate* isolate) {
       return isolate->factory()->timeZoneName_string();
     case UDAT_ERA_FIELD:
       return isolate->factory()->era_string();
+    case UDAT_FRACTIONAL_SECOND_FIELD:
+      return isolate->factory()->fractionalSecond_string();
     default:
       // Other UDAT_*_FIELD's cannot show up because there is no way to specify
       // them via options of Intl.DateTimeFormat.

tools/v8heapconst.py

@@ -286,51 +286,51 @@ KNOWN_MAPS = {
   ("read_only_space", 0x02371): (87, "EnumCacheMap"),
   ("read_only_space", 0x02411): (105, "ArrayBoilerplateDescriptionMap"),
   ("read_only_space", 0x02601): (90, "InterceptorInfoMap"),
-  ("read_only_space", 0x04d99): (78, "AccessCheckInfoMap"),
-  ("read_only_space", 0x04de9): (79, "AccessorInfoMap"),
-  ("read_only_space", 0x04e39): (80, "AccessorPairMap"),
-  ("read_only_space", 0x04e89): (81, "AliasedArgumentsEntryMap"),
-  ("read_only_space", 0x04ed9): (82, "AllocationMementoMap"),
-  ("read_only_space", 0x04f29): (83, "AsmWasmDataMap"),
-  ("read_only_space", 0x04f79): (84, "AsyncGeneratorRequestMap"),
-  ("read_only_space", 0x04fc9): (85, "ClassPositionsMap"),
-  ("read_only_space", 0x05019): (86, "DebugInfoMap"),
-  ("read_only_space", 0x05069): (88, "FunctionTemplateInfoMap"),
-  ("read_only_space", 0x050b9): (89, "FunctionTemplateRareDataMap"),
-  ("read_only_space", 0x05109): (91, "InterpreterDataMap"),
-  ("read_only_space", 0x05159): (92, "ModuleInfoEntryMap"),
-  ("read_only_space", 0x051a9): (93, "ModuleMap"),
-  ("read_only_space", 0x051f9): (94, "ObjectTemplateInfoMap"),
-  ("read_only_space", 0x05249): (95, "PromiseCapabilityMap"),
-  ("read_only_space", 0x05299): (96, "PromiseReactionMap"),
-  ("read_only_space", 0x052e9): (97, "PrototypeInfoMap"),
-  ("read_only_space", 0x05339): (98, "ScriptMap"),
-  ("read_only_space", 0x05389): (99, "SourcePositionTableWithFrameCacheMap"),
-  ("read_only_space", 0x053d9): (100, "StackFrameInfoMap"),
-  ("read_only_space", 0x05429): (101, "StackTraceFrameMap"),
-  ("read_only_space", 0x05479): (102, "TemplateObjectDescriptionMap"),
-  ("read_only_space", 0x054c9): (103, "Tuple2Map"),
-  ("read_only_space", 0x05519): (104, "Tuple3Map"),
-  ("read_only_space", 0x05569): (106, "WasmCapiFunctionDataMap"),
-  ("read_only_space", 0x055b9): (107, "WasmDebugInfoMap"),
-  ("read_only_space", 0x05609): (108, "WasmExceptionTagMap"),
-  ("read_only_space", 0x05659): (109, "WasmExportedFunctionDataMap"),
-  ("read_only_space", 0x056a9): (110, "WasmJSFunctionDataMap"),
-  ("read_only_space", 0x056f9): (111, "CallableTaskMap"),
-  ("read_only_space", 0x05749): (112, "CallbackTaskMap"),
-  ("read_only_space", 0x05799): (113, "PromiseFulfillReactionJobTaskMap"),
-  ("read_only_space", 0x057e9): (114, "PromiseRejectReactionJobTaskMap"),
-  ("read_only_space", 0x05839): (115, "PromiseResolveThenableJobTaskMap"),
-  ("read_only_space", 0x05889): (116, "FinalizationGroupCleanupJobTaskMap"),
-  ("read_only_space", 0x058d9): (117, "AllocationSiteWithWeakNextMap"),
-  ("read_only_space", 0x05929): (117, "AllocationSiteWithoutWeakNextMap"),
-  ("read_only_space", 0x05979): (152, "LoadHandler1Map"),
-  ("read_only_space", 0x059c9): (152, "LoadHandler2Map"),
-  ("read_only_space", 0x05a19): (152, "LoadHandler3Map"),
-  ("read_only_space", 0x05a69): (160, "StoreHandler0Map"),
-  ("read_only_space", 0x05ab9): (160, "StoreHandler1Map"),
-  ("read_only_space", 0x05b09): (160, "StoreHandler2Map"),
-  ("read_only_space", 0x05b59): (160, "StoreHandler3Map"),
+  ("read_only_space", 0x04de1): (78, "AccessCheckInfoMap"),
+  ("read_only_space", 0x04e31): (79, "AccessorInfoMap"),
+  ("read_only_space", 0x04e81): (80, "AccessorPairMap"),
+  ("read_only_space", 0x04ed1): (81, "AliasedArgumentsEntryMap"),
+  ("read_only_space", 0x04f21): (82, "AllocationMementoMap"),
+  ("read_only_space", 0x04f71): (83, "AsmWasmDataMap"),
+  ("read_only_space", 0x04fc1): (84, "AsyncGeneratorRequestMap"),
+  ("read_only_space", 0x05011): (85, "ClassPositionsMap"),
+  ("read_only_space", 0x05061): (86, "DebugInfoMap"),
+  ("read_only_space", 0x050b1): (88, "FunctionTemplateInfoMap"),
+  ("read_only_space", 0x05101): (89, "FunctionTemplateRareDataMap"),
+  ("read_only_space", 0x05151): (91, "InterpreterDataMap"),
+  ("read_only_space", 0x051a1): (92, "ModuleInfoEntryMap"),
+  ("read_only_space", 0x051f1): (93, "ModuleMap"),
+  ("read_only_space", 0x05241): (94, "ObjectTemplateInfoMap"),
+  ("read_only_space", 0x05291): (95, "PromiseCapabilityMap"),
+  ("read_only_space", 0x052e1): (96, "PromiseReactionMap"),
+  ("read_only_space", 0x05331): (97, "PrototypeInfoMap"),
+  ("read_only_space", 0x05381): (98, "ScriptMap"),
+  ("read_only_space", 0x053d1): (99, "SourcePositionTableWithFrameCacheMap"),
+  ("read_only_space", 0x05421): (100, "StackFrameInfoMap"),
+  ("read_only_space", 0x05471): (101, "StackTraceFrameMap"),
+  ("read_only_space", 0x054c1): (102, "TemplateObjectDescriptionMap"),
+  ("read_only_space", 0x05511): (103, "Tuple2Map"),
+  ("read_only_space", 0x05561): (104, "Tuple3Map"),
+  ("read_only_space", 0x055b1): (106, "WasmCapiFunctionDataMap"),
+  ("read_only_space", 0x05601): (107, "WasmDebugInfoMap"),
+  ("read_only_space", 0x05651): (108, "WasmExceptionTagMap"),
+  ("read_only_space", 0x056a1): (109, "WasmExportedFunctionDataMap"),
+  ("read_only_space", 0x056f1): (110, "WasmJSFunctionDataMap"),
+  ("read_only_space", 0x05741): (111, "CallableTaskMap"),
+  ("read_only_space", 0x05791): (112, "CallbackTaskMap"),
+  ("read_only_space", 0x057e1): (113, "PromiseFulfillReactionJobTaskMap"),
+  ("read_only_space", 0x05831): (114, "PromiseRejectReactionJobTaskMap"),
+  ("read_only_space", 0x05881): (115, "PromiseResolveThenableJobTaskMap"),
+  ("read_only_space", 0x058d1): (116, "FinalizationGroupCleanupJobTaskMap"),
+  ("read_only_space", 0x05921): (117, "AllocationSiteWithWeakNextMap"),
+  ("read_only_space", 0x05971): (117, "AllocationSiteWithoutWeakNextMap"),
+  ("read_only_space", 0x059c1): (152, "LoadHandler1Map"),
+  ("read_only_space", 0x05a11): (152, "LoadHandler2Map"),
+  ("read_only_space", 0x05a61): (152, "LoadHandler3Map"),
+  ("read_only_space", 0x05ab1): (160, "StoreHandler0Map"),
+  ("read_only_space", 0x05b01): (160, "StoreHandler1Map"),
+  ("read_only_space", 0x05b51): (160, "StoreHandler2Map"),
+  ("read_only_space", 0x05ba1): (160, "StoreHandler3Map"),
   ("map_space", 0x00139): (1057, "ExternalMap"),
   ("map_space", 0x00189): (1073, "JSMessageObjectMap"),
 }