[modules] Make duplicate export error deterministic.

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 {
@@ skipping 116 matching lines @@
       entry->module_request = import->second->module_request;
       entry->local_name = nullptr;
       special_exports_.Add(entry, zone);
       it = regular_exports_.erase(it);
     } else {
       it++;
     }
   }
 }
 
+namespace {
+
+const ModuleDescriptor::Entry* BetterDuplicate(
+    const ModuleDescriptor::Entry* candidate,
+    ZoneMap<const AstRawString*, const ModuleDescriptor::Entry*>& export_names,
+    const ModuleDescriptor::Entry* current_duplicate) {
+  DCHECK_NOT_NULL(candidate->export_name);
+  DCHECK(candidate->location.IsValid());
+  auto insert_result =
+      export_names.insert(std::make_pair(candidate->export_name, candidate));
+  if (insert_result.second) return current_duplicate;
+  if (current_duplicate == nullptr) {
+    current_duplicate = insert_result.first->second;
+  }
+  return (candidate->location.beg_pos > current_duplicate->location.beg_pos)
+             ? candidate
+             : current_duplicate;
+}
+
+}  // namespace
+
 const ModuleDescriptor::Entry* ModuleDescriptor::FindDuplicateExport(
     Zone* zone) const {
-  ZoneSet<const AstRawString*> export_names(zone);
+  const ModuleDescriptor::Entry* duplicate = nullptr;
+  ZoneMap<const AstRawString*, const ModuleDescriptor::Entry*> export_names(
+      zone);
   for (const auto& it : regular_exports_) {
-    const Entry* entry = it.second;
-    DCHECK_NOT_NULL(entry->export_name);
-    if (!export_names.insert(entry->export_name).second) return entry;
+    duplicate = BetterDuplicate(it.second, export_names, duplicate);
   }
   for (auto entry : special_exports_) {
     if (entry->export_name == nullptr) continue;  // Star export.
-    if (!export_names.insert(entry->export_name).second) return entry;
+    duplicate = BetterDuplicate(entry, export_names, duplicate);
   }
-  return nullptr;
+  return duplicate;
 }
 
 bool ModuleDescriptor::Validate(ModuleScope* module_scope,
                                 PendingCompilationErrorHandler* error_handler,
                                 Zone* zone) {
   DCHECK_EQ(this, module_scope->module());
   DCHECK_NOT_NULL(error_handler);
 
   // Report error iff there are duplicate exports.
   {
@@ skipping 17 matching lines @@
       return false;
     }
   }
 
   MakeIndirectExportsExplicit(zone);
   return true;
 }
 
 }  // namespace internal
 }  // namespace v8