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

src/api.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/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 1931 matching lines @@
              .ToLocal(&import)) {
       // TODO(adamk): Throw an exception.
       return false;
     }
     if (!import->Instantiate(v8_context, callback, callback_data)) {
       return false;
     }
     self->requested_modules()->set(i, *Utils::OpenHandle(*import));
   }
 
-  // TODO(neis): This will create multiple cells for the same local variable if
-  // exported under multiple names, which is wrong but cannot be observed at the
-  // moment. This will be fixed by doing the full-fledged linking here once we
-  // get there.
+  // Set up local exports.
   i::Handle<i::FixedArray> regular_exports = i::handle(
       shared->scope_info()->ModuleDescriptorInfo()->regular_exports(), isolate);
-  for (int i = 0, length = regular_exports->length(); i < length; ++i) {
-    i::Handle<i::ModuleInfoEntry> entry =
-        i::handle(i::ModuleInfoEntry::cast(regular_exports->get(i)), isolate);
-    DCHECK(entry->import_name()->IsUndefined(isolate));
-    i::Handle<i::String> export_name =
-        handle(i::String::cast(entry->export_name()), isolate);
-    i::Module::CreateExport(self, export_name);
+  for (int i = 0, n = regular_exports->length(); i < n; i += 2) {
+    i::Handle<i::FixedArray> export_names(
+        i::FixedArray::cast(regular_exports->get(i + 1)), isolate);
+    i::Module::CreateExport(self, export_names);
   }
 
   return true;
 }
 
 MaybeLocal<Value> Module::Evaluate(Local<Context> context) {
   PREPARE_FOR_EXECUTION_WITH_CONTEXT_IN_RUNTIME_CALL_STATS_SCOPE(
       "v8", "V8.Execute", context, Script, Run, MaybeLocal<Value>(),
       InternalEscapableScope, true);
   i::HistogramTimerScope execute_timer(isolate->counters()->execute(), true);
@@ skipping 142 matching lines @@
 
 MaybeLocal<Module> ScriptCompiler::CompileModule(Isolate* isolate,
                                                  Source* source) {
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
 
   auto maybe = CompileUnboundInternal(isolate, source, kNoCompileOptions, true);
   Local<UnboundScript> unbound;
   if (!maybe.ToLocal(&unbound)) return MaybeLocal<Module>();
 
   i::Handle<i::SharedFunctionInfo> shared = Utils::OpenHandle(*unbound);
-  i::Handle<i::Module> module = i_isolate->factory()->NewModule(shared);
-  return ToApiHandle<Module>(module);
+  return ToApiHandle<Module>(i_isolate->factory()->NewModule(shared));
 }
 
 
 class IsIdentifierHelper {
  public:
   IsIdentifierHelper() : is_identifier_(false), first_char_(true) {}
 
   bool Check(i::String* string) {
     i::ConsString* cons_string = i::String::VisitFlat(this, string, 0);
     if (cons_string == NULL) return is_identifier_;
@@ skipping 7288 matching lines @@
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 }  // namespace internal
 }  // namespace v8