[modules] Add partial support for debug-scopes.

src/ast/scopeinfo.cc

 // Copyright 2011 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 <stdlib.h>
 
 #include "src/ast/context-slot-cache.h"
 #include "src/ast/scopes.h"
 #include "src/ast/variables.h"
 #include "src/bootstrapper.h"
@@ skipping 629 matching lines @@
   DCHECK_EQ(scope_type(), MODULE_SCOPE);
   DCHECK(name->IsInternalizedString());
   DCHECK_NOT_NULL(mode);
   DCHECK_NOT_NULL(init_flag);
   DCHECK_NOT_NULL(maybe_assigned_flag);
 
   int module_vars_count = Smi::cast(get(ModuleVariableCountIndex()))->value();
   int entry = ModuleVariablesIndex();
   for (int i = 0; i < module_vars_count; ++i) {
     if (*name == get(entry + kModuleVariableNameOffset)) {
-      int index = Smi::cast(get(entry + kModuleVariableIndexOffset))->value();
-      int properties =
-          Smi::cast(get(entry + kModuleVariablePropertiesOffset))->value();
-      *mode = VariableModeField::decode(properties);
-      *init_flag = InitFlagField::decode(properties);
-      *maybe_assigned_flag = MaybeAssignedFlagField::decode(properties);
+      int index;
+      ModuleVariable(i, nullptr, &index, mode, init_flag, maybe_assigned_flag);
       return index;
     }
     entry += kModuleVariableEntryLength;
   }
 
   return -1;
 }
 
 int ScopeInfo::ContextSlotIndex(Handle<ScopeInfo> scope_info,
                                 Handle<String> name, VariableMode* mode,
@@ skipping 121 matching lines @@
 }
 
 int ScopeInfo::ModuleInfoIndex() {
   return OuterScopeInfoIndex() + (HasOuterScopeInfo() ? 1 : 0);
 }
 
 int ScopeInfo::ModuleVariableCountIndex() { return ModuleInfoIndex() + 1; }
 
 int ScopeInfo::ModuleVariablesIndex() { return ModuleVariableCountIndex() + 1; }
 
+void ScopeInfo::ModuleVariable(int i, String** name, int* index,
+                               VariableMode* mode,
+                               InitializationFlag* init_flag,
+                               MaybeAssignedFlag* maybe_assigned_flag) {
+  DCHECK_LE(0, i);
+  DCHECK_LT(i, Smi::cast(get(ModuleVariableCountIndex()))->value());
+
+  int entry = ModuleVariablesIndex() + i * kModuleVariableEntryLength;
+  int properties =
+      Smi::cast(get(entry + kModuleVariablePropertiesOffset))->value();
+
+  if (name != nullptr) {
+    *name = String::cast(get(entry + kModuleVariableNameOffset));
+  }
+  if (index != nullptr) {
+    *index = Smi::cast(get(entry + kModuleVariableIndexOffset))->value();
+  }
+  if (mode != nullptr) {
+    *mode = VariableModeField::decode(properties);
+  }
+  if (init_flag != nullptr) {
+    *init_flag = InitFlagField::decode(properties);
+  }
+  if (maybe_assigned_flag != nullptr) {
+    *maybe_assigned_flag = MaybeAssignedFlagField::decode(properties);
+  }
+}
+
 #ifdef DEBUG
 
 static void PrintList(const char* list_name,
                       int nof_internal_slots,
                       int start,
                       int end,
                       ScopeInfo* scope_info) {
   if (start < end) {
     PrintF("\n  // %s\n", list_name);
     if (nof_internal_slots > 0) {
@@ skipping 53 matching lines @@
   for (const auto& elem : descr->module_requests()) {
     module_requests->set(elem.second, *elem.first->string());
   }
 
   // Serialize special exports.
   Handle<FixedArray> special_exports =
       isolate->factory()->NewFixedArray(descr->special_exports().length());
   {
     int i = 0;
     for (auto entry : descr->special_exports()) {
-      special_exports->set(i++, *entry->Serialize(isolate));
+      Handle<ModuleInfoEntry> serialized_entry = entry->Serialize(isolate);
+      special_exports->set(i++, *serialized_entry);
     }
   }
 
   // Serialize namespace imports.
   Handle<FixedArray> namespace_imports =
       isolate->factory()->NewFixedArray(descr->namespace_imports().length());
   {
     int i = 0;
     for (auto entry : descr->namespace_imports()) {
-      namespace_imports->set(i++, *entry->Serialize(isolate));
+      Handle<ModuleInfoEntry> serialized_entry = entry->Serialize(isolate);
+      namespace_imports->set(i++, *serialized_entry);
     }
   }
 
   // Serialize regular exports.
   Handle<FixedArray> regular_exports =
       descr->SerializeRegularExports(isolate, zone);
 
   // Serialize regular imports.
   Handle<FixedArray> regular_imports = isolate->factory()->NewFixedArray(
       static_cast<int>(descr->regular_imports().size()));
   {
     int i = 0;
     for (const auto& elem : descr->regular_imports()) {
-      regular_imports->set(i++, *elem.second->Serialize(isolate));
+      Handle<ModuleInfoEntry> serialized_entry =
+          elem.second->Serialize(isolate);
+      regular_imports->set(i++, *serialized_entry);
     }
   }
 
   Handle<ModuleInfo> result = isolate->factory()->NewModuleInfo();
   result->set(kModuleRequestsIndex, *module_requests);
   result->set(kSpecialExportsIndex, *special_exports);
   result->set(kRegularExportsIndex, *regular_exports);
   result->set(kNamespaceImportsIndex, *namespace_imports);
   result->set(kRegularImportsIndex, *regular_imports);
   return result;
 }
 
+Handle<ModuleInfoEntry> ModuleInfo::LookupRegularImport(
+    Handle<ModuleInfo> info, Handle<String> local_name) {
+  Isolate* isolate = info->GetIsolate();
+  Handle<FixedArray> regular_imports(info->regular_imports(), isolate);
+  for (int i = 0, n = regular_imports->length(); i < n; ++i) {
+    Handle<ModuleInfoEntry> entry(
+        ModuleInfoEntry::cast(regular_imports->get(i)), isolate);
+    if (String::cast(entry->local_name())->Equals(*local_name)) {
+      return entry;
+    }
+  }
+  UNREACHABLE();
+  return Handle<ModuleInfoEntry>();
+}
+
 }  // namespace internal
 }  // namespace v8