[modules] Support exporting a local variable under multiple export names.

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 254 matching lines @@
 
   // If present, add the outer scope info.
   DCHECK(index == scope_info->OuterScopeInfoIndex());
   if (has_outer_scope_info) {
     scope_info->set(index++, *outer_scope.ToHandleChecked());
   }
 
   // Module-specific information (only for module scopes).
   if (scope->is_module_scope()) {
     Handle<ModuleInfo> module_info =
-        ModuleInfo::New(isolate, scope->AsModuleScope()->module());
+        ModuleInfo::New(isolate, zone, scope->AsModuleScope()->module());
     DCHECK_EQ(index, scope_info->ModuleInfoIndex());
     scope_info->set(index++, *module_info);
     DCHECK_EQ(index, scope_info->ModuleVariableCountIndex());
     scope_info->set(index++, Smi::FromInt(module_vars_count));
     DCHECK_EQ(index, scope_info->ModuleVariablesIndex());
     // The variable entries themselves have already been written above.
     index += kModuleVariableEntryLength * module_vars_count;
   }
 
   DCHECK_EQ(index, scope_info->length());
@@ skipping 559 matching lines @@
                                              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) {
+Handle<ModuleInfo> ModuleInfo::New(Isolate* isolate, Zone* zone,
+                                   ModuleDescriptor* descr) {
   // Serialize module requests.
   Handle<FixedArray> module_requests = isolate->factory()->NewFixedArray(
       static_cast<int>(descr->module_requests().size()));
   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));
     }
   }
 
   // Serialize special imports.
   Handle<FixedArray> special_imports =
       isolate->factory()->NewFixedArray(descr->special_imports().length());
   {
     int i = 0;
     for (auto entry : descr->special_imports()) {
       special_imports->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& elem : descr->regular_exports()) {
-      regular_exports->set(i++, *elem.second->Serialize(isolate));
-    }
-  }
+  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<ModuleInfo> result = isolate->factory()->NewModuleInfo();
   result->set(kModuleRequestsIndex, *module_requests);
   result->set(kSpecialExportsIndex, *special_exports);
   result->set(kRegularExportsIndex, *regular_exports);
   result->set(kSpecialImportsIndex, *special_imports);
   result->set(kRegularImportsIndex, *regular_imports);
   return result;
 }
 
 }  // namespace internal
 }  // namespace v8