Plumb import assertions through SourceTextModuleDescriptor's ModuleRequestMap

This change plumbs import assertions from SourceTextModuleDescriptor's
ModuleRequestMap into SourceTextModuleInfo via a new ModuleRequest
type, where previously there had been only the specifier.

SourceTextModuleDescriptor::module_map now deduplicates module requests
using the specifier and the import assertions.  Continuing to use the
specifier alone would cause a loss of information in the event that
a module imports from the same specifier multiple times using different
sets of assertions.  Failing to deduplicate at all would result in
multiple requests for statements like `import {a,b,c} from "foo.js"`,
which would be a potential performance issue.  See design doc at
https://docs.google.com/document/d/1yuXgNHSbTAPubT1Mg0JXp5uTrfirkvO1g5cHHCe-LmY
for more detail on this decision.

v8::internal::ModuleRequest holds the assertions as an array of the form
[key1, value1, position1, key2, value2, assertion2, ...].  However the
parser still needs to use a map, since duplicate assertion keys need to
be detected at parse time.  A follow-up  change will ensure that
assertions are sorted using a proper lexicographic sort.

Bug: v8:10958
Change-Id: Iff13fb9a37d58fc1622cd3cce78925ad2b7a14bb
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2493060
Commit-Queue: Dan Clark <daniec@microsoft.com>
Reviewed-by: Adam Klein <adamk@chromium.org>
Reviewed-by: Marja Hölttä <marja@chromium.org>
Cr-Commit-Position: refs/heads/master@{#71066}

src/api/api.cc

@@ -2249,7 +2249,9 @@ Local<String> Module::GetModuleRequest(int i) const {
       i::Handle<i::SourceTextModule>::cast(self)->info().module_requests(),
       isolate);
   CHECK_LT(i, module_requests->length());
-  return ToApiHandle<String>(i::handle(module_requests->get(i), isolate));
+  i::Handle<i::ModuleRequest> module_request(
+      i::ModuleRequest::cast(module_requests->get(i)), isolate);
+  return ToApiHandle<String>(i::handle(module_request->specifier(), isolate));
 }
 
 Location Module::GetModuleRequestLocation(int i) const {

src/ast/modules.cc

@@ -16,17 +16,47 @@ namespace internal {
 
 bool SourceTextModuleDescriptor::AstRawStringComparer::operator()(
     const AstRawString* lhs, const AstRawString* rhs) const {
+  return ThreeWayCompare(lhs, rhs) < 0;
+}
+
+int SourceTextModuleDescriptor::AstRawStringComparer::ThreeWayCompare(
+    const AstRawString* lhs, const AstRawString* rhs) {
   // Fast path for equal pointers: a pointer is not strictly less than itself.
   if (lhs == rhs) return false;
 
   // Order by contents (ordering by hash is unstable across runs).
   if (lhs->is_one_byte() != rhs->is_one_byte()) {
-    return lhs->is_one_byte();
+    return lhs->is_one_byte() ? -1 : 1;
   }
   if (lhs->byte_length() != rhs->byte_length()) {
-    return lhs->byte_length() < rhs->byte_length();
+    return lhs->byte_length() - rhs->byte_length();
   }
-  return memcmp(lhs->raw_data(), rhs->raw_data(), lhs->byte_length()) < 0;
+  return memcmp(lhs->raw_data(), rhs->raw_data(), lhs->byte_length());
+}
+
+bool SourceTextModuleDescriptor::ModuleRequestComparer::operator()(
+    const AstModuleRequest* lhs, const AstModuleRequest* rhs) const {
+  if (int specifier_comparison = AstRawStringComparer::ThreeWayCompare(
+          lhs->specifier(), rhs->specifier()))
+    return specifier_comparison < 0;
+
+  if (lhs->import_assertions()->size() != rhs->import_assertions()->size())
+    return (lhs->import_assertions()->size() <
+            rhs->import_assertions()->size());
+
+  auto lhsIt = lhs->import_assertions()->cbegin();
+  auto rhsIt = rhs->import_assertions()->cbegin();
+  for (; lhsIt != lhs->import_assertions()->cend(); ++lhsIt, ++rhsIt) {
+    if (int assertion_key_comparison =
+            AstRawStringComparer::ThreeWayCompare(lhsIt->first, rhsIt->first))
+      return assertion_key_comparison < 0;
+
+    if (int assertion_value_comparison = AstRawStringComparer::ThreeWayCompare(
+            lhsIt->second.first, rhsIt->second.first))
+      return assertion_value_comparison < 0;
+  }
+
+  return false;
 }
 
 void SourceTextModuleDescriptor::AddImport(
@@ -34,11 +64,11 @@ void SourceTextModuleDescriptor::AddImport(
     const AstRawString* module_request,
     const ImportAssertions* import_assertions, const Scanner::Location loc,
     const Scanner::Location specifier_loc, Zone* zone) {
-  // TODO(v8:10958) Add import_assertions to the Entry.
   Entry* entry = zone->New<Entry>(loc);
   entry->local_name = local_name;
   entry->import_name = import_name;
-  entry->module_request = AddModuleRequest(module_request, specifier_loc);
+  entry->module_request =
+      AddModuleRequest(module_request, import_assertions, specifier_loc, zone);
   AddRegularImport(entry);
 }
 
@@ -46,19 +76,18 @@ void SourceTextModuleDescriptor::AddStarImport(
     const AstRawString* local_name, const AstRawString* module_request,
     const ImportAssertions* import_assertions, const Scanner::Location loc,
     const Scanner::Location specifier_loc, Zone* zone) {
-  // TODO(v8:10958) Add import_assertions to the Entry.
   Entry* entry = zone->New<Entry>(loc);
   entry->local_name = local_name;
-  entry->module_request = AddModuleRequest(module_request, specifier_loc);
+  entry->module_request =
+      AddModuleRequest(module_request, import_assertions, specifier_loc, zone);
   AddNamespaceImport(entry, zone);
 }
 
 void SourceTextModuleDescriptor::AddEmptyImport(
     const AstRawString* module_request,
     const ImportAssertions* import_assertions,
-    const Scanner::Location specifier_loc) {
+    const Scanner::Location specifier_loc, Zone* zone) {
-  // TODO(v8:10958) Add import_assertions to the Entry.
+  AddModuleRequest(module_request, import_assertions, specifier_loc, zone);
-  AddModuleRequest(module_request, specifier_loc);
 }
 
 void SourceTextModuleDescriptor::AddExport(const AstRawString* local_name,
@@ -75,13 +104,13 @@ void SourceTextModuleDescriptor::AddExport(
     const AstRawString* module_request,
     const ImportAssertions* import_assertions, const Scanner::Location loc,
     const Scanner::Location specifier_loc, Zone* zone) {
-  // TODO(v8:10958) Add import_assertions to the Entry.
   DCHECK_NOT_NULL(import_name);
   DCHECK_NOT_NULL(export_name);
   Entry* entry = zone->New<Entry>(loc);
   entry->export_name = export_name;
   entry->import_name = import_name;
-  entry->module_request = AddModuleRequest(module_request, specifier_loc);
+  entry->module_request =
+      AddModuleRequest(module_request, import_assertions, specifier_loc, zone);
   AddSpecialExport(entry, zone);
 }
 
@@ -89,9 +118,9 @@ void SourceTextModuleDescriptor::AddStarExport(
     const AstRawString* module_request,
     const ImportAssertions* import_assertions, const Scanner::Location loc,
     const Scanner::Location specifier_loc, Zone* zone) {
-  // TODO(v8:10958) Add import_assertions to the Entry.
   Entry* entry = zone->New<Entry>(loc);
-  entry->module_request = AddModuleRequest(module_request, specifier_loc);
+  entry->module_request =
+      AddModuleRequest(module_request, import_assertions, specifier_loc, zone);
   AddSpecialExport(entry, zone);
 }
 
@@ -104,6 +133,32 @@ Handle<PrimitiveHeapObject> ToStringOrUndefined(LocalIsolate* isolate,
 }
 }  // namespace
 
+template <typename LocalIsolate>
+Handle<ModuleRequest> SourceTextModuleDescriptor::AstModuleRequest::Serialize(
+    LocalIsolate* isolate) const {
+  // The import assertions will be stored in this array in the form:
+  // [key1, value1, location1, key2, value2, location2, ...]
+  Handle<FixedArray> import_assertions_array =
+      isolate->factory()->NewFixedArray(
+          static_cast<int>(import_assertions()->size() * 3));
+
+  int i = 0;
+  for (auto iter = import_assertions()->cbegin();
+       iter != import_assertions()->cend(); ++iter, i += 3) {
+    import_assertions_array->set(i, *iter->first->string());
+    import_assertions_array->set(i + 1, *iter->second.first->string());
+    import_assertions_array->set(i + 2,
+                                 Smi::FromInt(iter->second.second.beg_pos));
+  }
+  return v8::internal::ModuleRequest::New(isolate, specifier()->string(),
+                                          import_assertions_array);
+}
+template Handle<ModuleRequest>
+SourceTextModuleDescriptor::AstModuleRequest::Serialize(Isolate* isolate) const;
+template Handle<ModuleRequest>
+SourceTextModuleDescriptor::AstModuleRequest::Serialize(
+    LocalIsolate* isolate) const;
+
 template <typename LocalIsolate>
 Handle<SourceTextModuleInfoEntry> SourceTextModuleDescriptor::Entry::Serialize(
     LocalIsolate* isolate) const {

src/ast/modules.h

@@ -13,6 +13,7 @@ namespace internal {
 
 
 class AstRawString;
+class ModuleRequest;
 class SourceTextModuleInfo;
 class SourceTextModuleInfoEntry;
 class PendingCompilationErrorHandler;
@@ -55,7 +56,7 @@ class SourceTextModuleDescriptor : public ZoneObject {
   // export {} from "foo.js";  (sic!)
   void AddEmptyImport(const AstRawString* module_request,
                       const ImportAssertions* import_assertions,
-                      const Scanner::Location specifier_loc);
+                      const Scanner::Location specifier_loc, Zone* zone);
 
   // export {x};
   // export {x as y};
@@ -123,20 +124,55 @@ class SourceTextModuleDescriptor : public ZoneObject {
   enum CellIndexKind { kInvalid, kExport, kImport };
   static CellIndexKind GetCellIndexKind(int cell_index);
 
-  struct ModuleRequest {
+  class AstModuleRequest : public ZoneObject {
+   public:
+    // TODO(v8:10958): Consider storing module request location here
+    // instead of using separate ModuleRequestLocation struct.
+    AstModuleRequest(const AstRawString* specifier,
+                     const ImportAssertions* import_assertions)
+        : specifier_(specifier), import_assertions_(import_assertions) {}
+
+    template <typename LocalIsolate>
+    Handle<v8::internal::ModuleRequest> Serialize(LocalIsolate* isolate) const;
+
+    const AstRawString* specifier() const { return specifier_; }
+    const ImportAssertions* import_assertions() const {
+      return import_assertions_;
+    }
+
+   private:
+    const AstRawString* specifier_;
+    const ImportAssertions* import_assertions_;
+  };
+
+  struct ModuleRequestLocation {
+    // The index at which we will place the request in SourceTextModuleInfo's
+    // module_requests FixedArray.
     int index;
+
+    // The JS source code position of the request, used for reporting errors.
     int position;
-    ModuleRequest(int index, int position) : index(index), position(position) {}
+
+    ModuleRequestLocation(int index, int position)
+        : index(index), position(position) {}
   };
 
   // Custom content-based comparer for the below maps, to keep them stable
   // across parses.
   struct V8_EXPORT_PRIVATE AstRawStringComparer {
     bool operator()(const AstRawString* lhs, const AstRawString* rhs) const;
+    static int ThreeWayCompare(const AstRawString* lhs,
+                               const AstRawString* rhs);
+  };
+
+  struct V8_EXPORT_PRIVATE ModuleRequestComparer {
+    bool operator()(const AstModuleRequest* lhs,
+                    const AstModuleRequest* rhs) const;
   };
 
   using ModuleRequestMap =
-      ZoneMap<const AstRawString*, ModuleRequest, AstRawStringComparer>;
+      ZoneMap<const AstModuleRequest*, ModuleRequestLocation,
+              ModuleRequestComparer>;
   using RegularExportMap =
       ZoneMultimap<const AstRawString*, Entry*, AstRawStringComparer>;
   using RegularImportMap =
@@ -233,13 +269,15 @@ class SourceTextModuleDescriptor : public ZoneObject {
   void AssignCellIndices();
 
   int AddModuleRequest(const AstRawString* specifier,
-                       Scanner::Location specifier_loc) {
+                       const ImportAssertions* import_assertions,
+                       Scanner::Location specifier_loc, Zone* zone) {
     DCHECK_NOT_NULL(specifier);
     int module_requests_count = static_cast<int>(module_requests_.size());
     auto it = module_requests_
-                  .insert(std::make_pair(specifier,
+                  .insert(std::make_pair(
-                                         ModuleRequest(module_requests_count,
+                      zone->New<AstModuleRequest>(specifier, import_assertions),
-                                                       specifier_loc.beg_pos)))
+                      ModuleRequestLocation(module_requests_count,
+                                            specifier_loc.beg_pos)))
                   .first;
     return it->second.index;
   }

src/compiler/types.cc

@@ -309,6 +309,7 @@ Type::bitset BitsetType::Lub(const MapRefLike& map) {
     case EVAL_CONTEXT_TYPE:
     case FUNCTION_CONTEXT_TYPE:
     case MODULE_CONTEXT_TYPE:
+    case MODULE_REQUEST_TYPE:
     case NATIVE_CONTEXT_TYPE:
     case SCRIPT_CONTEXT_TYPE:
     case WITH_CONTEXT_TYPE:

src/diagnostics/objects-debug.cc

@@ -1385,6 +1385,17 @@ void Module::ModuleVerify(Isolate* isolate) {
   CHECK_NE(hash(), 0);
 }
 
+void ModuleRequest::ModuleRequestVerify(Isolate* isolate) {
+  TorqueGeneratedClassVerifiers::ModuleRequestVerify(*this, isolate);
+  CHECK_EQ(0, import_assertions().length() % 3);
+
+  for (int i = 0; i < import_assertions().length(); i += 3) {
+    CHECK(import_assertions().get(i).IsString());      // Assertion key
+    CHECK(import_assertions().get(i + 1).IsString());  // Assertion value
+    CHECK(import_assertions().get(i + 2).IsSmi());     // Assertion location
+  }
+}
+
 void SourceTextModule::SourceTextModuleVerify(Isolate* isolate) {
   TorqueGeneratedClassVerifiers::SourceTextModuleVerify(*this, isolate);
 

src/objects/module-inl.h

@@ -25,6 +25,7 @@ OBJECT_CONSTRUCTORS_IMPL(Module, HeapObject)
 TQ_OBJECT_CONSTRUCTORS_IMPL(JSModuleNamespace)
 
 NEVER_READ_ONLY_SPACE_IMPL(Module)
+NEVER_READ_ONLY_SPACE_IMPL(ModuleRequest)
 NEVER_READ_ONLY_SPACE_IMPL(SourceTextModule)
 NEVER_READ_ONLY_SPACE_IMPL(SyntheticModule)
 

src/objects/objects-definitions.h

@@ -135,6 +135,7 @@ namespace internal {
     function_template_rare_data)                                              \
   V(_, INTERCEPTOR_INFO_TYPE, InterceptorInfo, interceptor_info)              \
   V(_, INTERPRETER_DATA_TYPE, InterpreterData, interpreter_data)              \
+  V(_, MODULE_REQUEST_TYPE, ModuleRequest, module_request)                    \
   V(_, PROMISE_CAPABILITY_TYPE, PromiseCapability, promise_capability)        \
   V(_, PROMISE_REACTION_TYPE, PromiseReaction, promise_reaction)              \
   V(_, PROPERTY_DESCRIPTOR_OBJECT_TYPE, PropertyDescriptorObject,             \

src/objects/scope-info.cc

@@ -1043,6 +1043,24 @@ std::ostream& operator<<(std::ostream& os, VariableAllocationInfo var_info) {
   return os;
 }
 
+template <typename LocalIsolate>
+Handle<ModuleRequest> ModuleRequest::New(LocalIsolate* isolate,
+                                         Handle<String> specifier,
+                                         Handle<FixedArray> import_assertions) {
+  Handle<ModuleRequest> result = Handle<ModuleRequest>::cast(
+      isolate->factory()->NewStruct(MODULE_REQUEST_TYPE, AllocationType::kOld));
+  result->set_specifier(*specifier);
+  result->set_import_assertions(*import_assertions);
+  return result;
+}
+
+template Handle<ModuleRequest> ModuleRequest::New(
+    Isolate* isolate, Handle<String> specifier,
+    Handle<FixedArray> import_assertions);
+template Handle<ModuleRequest> ModuleRequest::New(
+    LocalIsolate* isolate, Handle<String> specifier,
+    Handle<FixedArray> import_assertions);
+
 template <typename LocalIsolate>
 Handle<SourceTextModuleInfoEntry> SourceTextModuleInfoEntry::New(
     LocalIsolate* isolate, Handle<PrimitiveHeapObject> export_name,
@@ -1082,7 +1100,9 @@ Handle<SourceTextModuleInfo> SourceTextModuleInfo::New(
   Handle<FixedArray> module_request_positions =
       isolate->factory()->NewFixedArray(size);
   for (const auto& elem : descr->module_requests()) {
-    module_requests->set(elem.second.index, *elem.first->string());
+    Handle<ModuleRequest> serialized_module_request =
+        elem.first->Serialize(isolate);
+    module_requests->set(elem.second.index, *serialized_module_request);
     module_request_positions->set(elem.second.index,
                                   Smi::FromInt(elem.second.position));
   }

src/objects/source-text-module-inl.h

@@ -17,6 +17,7 @@ namespace internal {
 
 #include "torque-generated/src/objects/source-text-module-tq-inl.inc"
 
+TQ_OBJECT_CONSTRUCTORS_IMPL(ModuleRequest)
 TQ_OBJECT_CONSTRUCTORS_IMPL(SourceTextModule)
 TQ_OBJECT_CONSTRUCTORS_IMPL(SourceTextModuleInfoEntry)
 

src/objects/source-text-module.cc

@@ -234,16 +234,20 @@ MaybeHandle<Cell> SourceTextModule::ResolveExport(
 
 MaybeHandle<Cell> SourceTextModule::ResolveImport(
     Isolate* isolate, Handle<SourceTextModule> module, Handle<String> name,
-    int module_request, MessageLocation loc, bool must_resolve,
+    int module_request_index, MessageLocation loc, bool must_resolve,
     Module::ResolveSet* resolve_set) {
   Handle<Module> requested_module(
-      Module::cast(module->requested_modules().get(module_request)), isolate);
+      Module::cast(module->requested_modules().get(module_request_index)),
-  Handle<String> specifier(
-      String::cast(module->info().module_requests().get(module_request)),
       isolate);
+  Handle<ModuleRequest> module_request(
+      ModuleRequest::cast(
+          module->info().module_requests().get(module_request_index)),
+      isolate);
+  Handle<String> module_specifier(String::cast(module_request->specifier()),
+                                  isolate);
   MaybeHandle<Cell> result =
-      Module::ResolveExport(isolate, requested_module, specifier, name, loc,
+      Module::ResolveExport(isolate, requested_module, module_specifier, name,
-                            must_resolve, resolve_set);
+                            loc, must_resolve, resolve_set);
   DCHECK_IMPLIES(isolate->has_pending_exception(), result.is_null());
   return result;
 }
@@ -312,7 +316,10 @@ bool SourceTextModule::PrepareInstantiate(
   Handle<FixedArray> module_requests(module_info->module_requests(), isolate);
   Handle<FixedArray> requested_modules(module->requested_modules(), isolate);
   for (int i = 0, length = module_requests->length(); i < length; ++i) {
-    Handle<String> specifier(String::cast(module_requests->get(i)), isolate);
+    Handle<ModuleRequest> module_request(
+        ModuleRequest::cast(module_requests->get(i)), isolate);
+    Handle<String> specifier(module_request->specifier(), isolate);
+    // TODO(v8:10958) Pass import assertions to the callback
     v8::Local<v8::Module> api_requested_module;
     if (!callback(context, v8::Utils::ToLocal(specifier),
                   v8::Utils::ToLocal(Handle<Module>::cast(module)))

src/objects/source-text-module.h

@@ -126,7 +126,7 @@ class SourceTextModule
       MessageLocation loc, bool must_resolve, ResolveSet* resolve_set);
   static V8_WARN_UNUSED_RESULT MaybeHandle<Cell> ResolveImport(
       Isolate* isolate, Handle<SourceTextModule> module, Handle<String> name,
-      int module_request, MessageLocation loc, bool must_resolve,
+      int module_request_index, MessageLocation loc, bool must_resolve,
       ResolveSet* resolve_set);
 
   static V8_WARN_UNUSED_RESULT MaybeHandle<Cell> ResolveExportUsingStarExports(
@@ -238,6 +238,20 @@ class SourceTextModuleInfo : public FixedArray {
   OBJECT_CONSTRUCTORS(SourceTextModuleInfo, FixedArray);
 };
 
+class ModuleRequest
+    : public TorqueGeneratedModuleRequest<ModuleRequest, Struct> {
+ public:
+  NEVER_READ_ONLY_SPACE
+  DECL_VERIFIER(ModuleRequest)
+
+  template <typename LocalIsolate>
+  static Handle<ModuleRequest> New(LocalIsolate* isolate,
+                                   Handle<String> specifier,
+                                   Handle<FixedArray> import_assertions);
+
+  TQ_OBJECT_CONSTRUCTORS(ModuleRequest)
+};
+
 class SourceTextModuleInfoEntry
     : public TorqueGeneratedSourceTextModuleInfoEntry<SourceTextModuleInfoEntry,
                                                       Struct> {

src/objects/source-text-module.tq

@@ -47,6 +47,16 @@ extern class SourceTextModule extends Module {
   flags: SmiTagged<SourceTextModuleFlags>;
 }
 
+@generateCppClass
+@generatePrint
+extern class ModuleRequest extends Struct {
+  specifier: String;
+
+  // Import assertions are stored in this array in the form:
+  // [key1, value1, location1, key2, value2, location2, ...]
+  import_assertions: FixedArray;
+}
+
 @generateCppClass
 extern class SourceTextModuleInfoEntry extends Struct {
   export_name: String|Undefined;

src/parsing/parser.cc

@@ -1306,8 +1306,8 @@ void Parser::ParseImportDeclaration() {
     const AstRawString* module_specifier = ParseModuleSpecifier();
     const ImportAssertions* import_assertions = ParseImportAssertClause();
     ExpectSemicolon();
-    module()->AddEmptyImport(module_specifier, import_assertions,
+    module()->AddEmptyImport(module_specifier, import_assertions, specifier_loc,
-                             specifier_loc);
+                             zone());
     return;
   }
 
@@ -1377,7 +1377,7 @@ void Parser::ParseImportDeclaration() {
   if (named_imports != nullptr) {
     if (named_imports->length() == 0) {
       module()->AddEmptyImport(module_specifier, import_assertions,
-                               specifier_loc);
+                               specifier_loc, zone());
     } else {
       for (const NamedImport* import : *named_imports) {
         module()->AddImport(import->import_name, import->local_name,
@@ -1567,7 +1567,7 @@ Statement* Parser::ParseExportDeclaration() {
 
         if (export_data->is_empty()) {
           module()->AddEmptyImport(module_specifier, import_assertions,
-                                   specifier_loc);
+                                   specifier_loc, zone());
         } else {
           for (const ExportClauseData& data : *export_data) {
             module()->AddExport(data.local_name, data.export_name,

test/cctest/test-parsing.cc

@@ -8082,19 +8082,19 @@ TEST(ModuleParsingInternals) {
 
   CHECK_EQ(5u, descriptor->module_requests().size());
   for (const auto& elem : descriptor->module_requests()) {
-    if (elem.first->IsOneByteEqualTo("m.js")) {
+    if (elem.first->specifier()->IsOneByteEqualTo("m.js")) {
       CHECK_EQ(0, elem.second.index);
       CHECK_EQ(51, elem.second.position);
-    } else if (elem.first->IsOneByteEqualTo("n.js")) {
+    } else if (elem.first->specifier()->IsOneByteEqualTo("n.js")) {
       CHECK_EQ(1, elem.second.index);
       CHECK_EQ(72, elem.second.position);
-    } else if (elem.first->IsOneByteEqualTo("p.js")) {
+    } else if (elem.first->specifier()->IsOneByteEqualTo("p.js")) {
       CHECK_EQ(2, elem.second.index);
       CHECK_EQ(123, elem.second.position);
-    } else if (elem.first->IsOneByteEqualTo("q.js")) {
+    } else if (elem.first->specifier()->IsOneByteEqualTo("q.js")) {
       CHECK_EQ(3, elem.second.index);
       CHECK_EQ(249, elem.second.position);
-    } else if (elem.first->IsOneByteEqualTo("bar.js")) {
+    } else if (elem.first->specifier()->IsOneByteEqualTo("bar.js")) {
       CHECK_EQ(4, elem.second.index);
       CHECK_EQ(370, elem.second.position);
     } else {
@@ -8172,6 +8172,353 @@ TEST(ModuleParsingInternals) {
   CheckEntry(entry, nullptr, "aa", "aa", 0);
 }
 
+TEST(ModuleParsingInternalsWithImportAssertions) {
+  i::FLAG_harmony_import_assertions = true;
+  i::Isolate* isolate = CcTest::i_isolate();
+  i::Factory* factory = isolate->factory();
+  v8::HandleScope handles(CcTest::isolate());
+  v8::Local<v8::Context> context = v8::Context::New(CcTest::isolate());
+  v8::Context::Scope context_scope(context);
+  isolate->stack_guard()->SetStackLimit(base::Stack::GetCurrentStackPosition() -
+                                        128 * 1024);
+
+  static const char kSource[] =
+      "import { q as z } from 'm.js';"
+      "import { q as z2 } from 'm.js' assert { foo: 'bar'};"
+      "import { q as z3 } from 'm.js' assert { foo2: 'bar'};"
+      "import { q as z4 } from 'm.js' assert { foo: 'bar2'};"
+      "import { q as z5 } from 'm.js' assert { foo: 'bar', foo2: 'bar'};"
+      "import { q as z6 } from 'n.js' assert { foo: 'bar'};"
+      "import 'm.js' assert { foo: 'bar'};"
+      "export * from 'm.js' assert { foo: 'bar', foo2: 'bar'};";
+  i::Handle<i::String> source = factory->NewStringFromAsciiChecked(kSource);
+  i::Handle<i::Script> script = factory->NewScript(source);
+  i::UnoptimizedCompileState compile_state(isolate);
+  i::UnoptimizedCompileFlags flags =
+      i::UnoptimizedCompileFlags::ForScriptCompile(isolate, *script);
+  flags.set_is_module(true);
+  i::ParseInfo info(isolate, flags, &compile_state);
+  CHECK_PARSE_PROGRAM(&info, script, isolate);
+
+  i::FunctionLiteral* func = info.literal();
+  i::ModuleScope* module_scope = func->scope()->AsModuleScope();
+  CHECK(module_scope->is_module_scope());
+
+  i::SourceTextModuleDescriptor* descriptor = module_scope->module();
+  CHECK_NOT_NULL(descriptor);
+
+  const i::AstRawString* foo_string =
+      info.ast_value_factory()->GetOneByteString("foo");
+  const i::AstRawString* foo2_string =
+      info.ast_value_factory()->GetOneByteString("foo2");
+  CHECK_EQ(6u, descriptor->module_requests().size());
+  for (const auto& elem : descriptor->module_requests()) {
+    if (elem.second.index == 0) {
+      CHECK(elem.first->specifier()->IsOneByteEqualTo("m.js"));
+      CHECK_EQ(0, elem.first->import_assertions()->size());
+      CHECK_EQ(23, elem.second.position);
+    } else if (elem.second.index == 1) {
+      CHECK(elem.first->specifier()->IsOneByteEqualTo("m.js"));
+      CHECK_EQ(1, elem.first->import_assertions()->size());
+      CHECK_EQ(54, elem.second.position);
+      CHECK(elem.first->import_assertions()
+                ->at(foo_string)
+                .first->IsOneByteEqualTo("bar"));
+      CHECK_EQ(70,
+               elem.first->import_assertions()->at(foo_string).second.beg_pos);
+    } else if (elem.second.index == 2) {
+      CHECK(elem.first->specifier()->IsOneByteEqualTo("m.js"));
+      CHECK_EQ(1, elem.first->import_assertions()->size());
+      CHECK_EQ(106, elem.second.position);
+      CHECK(elem.first->import_assertions()
+                ->at(foo2_string)
+                .first->IsOneByteEqualTo("bar"));
+      CHECK_EQ(122,
+               elem.first->import_assertions()->at(foo2_string).second.beg_pos);
+    } else if (elem.second.index == 3) {
+      CHECK(elem.first->specifier()->IsOneByteEqualTo("m.js"));
+      CHECK_EQ(1, elem.first->import_assertions()->size());
+      CHECK_EQ(159, elem.second.position);
+      CHECK(elem.first->import_assertions()
+                ->at(foo_string)
+                .first->IsOneByteEqualTo("bar2"));
+      CHECK_EQ(175,
+               elem.first->import_assertions()->at(foo_string).second.beg_pos);
+    } else if (elem.second.index == 4) {
+      CHECK(elem.first->specifier()->IsOneByteEqualTo("m.js"));
+      CHECK_EQ(2, elem.first->import_assertions()->size());
+      CHECK_EQ(212, elem.second.position);
+      CHECK(elem.first->import_assertions()
+                ->at(foo_string)
+                .first->IsOneByteEqualTo("bar"));
+      CHECK_EQ(228,
+               elem.first->import_assertions()->at(foo_string).second.beg_pos);
+      CHECK(elem.first->import_assertions()
+                ->at(foo2_string)
+                .first->IsOneByteEqualTo("bar"));
+      CHECK_EQ(240,
+               elem.first->import_assertions()->at(foo2_string).second.beg_pos);
+    } else if (elem.second.index == 5) {
+      CHECK(elem.first->specifier()->IsOneByteEqualTo("n.js"));
+      CHECK_EQ(1, elem.first->import_assertions()->size());
+      CHECK_EQ(277, elem.second.position);
+      CHECK(elem.first->import_assertions()
+                ->at(foo_string)
+                .first->IsOneByteEqualTo("bar"));
+      CHECK_EQ(293,
+               elem.first->import_assertions()->at(foo_string).second.beg_pos);
+    } else {
+      UNREACHABLE();
+    }
+  }
+}
+
+TEST(ModuleParsingImportAssertionOrdering) {
+  i::FLAG_harmony_import_assertions = true;
+  i::Isolate* isolate = CcTest::i_isolate();
+  i::Factory* factory = isolate->factory();
+  v8::HandleScope handles(CcTest::isolate());
+  v8::Local<v8::Context> context = v8::Context::New(CcTest::isolate());
+  v8::Context::Scope context_scope(context);
+  isolate->stack_guard()->SetStackLimit(base::Stack::GetCurrentStackPosition() -
+                                        128 * 1024);
+
+  static const char kSource[] =
+      "import 'foo' assert { };"
+      "import 'baaaaaar' assert { };"
+      "import 'aa' assert { };"
+      "import 'a' assert { a: 'b' };"
+      "import 'b' assert { };"
+      "import 'd' assert { a: 'b' };"
+      "import 'c' assert { };"
+      "import 'f' assert { };"
+      "import 'f' assert { a: 'b'};"
+      "import 'g' assert { a: 'b' };"
+      "import 'g' assert { };"
+      "import 'h' assert { a: 'd' };"
+      "import 'h' assert { b: 'c' };"
+      "import 'i' assert { b: 'c' };"
+      "import 'i' assert { a: 'd' };"
+      "import 'j' assert { a: 'b' };"
+      "import 'j' assert { a: 'c' };"
+      "import 'k' assert { a: 'c' };"
+      "import 'k' assert { a: 'b' };"
+      "import 'l' assert { a: 'b', e: 'f' };"
+      "import 'l' assert { a: 'c', d: 'g' };"
+      "import 'm' assert { a: 'c', d: 'g' };"
+      "import 'm' assert { a: 'b', e: 'f' };"
+      "import 'n' assert { 'd': '' };"
+      "import 'n' assert { 'a': 'b' };"
+      "import 'o' assert { 'a': 'b' };"
+      "import 'o' assert { 'd': '' };"
+      "import 'p' assert { 'z': 'c' };"
+      "import 'p' assert { 'a': 'c', 'b': 'c' };";
+  i::Handle<i::String> source = factory->NewStringFromAsciiChecked(kSource);
+  i::Handle<i::Script> script = factory->NewScript(source);
+  i::UnoptimizedCompileState compile_state(isolate);
+  i::UnoptimizedCompileFlags flags =
+      i::UnoptimizedCompileFlags::ForScriptCompile(isolate, *script);
+  flags.set_is_module(true);
+  i::ParseInfo info(isolate, flags, &compile_state);
+  CHECK_PARSE_PROGRAM(&info, script, isolate);
+
+  i::FunctionLiteral* func = info.literal();
+  i::ModuleScope* module_scope = func->scope()->AsModuleScope();
+  CHECK(module_scope->is_module_scope());
+
+  i::SourceTextModuleDescriptor* descriptor = module_scope->module();
+  CHECK_NOT_NULL(descriptor);
+
+  const i::AstRawString* a_string =
+      info.ast_value_factory()->GetOneByteString("a");
+  const i::AstRawString* b_string =
+      info.ast_value_factory()->GetOneByteString("b");
+  const i::AstRawString* d_string =
+      info.ast_value_factory()->GetOneByteString("d");
+  const i::AstRawString* e_string =
+      info.ast_value_factory()->GetOneByteString("e");
+  const i::AstRawString* z_string =
+      info.ast_value_factory()->GetOneByteString("z");
+  CHECK_EQ(29u, descriptor->module_requests().size());
+  auto request_iterator = descriptor->module_requests().cbegin();
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("a"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("b"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("c"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("d"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("f"));
+  CHECK_EQ(0, request_iterator->first->import_assertions()->size());
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("f"));
+  CHECK_EQ(1, request_iterator->first->import_assertions()->size());
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("g"));
+  CHECK_EQ(0, request_iterator->first->import_assertions()->size());
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("g"));
+  CHECK_EQ(1, request_iterator->first->import_assertions()->size());
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("h"));
+  CHECK_EQ(1, request_iterator->first->import_assertions()->size());
+  CHECK(request_iterator->first->import_assertions()
+            ->at(a_string)
+            .first->IsOneByteEqualTo("d"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("h"));
+  CHECK_EQ(1, request_iterator->first->import_assertions()->size());
+  CHECK(request_iterator->first->import_assertions()
+            ->at(b_string)
+            .first->IsOneByteEqualTo("c"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("i"));
+  CHECK_EQ(1, request_iterator->first->import_assertions()->size());
+  CHECK(request_iterator->first->import_assertions()
+            ->at(a_string)
+            .first->IsOneByteEqualTo("d"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("i"));
+  CHECK_EQ(1, request_iterator->first->import_assertions()->size());
+  CHECK(request_iterator->first->import_assertions()
+            ->at(b_string)
+            .first->IsOneByteEqualTo("c"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("j"));
+  CHECK_EQ(1, request_iterator->first->import_assertions()->size());
+  CHECK(request_iterator->first->import_assertions()
+            ->at(a_string)
+            .first->IsOneByteEqualTo("b"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("j"));
+  CHECK_EQ(1, request_iterator->first->import_assertions()->size());
+  CHECK(request_iterator->first->import_assertions()
+            ->at(a_string)
+            .first->IsOneByteEqualTo("c"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("k"));
+  CHECK_EQ(1, request_iterator->first->import_assertions()->size());
+  CHECK(request_iterator->first->import_assertions()
+            ->at(a_string)
+            .first->IsOneByteEqualTo("b"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("k"));
+  CHECK_EQ(1, request_iterator->first->import_assertions()->size());
+  CHECK(request_iterator->first->import_assertions()
+            ->at(a_string)
+            .first->IsOneByteEqualTo("c"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("l"));
+  CHECK_EQ(2, request_iterator->first->import_assertions()->size());
+  CHECK(request_iterator->first->import_assertions()
+            ->at(a_string)
+            .first->IsOneByteEqualTo("b"));
+  CHECK(request_iterator->first->import_assertions()
+            ->at(e_string)
+            .first->IsOneByteEqualTo("f"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("l"));
+  CHECK_EQ(2, request_iterator->first->import_assertions()->size());
+  CHECK(request_iterator->first->import_assertions()
+            ->at(a_string)
+            .first->IsOneByteEqualTo("c"));
+  CHECK(request_iterator->first->import_assertions()
+            ->at(d_string)
+            .first->IsOneByteEqualTo("g"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("m"));
+  CHECK_EQ(2, request_iterator->first->import_assertions()->size());
+  CHECK(request_iterator->first->import_assertions()
+            ->at(a_string)
+            .first->IsOneByteEqualTo("b"));
+  CHECK(request_iterator->first->import_assertions()
+            ->at(e_string)
+            .first->IsOneByteEqualTo("f"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("m"));
+  CHECK_EQ(2, request_iterator->first->import_assertions()->size());
+  CHECK(request_iterator->first->import_assertions()
+            ->at(a_string)
+            .first->IsOneByteEqualTo("c"));
+  CHECK(request_iterator->first->import_assertions()
+            ->at(d_string)
+            .first->IsOneByteEqualTo("g"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("n"));
+  CHECK_EQ(1, request_iterator->first->import_assertions()->size());
+  CHECK(request_iterator->first->import_assertions()
+            ->at(a_string)
+            .first->IsOneByteEqualTo("b"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("n"));
+  CHECK_EQ(1, request_iterator->first->import_assertions()->size());
+  CHECK(request_iterator->first->import_assertions()
+            ->at(d_string)
+            .first->IsOneByteEqualTo(""));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("o"));
+  CHECK_EQ(1, request_iterator->first->import_assertions()->size());
+  CHECK(request_iterator->first->import_assertions()
+            ->at(a_string)
+            .first->IsOneByteEqualTo("b"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("o"));
+  CHECK_EQ(1, request_iterator->first->import_assertions()->size());
+  CHECK(request_iterator->first->import_assertions()
+            ->at(d_string)
+            .first->IsOneByteEqualTo(""));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("p"));
+  CHECK_EQ(1, request_iterator->first->import_assertions()->size());
+  CHECK(request_iterator->first->import_assertions()
+            ->at(z_string)
+            .first->IsOneByteEqualTo("c"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("p"));
+  CHECK_EQ(2, request_iterator->first->import_assertions()->size());
+  CHECK(request_iterator->first->import_assertions()
+            ->at(a_string)
+            .first->IsOneByteEqualTo("c"));
+  CHECK(request_iterator->first->import_assertions()
+            ->at(b_string)
+            .first->IsOneByteEqualTo("c"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("aa"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("foo"));
+  ++request_iterator;
+
+  CHECK(request_iterator->first->specifier()->IsOneByteEqualTo("baaaaaar"));
+}
 
 TEST(DuplicateProtoError) {
   const char* context_data[][2] = {

tools/v8heapconst.py

@@ -62,94 +62,95 @@ INSTANCE_TYPES = {
   98: "FUNCTION_TEMPLATE_RARE_DATA_TYPE",
   99: "INTERCEPTOR_INFO_TYPE",
   100: "INTERPRETER_DATA_TYPE",
-  101: "PROMISE_CAPABILITY_TYPE",
+  101: "MODULE_REQUEST_TYPE",
-  102: "PROMISE_REACTION_TYPE",
+  102: "PROMISE_CAPABILITY_TYPE",
-  103: "PROPERTY_DESCRIPTOR_OBJECT_TYPE",
+  103: "PROMISE_REACTION_TYPE",
-  104: "PROTOTYPE_INFO_TYPE",
+  104: "PROPERTY_DESCRIPTOR_OBJECT_TYPE",
-  105: "SCRIPT_TYPE",
+  105: "PROTOTYPE_INFO_TYPE",
-  106: "SOURCE_TEXT_MODULE_INFO_ENTRY_TYPE",
+  106: "SCRIPT_TYPE",
-  107: "STACK_FRAME_INFO_TYPE",
+  107: "SOURCE_TEXT_MODULE_INFO_ENTRY_TYPE",
-  108: "STACK_TRACE_FRAME_TYPE",
+  108: "STACK_FRAME_INFO_TYPE",
-  109: "TEMPLATE_OBJECT_DESCRIPTION_TYPE",
+  109: "STACK_TRACE_FRAME_TYPE",
-  110: "TUPLE2_TYPE",
+  110: "TEMPLATE_OBJECT_DESCRIPTION_TYPE",
-  111: "WASM_EXCEPTION_TAG_TYPE",
+  111: "TUPLE2_TYPE",
-  112: "WASM_EXPORTED_FUNCTION_DATA_TYPE",
+  112: "WASM_EXCEPTION_TAG_TYPE",
-  113: "WASM_INDIRECT_FUNCTION_TABLE_TYPE",
+  113: "WASM_EXPORTED_FUNCTION_DATA_TYPE",
-  114: "WASM_JS_FUNCTION_DATA_TYPE",
+  114: "WASM_INDIRECT_FUNCTION_TABLE_TYPE",
-  115: "WASM_VALUE_TYPE",
+  115: "WASM_JS_FUNCTION_DATA_TYPE",
-  116: "FIXED_ARRAY_TYPE",
+  116: "WASM_VALUE_TYPE",
-  117: "HASH_TABLE_TYPE",
+  117: "FIXED_ARRAY_TYPE",
-  118: "EPHEMERON_HASH_TABLE_TYPE",
+  118: "HASH_TABLE_TYPE",
-  119: "GLOBAL_DICTIONARY_TYPE",
+  119: "EPHEMERON_HASH_TABLE_TYPE",
-  120: "NAME_DICTIONARY_TYPE",
+  120: "GLOBAL_DICTIONARY_TYPE",
-  121: "NUMBER_DICTIONARY_TYPE",
+  121: "NAME_DICTIONARY_TYPE",
-  122: "ORDERED_HASH_MAP_TYPE",
+  122: "NUMBER_DICTIONARY_TYPE",
-  123: "ORDERED_HASH_SET_TYPE",
+  123: "ORDERED_HASH_MAP_TYPE",
-  124: "ORDERED_NAME_DICTIONARY_TYPE",
+  124: "ORDERED_HASH_SET_TYPE",
-  125: "SIMPLE_NUMBER_DICTIONARY_TYPE",
+  125: "ORDERED_NAME_DICTIONARY_TYPE",
-  126: "CLOSURE_FEEDBACK_CELL_ARRAY_TYPE",
+  126: "SIMPLE_NUMBER_DICTIONARY_TYPE",
-  127: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE",
+  127: "CLOSURE_FEEDBACK_CELL_ARRAY_TYPE",
-  128: "SCOPE_INFO_TYPE",
+  128: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE",
-  129: "SCRIPT_CONTEXT_TABLE_TYPE",
+  129: "SCOPE_INFO_TYPE",
-  130: "BYTE_ARRAY_TYPE",
+  130: "SCRIPT_CONTEXT_TABLE_TYPE",
-  131: "BYTECODE_ARRAY_TYPE",
+  131: "BYTE_ARRAY_TYPE",
-  132: "FIXED_DOUBLE_ARRAY_TYPE",
+  132: "BYTECODE_ARRAY_TYPE",
-  133: "INTERNAL_CLASS_WITH_SMI_ELEMENTS_TYPE",
+  133: "FIXED_DOUBLE_ARRAY_TYPE",
-  134: "SLOPPY_ARGUMENTS_ELEMENTS_TYPE",
+  134: "INTERNAL_CLASS_WITH_SMI_ELEMENTS_TYPE",
-  135: "AWAIT_CONTEXT_TYPE",
+  135: "SLOPPY_ARGUMENTS_ELEMENTS_TYPE",
-  136: "BLOCK_CONTEXT_TYPE",
+  136: "AWAIT_CONTEXT_TYPE",
-  137: "CATCH_CONTEXT_TYPE",
+  137: "BLOCK_CONTEXT_TYPE",
-  138: "DEBUG_EVALUATE_CONTEXT_TYPE",
+  138: "CATCH_CONTEXT_TYPE",
-  139: "EVAL_CONTEXT_TYPE",
+  139: "DEBUG_EVALUATE_CONTEXT_TYPE",
-  140: "FUNCTION_CONTEXT_TYPE",
+  140: "EVAL_CONTEXT_TYPE",
-  141: "MODULE_CONTEXT_TYPE",
+  141: "FUNCTION_CONTEXT_TYPE",
-  142: "NATIVE_CONTEXT_TYPE",
+  142: "MODULE_CONTEXT_TYPE",
-  143: "SCRIPT_CONTEXT_TYPE",
+  143: "NATIVE_CONTEXT_TYPE",
-  144: "WITH_CONTEXT_TYPE",
+  144: "SCRIPT_CONTEXT_TYPE",
-  145: "EXPORTED_SUB_CLASS_BASE_TYPE",
+  145: "WITH_CONTEXT_TYPE",
-  146: "EXPORTED_SUB_CLASS_TYPE",
+  146: "EXPORTED_SUB_CLASS_BASE_TYPE",
-  147: "EXPORTED_SUB_CLASS2_TYPE",
+  147: "EXPORTED_SUB_CLASS_TYPE",
-  148: "SMALL_ORDERED_HASH_MAP_TYPE",
+  148: "EXPORTED_SUB_CLASS2_TYPE",
-  149: "SMALL_ORDERED_HASH_SET_TYPE",
+  149: "SMALL_ORDERED_HASH_MAP_TYPE",
-  150: "SMALL_ORDERED_NAME_DICTIONARY_TYPE",
+  150: "SMALL_ORDERED_HASH_SET_TYPE",
-  151: "DESCRIPTOR_ARRAY_TYPE",
+  151: "SMALL_ORDERED_NAME_DICTIONARY_TYPE",
-  152: "STRONG_DESCRIPTOR_ARRAY_TYPE",
+  152: "DESCRIPTOR_ARRAY_TYPE",
-  153: "SOURCE_TEXT_MODULE_TYPE",
+  153: "STRONG_DESCRIPTOR_ARRAY_TYPE",
-  154: "SYNTHETIC_MODULE_TYPE",
+  154: "SOURCE_TEXT_MODULE_TYPE",
-  155: "UNCOMPILED_DATA_WITH_PREPARSE_DATA_TYPE",
+  155: "SYNTHETIC_MODULE_TYPE",
-  156: "UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_TYPE",
+  156: "UNCOMPILED_DATA_WITH_PREPARSE_DATA_TYPE",
-  157: "WEAK_FIXED_ARRAY_TYPE",
+  157: "UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_TYPE",
-  158: "TRANSITION_ARRAY_TYPE",
+  158: "WEAK_FIXED_ARRAY_TYPE",
-  159: "CELL_TYPE",
+  159: "TRANSITION_ARRAY_TYPE",
-  160: "CODE_TYPE",
+  160: "CELL_TYPE",
-  161: "CODE_DATA_CONTAINER_TYPE",
+  161: "CODE_TYPE",
-  162: "COVERAGE_INFO_TYPE",
+  162: "CODE_DATA_CONTAINER_TYPE",
-  163: "EMBEDDER_DATA_ARRAY_TYPE",
+  163: "COVERAGE_INFO_TYPE",
-  164: "FEEDBACK_METADATA_TYPE",
+  164: "EMBEDDER_DATA_ARRAY_TYPE",
-  165: "FEEDBACK_VECTOR_TYPE",
+  165: "FEEDBACK_METADATA_TYPE",
-  166: "FILLER_TYPE",
+  166: "FEEDBACK_VECTOR_TYPE",
-  167: "FREE_SPACE_TYPE",
+  167: "FILLER_TYPE",
-  168: "INTERNAL_CLASS_TYPE",
+  168: "FREE_SPACE_TYPE",
-  169: "INTERNAL_CLASS_WITH_STRUCT_ELEMENTS_TYPE",
+  169: "INTERNAL_CLASS_TYPE",
-  170: "MAP_TYPE",
+  170: "INTERNAL_CLASS_WITH_STRUCT_ELEMENTS_TYPE",
-  171: "ON_HEAP_BASIC_BLOCK_PROFILER_DATA_TYPE",
+  171: "MAP_TYPE",
-  172: "PREPARSE_DATA_TYPE",
+  172: "ON_HEAP_BASIC_BLOCK_PROFILER_DATA_TYPE",
-  173: "PROPERTY_ARRAY_TYPE",
+  173: "PREPARSE_DATA_TYPE",
-  174: "PROPERTY_CELL_TYPE",
+  174: "PROPERTY_ARRAY_TYPE",
-  175: "SHARED_FUNCTION_INFO_TYPE",
+  175: "PROPERTY_CELL_TYPE",
-  176: "SMI_BOX_TYPE",
+  176: "SHARED_FUNCTION_INFO_TYPE",
-  177: "SMI_PAIR_TYPE",
+  177: "SMI_BOX_TYPE",
-  178: "SORT_STATE_TYPE",
+  178: "SMI_PAIR_TYPE",
-  179: "WASM_ARRAY_TYPE",
+  179: "SORT_STATE_TYPE",
-  180: "WASM_CAPI_FUNCTION_DATA_TYPE",
+  180: "WASM_ARRAY_TYPE",
-  181: "WASM_STRUCT_TYPE",
+  181: "WASM_CAPI_FUNCTION_DATA_TYPE",
-  182: "WEAK_ARRAY_LIST_TYPE",
+  182: "WASM_STRUCT_TYPE",
-  183: "WEAK_CELL_TYPE",
+  183: "WEAK_ARRAY_LIST_TYPE",
-  184: "JS_PROXY_TYPE",
+  184: "WEAK_CELL_TYPE",
+  185: "JS_PROXY_TYPE",
   1057: "JS_OBJECT_TYPE",
-  185: "JS_GLOBAL_OBJECT_TYPE",
+  186: "JS_GLOBAL_OBJECT_TYPE",
-  186: "JS_GLOBAL_PROXY_TYPE",
+  187: "JS_GLOBAL_PROXY_TYPE",
-  187: "JS_MODULE_NAMESPACE_TYPE",
+  188: "JS_MODULE_NAMESPACE_TYPE",
   1040: "JS_SPECIAL_API_OBJECT_TYPE",
   1041: "JS_PRIMITIVE_WRAPPER_TYPE",
   1042: "JS_MAP_KEY_ITERATOR_TYPE",
@@ -206,78 +207,78 @@ INSTANCE_TYPES = {
 
 # List of known V8 maps.
 KNOWN_MAPS = {
-  ("read_only_space", 0x02115): (170, "MetaMap"),
+  ("read_only_space", 0x02115): (171, "MetaMap"),
   ("read_only_space", 0x0213d): (67, "NullMap"),
-  ("read_only_space", 0x02165): (152, "StrongDescriptorArrayMap"),
+  ("read_only_space", 0x02165): (153, "StrongDescriptorArrayMap"),
-  ("read_only_space", 0x0218d): (157, "WeakFixedArrayMap"),
+  ("read_only_space", 0x0218d): (158, "WeakFixedArrayMap"),
   ("read_only_space", 0x021cd): (96, "EnumCacheMap"),
-  ("read_only_space", 0x02201): (116, "FixedArrayMap"),
+  ("read_only_space", 0x02201): (117, "FixedArrayMap"),
   ("read_only_space", 0x0224d): (8, "OneByteInternalizedStringMap"),
-  ("read_only_space", 0x02299): (167, "FreeSpaceMap"),
+  ("read_only_space", 0x02299): (168, "FreeSpaceMap"),
-  ("read_only_space", 0x022c1): (166, "OnePointerFillerMap"),
+  ("read_only_space", 0x022c1): (167, "OnePointerFillerMap"),
-  ("read_only_space", 0x022e9): (166, "TwoPointerFillerMap"),
+  ("read_only_space", 0x022e9): (167, "TwoPointerFillerMap"),
   ("read_only_space", 0x02311): (67, "UninitializedMap"),
   ("read_only_space", 0x02389): (67, "UndefinedMap"),
   ("read_only_space", 0x023cd): (66, "HeapNumberMap"),
   ("read_only_space", 0x02401): (67, "TheHoleMap"),
   ("read_only_space", 0x02461): (67, "BooleanMap"),
-  ("read_only_space", 0x02505): (130, "ByteArrayMap"),
+  ("read_only_space", 0x02505): (131, "ByteArrayMap"),
-  ("read_only_space", 0x0252d): (116, "FixedCOWArrayMap"),
+  ("read_only_space", 0x0252d): (117, "FixedCOWArrayMap"),
-  ("read_only_space", 0x02555): (117, "HashTableMap"),
+  ("read_only_space", 0x02555): (118, "HashTableMap"),
   ("read_only_space", 0x0257d): (64, "SymbolMap"),
   ("read_only_space", 0x025a5): (40, "OneByteStringMap"),
-  ("read_only_space", 0x025cd): (128, "ScopeInfoMap"),
+  ("read_only_space", 0x025cd): (129, "ScopeInfoMap"),
-  ("read_only_space", 0x025f5): (175, "SharedFunctionInfoMap"),
+  ("read_only_space", 0x025f5): (176, "SharedFunctionInfoMap"),
-  ("read_only_space", 0x0261d): (160, "CodeMap"),
+  ("read_only_space", 0x0261d): (161, "CodeMap"),
-  ("read_only_space", 0x02645): (159, "CellMap"),
+  ("read_only_space", 0x02645): (160, "CellMap"),
-  ("read_only_space", 0x0266d): (174, "GlobalPropertyCellMap"),
+  ("read_only_space", 0x0266d): (175, "GlobalPropertyCellMap"),
   ("read_only_space", 0x02695): (70, "ForeignMap"),
-  ("read_only_space", 0x026bd): (158, "TransitionArrayMap"),
+  ("read_only_space", 0x026bd): (159, "TransitionArrayMap"),
   ("read_only_space", 0x026e5): (45, "ThinOneByteStringMap"),
-  ("read_only_space", 0x0270d): (165, "FeedbackVectorMap"),
+  ("read_only_space", 0x0270d): (166, "FeedbackVectorMap"),
   ("read_only_space", 0x0273d): (67, "ArgumentsMarkerMap"),
   ("read_only_space", 0x0279d): (67, "ExceptionMap"),
   ("read_only_space", 0x027f9): (67, "TerminationExceptionMap"),
   ("read_only_space", 0x02861): (67, "OptimizedOutMap"),
   ("read_only_space", 0x028c1): (67, "StaleRegisterMap"),
-  ("read_only_space", 0x02921): (129, "ScriptContextTableMap"),
+  ("read_only_space", 0x02921): (130, "ScriptContextTableMap"),
-  ("read_only_space", 0x02949): (126, "ClosureFeedbackCellArrayMap"),
+  ("read_only_space", 0x02949): (127, "ClosureFeedbackCellArrayMap"),
-  ("read_only_space", 0x02971): (164, "FeedbackMetadataArrayMap"),
+  ("read_only_space", 0x02971): (165, "FeedbackMetadataArrayMap"),
-  ("read_only_space", 0x02999): (116, "ArrayListMap"),
+  ("read_only_space", 0x02999): (117, "ArrayListMap"),
   ("read_only_space", 0x029c1): (65, "BigIntMap"),
-  ("read_only_space", 0x029e9): (127, "ObjectBoilerplateDescriptionMap"),
+  ("read_only_space", 0x029e9): (128, "ObjectBoilerplateDescriptionMap"),
-  ("read_only_space", 0x02a11): (131, "BytecodeArrayMap"),
+  ("read_only_space", 0x02a11): (132, "BytecodeArrayMap"),
-  ("read_only_space", 0x02a39): (161, "CodeDataContainerMap"),
+  ("read_only_space", 0x02a39): (162, "CodeDataContainerMap"),
-  ("read_only_space", 0x02a61): (162, "CoverageInfoMap"),
+  ("read_only_space", 0x02a61): (163, "CoverageInfoMap"),
-  ("read_only_space", 0x02a89): (132, "FixedDoubleArrayMap"),
+  ("read_only_space", 0x02a89): (133, "FixedDoubleArrayMap"),
-  ("read_only_space", 0x02ab1): (119, "GlobalDictionaryMap"),
+  ("read_only_space", 0x02ab1): (120, "GlobalDictionaryMap"),
   ("read_only_space", 0x02ad9): (97, "ManyClosuresCellMap"),
-  ("read_only_space", 0x02b01): (116, "ModuleInfoMap"),
+  ("read_only_space", 0x02b01): (117, "ModuleInfoMap"),
-  ("read_only_space", 0x02b29): (120, "NameDictionaryMap"),
+  ("read_only_space", 0x02b29): (121, "NameDictionaryMap"),
   ("read_only_space", 0x02b51): (97, "NoClosuresCellMap"),
-  ("read_only_space", 0x02b79): (121, "NumberDictionaryMap"),
+  ("read_only_space", 0x02b79): (122, "NumberDictionaryMap"),
   ("read_only_space", 0x02ba1): (97, "OneClosureCellMap"),
-  ("read_only_space", 0x02bc9): (122, "OrderedHashMapMap"),
+  ("read_only_space", 0x02bc9): (123, "OrderedHashMapMap"),
-  ("read_only_space", 0x02bf1): (123, "OrderedHashSetMap"),
+  ("read_only_space", 0x02bf1): (124, "OrderedHashSetMap"),
-  ("read_only_space", 0x02c19): (124, "OrderedNameDictionaryMap"),
+  ("read_only_space", 0x02c19): (125, "OrderedNameDictionaryMap"),
-  ("read_only_space", 0x02c41): (172, "PreparseDataMap"),
+  ("read_only_space", 0x02c41): (173, "PreparseDataMap"),
-  ("read_only_space", 0x02c69): (173, "PropertyArrayMap"),
+  ("read_only_space", 0x02c69): (174, "PropertyArrayMap"),
   ("read_only_space", 0x02c91): (93, "SideEffectCallHandlerInfoMap"),
   ("read_only_space", 0x02cb9): (93, "SideEffectFreeCallHandlerInfoMap"),
   ("read_only_space", 0x02ce1): (93, "NextCallSideEffectFreeCallHandlerInfoMap"),
-  ("read_only_space", 0x02d09): (125, "SimpleNumberDictionaryMap"),
+  ("read_only_space", 0x02d09): (126, "SimpleNumberDictionaryMap"),
-  ("read_only_space", 0x02d31): (148, "SmallOrderedHashMapMap"),
+  ("read_only_space", 0x02d31): (149, "SmallOrderedHashMapMap"),
-  ("read_only_space", 0x02d59): (149, "SmallOrderedHashSetMap"),
+  ("read_only_space", 0x02d59): (150, "SmallOrderedHashSetMap"),
-  ("read_only_space", 0x02d81): (150, "SmallOrderedNameDictionaryMap"),
+  ("read_only_space", 0x02d81): (151, "SmallOrderedNameDictionaryMap"),
-  ("read_only_space", 0x02da9): (153, "SourceTextModuleMap"),
+  ("read_only_space", 0x02da9): (154, "SourceTextModuleMap"),
-  ("read_only_space", 0x02dd1): (154, "SyntheticModuleMap"),
+  ("read_only_space", 0x02dd1): (155, "SyntheticModuleMap"),
-  ("read_only_space", 0x02df9): (156, "UncompiledDataWithoutPreparseDataMap"),
+  ("read_only_space", 0x02df9): (157, "UncompiledDataWithoutPreparseDataMap"),
-  ("read_only_space", 0x02e21): (155, "UncompiledDataWithPreparseDataMap"),
+  ("read_only_space", 0x02e21): (156, "UncompiledDataWithPreparseDataMap"),
   ("read_only_space", 0x02e49): (71, "WasmTypeInfoMap"),
-  ("read_only_space", 0x02e71): (182, "WeakArrayListMap"),
+  ("read_only_space", 0x02e71): (183, "WeakArrayListMap"),
-  ("read_only_space", 0x02e99): (118, "EphemeronHashTableMap"),
+  ("read_only_space", 0x02e99): (119, "EphemeronHashTableMap"),
-  ("read_only_space", 0x02ec1): (163, "EmbedderDataArrayMap"),
+  ("read_only_space", 0x02ec1): (164, "EmbedderDataArrayMap"),
-  ("read_only_space", 0x02ee9): (183, "WeakCellMap"),
+  ("read_only_space", 0x02ee9): (184, "WeakCellMap"),
   ("read_only_space", 0x02f11): (32, "StringMap"),
   ("read_only_space", 0x02f39): (41, "ConsOneByteStringMap"),
   ("read_only_space", 0x02f61): (33, "ConsStringMap"),
@@ -318,51 +319,52 @@ KNOWN_MAPS = {
   ("read_only_space", 0x05699): (95, "DebugInfoMap"),
   ("read_only_space", 0x056c1): (98, "FunctionTemplateRareDataMap"),
   ("read_only_space", 0x056e9): (100, "InterpreterDataMap"),
-  ("read_only_space", 0x05711): (101, "PromiseCapabilityMap"),
+  ("read_only_space", 0x05711): (101, "ModuleRequestMap"),
-  ("read_only_space", 0x05739): (102, "PromiseReactionMap"),
+  ("read_only_space", 0x05739): (102, "PromiseCapabilityMap"),
-  ("read_only_space", 0x05761): (103, "PropertyDescriptorObjectMap"),
+  ("read_only_space", 0x05761): (103, "PromiseReactionMap"),
-  ("read_only_space", 0x05789): (104, "PrototypeInfoMap"),
+  ("read_only_space", 0x05789): (104, "PropertyDescriptorObjectMap"),
-  ("read_only_space", 0x057b1): (105, "ScriptMap"),
+  ("read_only_space", 0x057b1): (105, "PrototypeInfoMap"),
-  ("read_only_space", 0x057d9): (106, "SourceTextModuleInfoEntryMap"),
+  ("read_only_space", 0x057d9): (106, "ScriptMap"),
-  ("read_only_space", 0x05801): (107, "StackFrameInfoMap"),
+  ("read_only_space", 0x05801): (107, "SourceTextModuleInfoEntryMap"),
-  ("read_only_space", 0x05829): (108, "StackTraceFrameMap"),
+  ("read_only_space", 0x05829): (108, "StackFrameInfoMap"),
-  ("read_only_space", 0x05851): (109, "TemplateObjectDescriptionMap"),
+  ("read_only_space", 0x05851): (109, "StackTraceFrameMap"),
-  ("read_only_space", 0x05879): (110, "Tuple2Map"),
+  ("read_only_space", 0x05879): (110, "TemplateObjectDescriptionMap"),
-  ("read_only_space", 0x058a1): (111, "WasmExceptionTagMap"),
+  ("read_only_space", 0x058a1): (111, "Tuple2Map"),
-  ("read_only_space", 0x058c9): (112, "WasmExportedFunctionDataMap"),
+  ("read_only_space", 0x058c9): (112, "WasmExceptionTagMap"),
-  ("read_only_space", 0x058f1): (113, "WasmIndirectFunctionTableMap"),
+  ("read_only_space", 0x058f1): (113, "WasmExportedFunctionDataMap"),
-  ("read_only_space", 0x05919): (114, "WasmJSFunctionDataMap"),
+  ("read_only_space", 0x05919): (114, "WasmIndirectFunctionTableMap"),
-  ("read_only_space", 0x05941): (115, "WasmValueMap"),
+  ("read_only_space", 0x05941): (115, "WasmJSFunctionDataMap"),
-  ("read_only_space", 0x05969): (134, "SloppyArgumentsElementsMap"),
+  ("read_only_space", 0x05969): (116, "WasmValueMap"),
-  ("read_only_space", 0x05991): (151, "DescriptorArrayMap"),
+  ("read_only_space", 0x05991): (135, "SloppyArgumentsElementsMap"),
-  ("read_only_space", 0x059b9): (171, "OnHeapBasicBlockProfilerDataMap"),
+  ("read_only_space", 0x059b9): (152, "DescriptorArrayMap"),
-  ("read_only_space", 0x059e1): (180, "WasmCapiFunctionDataMap"),
+  ("read_only_space", 0x059e1): (172, "OnHeapBasicBlockProfilerDataMap"),
-  ("read_only_space", 0x05a09): (168, "InternalClassMap"),
+  ("read_only_space", 0x05a09): (181, "WasmCapiFunctionDataMap"),
-  ("read_only_space", 0x05a31): (177, "SmiPairMap"),
+  ("read_only_space", 0x05a31): (169, "InternalClassMap"),
-  ("read_only_space", 0x05a59): (176, "SmiBoxMap"),
+  ("read_only_space", 0x05a59): (178, "SmiPairMap"),
-  ("read_only_space", 0x05a81): (145, "ExportedSubClassBaseMap"),
+  ("read_only_space", 0x05a81): (177, "SmiBoxMap"),
-  ("read_only_space", 0x05aa9): (146, "ExportedSubClassMap"),
+  ("read_only_space", 0x05aa9): (146, "ExportedSubClassBaseMap"),
-  ("read_only_space", 0x05ad1): (68, "AbstractInternalClassSubclass1Map"),
+  ("read_only_space", 0x05ad1): (147, "ExportedSubClassMap"),
-  ("read_only_space", 0x05af9): (69, "AbstractInternalClassSubclass2Map"),
+  ("read_only_space", 0x05af9): (68, "AbstractInternalClassSubclass1Map"),
-  ("read_only_space", 0x05b21): (133, "InternalClassWithSmiElementsMap"),
+  ("read_only_space", 0x05b21): (69, "AbstractInternalClassSubclass2Map"),
-  ("read_only_space", 0x05b49): (169, "InternalClassWithStructElementsMap"),
+  ("read_only_space", 0x05b49): (134, "InternalClassWithSmiElementsMap"),
-  ("read_only_space", 0x05b71): (147, "ExportedSubClass2Map"),
+  ("read_only_space", 0x05b71): (170, "InternalClassWithStructElementsMap"),
-  ("read_only_space", 0x05b99): (178, "SortStateMap"),
+  ("read_only_space", 0x05b99): (148, "ExportedSubClass2Map"),
-  ("read_only_space", 0x05bc1): (86, "AllocationSiteWithWeakNextMap"),
+  ("read_only_space", 0x05bc1): (179, "SortStateMap"),
-  ("read_only_space", 0x05be9): (86, "AllocationSiteWithoutWeakNextMap"),
+  ("read_only_space", 0x05be9): (86, "AllocationSiteWithWeakNextMap"),
-  ("read_only_space", 0x05c11): (77, "LoadHandler1Map"),
+  ("read_only_space", 0x05c11): (86, "AllocationSiteWithoutWeakNextMap"),
-  ("read_only_space", 0x05c39): (77, "LoadHandler2Map"),
+  ("read_only_space", 0x05c39): (77, "LoadHandler1Map"),
-  ("read_only_space", 0x05c61): (77, "LoadHandler3Map"),
+  ("read_only_space", 0x05c61): (77, "LoadHandler2Map"),
-  ("read_only_space", 0x05c89): (78, "StoreHandler0Map"),
+  ("read_only_space", 0x05c89): (77, "LoadHandler3Map"),
-  ("read_only_space", 0x05cb1): (78, "StoreHandler1Map"),
+  ("read_only_space", 0x05cb1): (78, "StoreHandler0Map"),
-  ("read_only_space", 0x05cd9): (78, "StoreHandler2Map"),
+  ("read_only_space", 0x05cd9): (78, "StoreHandler1Map"),
-  ("read_only_space", 0x05d01): (78, "StoreHandler3Map"),
+  ("read_only_space", 0x05d01): (78, "StoreHandler2Map"),
+  ("read_only_space", 0x05d29): (78, "StoreHandler3Map"),
   ("map_space", 0x02115): (1057, "ExternalMap"),
   ("map_space", 0x0213d): (1072, "JSMessageObjectMap"),
-  ("map_space", 0x02165): (181, "WasmRttEqrefMap"),
+  ("map_space", 0x02165): (182, "WasmRttEqrefMap"),
-  ("map_space", 0x0218d): (181, "WasmRttExternrefMap"),
+  ("map_space", 0x0218d): (182, "WasmRttExternrefMap"),
-  ("map_space", 0x021b5): (181, "WasmRttFuncrefMap"),
+  ("map_space", 0x021b5): (182, "WasmRttFuncrefMap"),
-  ("map_space", 0x021dd): (181, "WasmRttI31refMap"),
+  ("map_space", 0x021dd): (182, "WasmRttI31refMap"),
 }
 
 # List of known V8 objects.