[modules] Basic support of exports

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 499 matching lines @@
   return String::cast(get(FunctionNameInfoIndex()));
 }
 
 ScopeInfo* ScopeInfo::OuterScopeInfo() {
   DCHECK(HasOuterScopeInfo());
   return ScopeInfo::cast(get(OuterScopeInfoIndex()));
 }
 
 ModuleInfo* ScopeInfo::ModuleDescriptorInfo() {
   DCHECK(scope_type() == MODULE_SCOPE);
-  return static_cast<ModuleInfo*>(get(ModuleInfoIndex()));
+  return ModuleInfo::cast(get(ModuleInfoIndex()));
 }
 
 String* ScopeInfo::ParameterName(int var) {
   DCHECK_LE(0, var);
   DCHECK_LT(var, ParameterCount());
   int info_index = ParameterNamesIndex() + var;
   return String::cast(get(info_index));
 }
 
 
@@ skipping 273 matching lines @@
   PrintF("{");
 
   if (length() > 0) {
     PrintList("parameters", 0, ParameterNamesIndex(),
               ParameterNamesIndex() + ParameterCount(), this);
     PrintList("stack slots", 0, StackLocalNamesIndex(),
               StackLocalNamesIndex() + StackLocalCount(), this);
     PrintList("context slots", Context::MIN_CONTEXT_SLOTS,
               ContextLocalNamesIndex(),
               ContextLocalNamesIndex() + ContextLocalCount(), this);
+    // TODO(neis): Print module stuff if present.
   }
 
   PrintF("}\n");
 }
 #endif  // DEBUG
 
+Handle<ModuleInfoEntry> ModuleInfoEntry::New(Isolate* isolate,
+                                             Handle<Object> export_name,
+                                             Handle<Object> local_name,
+                                             Handle<Object> import_name,
+                                             Handle<Object> module_request) {
+  Handle<ModuleInfoEntry> result = isolate->factory()->NewModuleInfoEntry();
+  result->set(kExportNameIndex, *export_name);
+  result->set(kLocalNameIndex, *local_name);
+  result->set(kImportNameIndex, *import_name);
+  result->set(kModuleRequestIndex, *module_request);
+  return result;
+}
+
 Handle<ModuleInfo> ModuleInfo::New(Isolate* isolate, ModuleDescriptor* descr) {
   // 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));
     }
   }
 
   // Serialize regular exports.
   Handle<FixedArray> regular_exports = isolate->factory()->NewFixedArray(
       static_cast<int>(descr->regular_exports().size()));
   {
     int i = 0;
     for (const auto& it : descr->regular_exports()) {
       regular_exports->set(i++, *it.second->Serialize(isolate));
     }
   }
 
   Handle<ModuleInfo> result = isolate->factory()->NewModuleInfo();
   result->set(kSpecialExportsIndex, *special_exports);
   result->set(kRegularExportsIndex, *regular_exports);
   return result;
 }
 
 }  // namespace internal
 }  // namespace v8