[modules] Partial support for (de-)serializing module descriptor entries.

src/ast/modules.cc

 // Copyright 2012 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/ast/modules.h"
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/scopes.h"
 
 namespace v8 {
 namespace internal {
 
 void ModuleDescriptor::AddImport(
     const AstRawString* import_name, const AstRawString* local_name,
     const AstRawString* module_request, Scanner::Location loc, Zone* zone) {
-  DCHECK_NOT_NULL(import_name);
-  DCHECK_NOT_NULL(local_name);
-  DCHECK_NOT_NULL(module_request);
   Entry* entry = new (zone) Entry(loc);
   entry->local_name = local_name;
   entry->import_name = import_name;
   entry->module_request = module_request;
-  regular_imports_.insert(std::make_pair(entry->local_name, entry));
-  // We don't care if there's already an entry for this local name, as in that
-  // case we will report an error when declaring the variable.
+  AddRegularImport(entry);
 }
 
 
 void ModuleDescriptor::AddStarImport(
     const AstRawString* local_name, const AstRawString* module_request,
     Scanner::Location loc, Zone* zone) {
   DCHECK_NOT_NULL(local_name);
   DCHECK_NOT_NULL(module_request);
   Entry* entry = new (zone) Entry(loc);
   entry->local_name = local_name;
   entry->module_request = module_request;
-  special_imports_.Add(entry, zone);
+  AddSpecialImport(entry, zone);
 }
 
 
 void ModuleDescriptor::AddEmptyImport(
     const AstRawString* module_request, Scanner::Location loc, Zone* zone) {
-  DCHECK_NOT_NULL(module_request);
   Entry* entry = new (zone) Entry(loc);
   entry->module_request = module_request;
-  special_imports_.Add(entry, zone);
+  AddSpecialImport(entry, zone);
 }
 
 
 void ModuleDescriptor::AddExport(
     const AstRawString* local_name, const AstRawString* export_name,
     Scanner::Location loc, Zone* zone) {
-  DCHECK_NOT_NULL(local_name);
-  DCHECK_NOT_NULL(export_name);
   Entry* entry = new (zone) Entry(loc);
   entry->export_name = export_name;
   entry->local_name = local_name;
-  regular_exports_.insert(std::make_pair(entry->local_name, entry));
+  AddRegularExport(entry);
 }
 
 
 void ModuleDescriptor::AddExport(
     const AstRawString* import_name, const AstRawString* export_name,
     const AstRawString* module_request, Scanner::Location loc, Zone* zone) {
   DCHECK_NOT_NULL(import_name);
   DCHECK_NOT_NULL(export_name);
-  DCHECK_NOT_NULL(module_request);
   Entry* entry = new (zone) Entry(loc);
   entry->export_name = export_name;
   entry->import_name = import_name;
   entry->module_request = module_request;
-  special_exports_.Add(entry, zone);
+  AddSpecialExport(entry, zone);
 }
 
 
 void ModuleDescriptor::AddStarExport(
     const AstRawString* module_request, Scanner::Location loc, Zone* zone) {
-  DCHECK_NOT_NULL(module_request);
   Entry* entry = new (zone) Entry(loc);
   entry->module_request = module_request;
-  special_exports_.Add(entry, zone);
+  AddSpecialExport(entry, zone);
+}
+
+namespace {
+
+Handle<Object> ToStringOrUndefined(Isolate* isolate, const AstRawString* s) {
+  return (s == nullptr)
+             ? Handle<Object>::cast(isolate->factory()->undefined_value())
+             : Handle<Object>::cast(s->string());
+}
+
+const AstRawString* FromStringOrUndefined(Isolate* isolate,
+                                          AstValueFactory* avfactory,
+                                          Handle<Object> object) {
+  if (object->IsUndefined(isolate)) return nullptr;
+  return avfactory->GetString(Handle<String>::cast(object));
+}
+
+}  // namespace
+
+Handle<FixedArray> ModuleDescriptor::Entry::Serialize(Isolate* isolate) const {
+  Handle<FixedArray> result = isolate->factory()->NewFixedArray(4);

[adamk, 2016/08/25 15:56:19]

Do you plan to always used a FixedArray for this or is this just temporary?

[neis, 2016/08/26 07:28:03]

I don't mind using something else when I see the need.

+  result->set(0, *ToStringOrUndefined(isolate, export_name));
+  result->set(1, *ToStringOrUndefined(isolate, local_name));
+  result->set(2, *ToStringOrUndefined(isolate, import_name));
+  result->set(3, *ToStringOrUndefined(isolate, module_request));
+  return result;
+}
+
+ModuleDescriptor::Entry* ModuleDescriptor::Entry::Deserialize(
+    Isolate* isolate, AstValueFactory* avfactory, Handle<FixedArray> data) {
+  Entry* entry = new (avfactory->zone()) Entry(Scanner::Location::invalid());
+  entry->export_name =
+      FromStringOrUndefined(isolate, avfactory, handle(data->get(0), isolate));
+  entry->local_name =
+      FromStringOrUndefined(isolate, avfactory, handle(data->get(1), isolate));
+  entry->import_name =
+      FromStringOrUndefined(isolate, avfactory, handle(data->get(2), isolate));
+  entry->module_request =
+      FromStringOrUndefined(isolate, avfactory, handle(data->get(3), isolate));
+  return entry;
 }
 
 void ModuleDescriptor::MakeIndirectExportsExplicit(Zone* zone) {
   for (auto it = regular_exports_.begin(); it != regular_exports_.end();) {
     Entry* entry = it->second;
     DCHECK_NOT_NULL(entry->local_name);
     auto import = regular_imports_.find(entry->local_name);
     if (import != regular_imports_.end()) {
       // Found an indirect export.  Patch export entry and move it from regular
       // to special.
@@ skipping 55 matching lines @@
       return false;
     }
   }
 
   MakeIndirectExportsExplicit(zone);
   return true;
 }
 
 }  // namespace internal
 }  // namespace v8