Update handling of exports.

sdk/lib/_internal/compiler/implementation/library_loader.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart2js;
 
 /**
  * [CompilerTask] for loading libraries and setting up the import/export scopes.
  *
  * The library loader uses four different kinds of URIs in different parts of
@@ skipping 551 matching lines @@
     }
   }
 }
 
 /**
  * The combinator filter computed from an export tag and the library dependency
  * node for the library that declared the export tag. This represents an edge in
  * the library dependency graph.
  */
 class ExportLink {
+  final Export export;
   final CombinatorFilter combinatorFilter;
   final LibraryDependencyNode exportNode;
 
   ExportLink(Export export, LibraryDependencyNode this.exportNode)
-      : this.combinatorFilter = new CombinatorFilter.fromTag(export);
+      : this.export = export,
+        this.combinatorFilter = new CombinatorFilter.fromTag(export);
 
   /**
    * Exports [element] to the dependent library unless [element] is filtered by
    * the export combinators. Returns [:true:] if the set pending exports of the
    * dependent library was modified.
    */
   bool exportElement(Element element) {
     if (combinatorFilter.exclude(element)) return false;
-    return exportNode.addElementToPendingExports(element);
+    return exportNode.addElementToPendingExports(element, export);
   }
 }
 
 /**
  * A node in the library dependency graph.
  *
  * This class is used to collect the library dependencies expressed through
  * import and export tags, and as the work-list entry in computations of library
  * exports performed in [LibraryDependencyHandler.computeExports].
  */
@@ skipping 19 matching lines @@
    */
   Link<ExportLink> dependencies = const Link<ExportLink>();
 
   /**
    * The export scope for [library] which is gradually computed by the work-list
    * computation in [LibraryDependencyHandler.computeExports].
    */
   Map<SourceString, Element> exportScope =
       new LinkedHashMap<SourceString, Element>();
 
+  /// Map from exported elements to the export directives that exported them.
+  Map<Element, Link<Export>> exporters = new Map<Element, Link<Export>>();
+
   /**
    * The set of exported elements that need to be propageted to dependent
    * libraries as part of the work-list computation performed in
-   * [LibraryDependencyHandler.computeExports].
+   * [LibraryDependencyHandler.computeExports]. Each export element is mapped
+   * to a list of exports directives that export it.
    */
-  Set<Element> pendingExportSet = new Set<Element>();
+  Map<Element, Link<Export>> pendingExportMap =
+      new Map<Element, Link<Export>>();
 
   LibraryDependencyNode(LibraryElement this.library);
 
   /**
    * Registers that the library of this node imports [importLibrary] through the
    * [import] tag.
    */
   void registerImportDependency(Import import,
                                 LibraryElement importedLibrary) {
     imports = imports.prepend(new ImportLink(import, importedLibrary));
   }
 
   /**
    * Registers that the library of this node is exported by
    * [exportingLibraryNode] through the [export] tag.
    */
   void registerExportDependency(Export export,
                                 LibraryDependencyNode exportingLibraryNode) {
     dependencies =
         dependencies.prepend(new ExportLink(export, exportingLibraryNode));
   }
 
   /**
    * Registers all non-private locally declared members of the library of this
    * node to be exported. This forms the basis for the work-list computation of
    * the export scopes performed in [LibraryDependencyHandler.computeExports].
    */
   void registerInitialExports() {
-    pendingExportSet.addAll(library.getNonPrivateElementsInScope());
+    for (Element element in library.getNonPrivateElementsInScope()) {
+      pendingExportMap[element] = const Link<Export>();
+    }
   }
 
   void registerHandledExports(LibraryElement exportedLibraryElement,
+                              Export export,
                               CombinatorFilter filter) {
     assert(invariant(library, exportedLibraryElement.exportsHandled));
     for (Element exportedElement in exportedLibraryElement.exports) {
       if (!filter.exclude(exportedElement)) {
-        pendingExportSet.add(exportedElement);
+        Link<Export> exports =
+            pendingExportMap.putIfAbsent(exportedElement,
+                                         () => const Link<Export>());
+        pendingExportMap[exportedElement] = exports.prepend(export);
       }
     }
   }
 
   /**
    * Registers the compute export scope with the node library.
    */
   void registerExports() {
     library.setExports(exportScope.values.toList());
   }
 
   /**
    * Registers the imports of the node library.
    */
   void registerImports(Compiler compiler) {
     for (ImportLink link in imports) {
       link.importLibrary(compiler, library);
     }
   }
 
   /**
    * Copies and clears pending export set for this node.
    */
-  List<Element> pullPendingExports() {
-    List<Element> pendingExports = new List.from(pendingExportSet);
-    pendingExportSet.clear();
+  Map<Element, Link<Export>> pullPendingExports() {
+    Map<Element, Link<Export>> pendingExports =
+        new Map<Element, Link<Export>>.from(pendingExportMap);
+    pendingExportMap.clear();
     return pendingExports;
   }
 
   /**
    * Adds [element] to the export scope for this node. If the [element] name
    * is a duplicate, an error element is inserted into the export scope.
    */
-  Element addElementToExportScope(Compiler compiler, Element element) {
+  Element addElementToExportScope(Compiler compiler, Element element,
+                                  Link<Export> exports) {
+
     SourceString name = element.name;
+
+    void reportDuplicateExport(Element duplicate,
+                               Link<Export> duplicateExports,
+                               {bool reportError: true}) {
+      compiler.withCurrentElement(library, () {
+        for (Export export in duplicateExports) {
+          if (reportError) {
+            compiler.reportError(export,
+                MessageKind.DUPLICATE_EXPORT, {'name': name});
+            reportError = false;
+          } else {
+            compiler.reportInfo(export,
+                MessageKind.DUPLICATE_EXPORT_CONT, {'name': name});
+          }
+        }
+      });
+    }
+
+    void reportDuplicateExportDecl(Element duplicate,
+                                   Link<Export> duplicateExports) {
+      compiler.reportInfo(duplicate, MessageKind.DUPLICATE_EXPORT_DECL,
+          {'name': name, 'uriString': duplicateExports.head.uri});
+    }
+
     Element existingElement = exportScope[name];
-    if (existingElement != null) {
+    if (existingElement != null && existingElement != element) {
       if (existingElement.isErroneous()) {
-        compiler.reportError(element, MessageKind.DUPLICATE_EXPORT,
-                             {'name': name});
+        reportDuplicateExport(element, exports);
+        reportDuplicateExportDecl(element, exports);
         element = existingElement;
       } else if (existingElement.getLibrary() != library) {
         // Declared elements hide exported elements.
-        compiler.reportError(existingElement, MessageKind.DUPLICATE_EXPORT,
-                             {'name': name});
-        compiler.reportError(element, MessageKind.DUPLICATE_EXPORT,
-                             {'name': name});
+        Link<Export> existingExports = exporters[existingElement];
+        reportDuplicateExport(existingElement, existingExports);
+        reportDuplicateExport(element, exports, reportError: false);
+        reportDuplicateExportDecl(existingElement, existingExports);
+        reportDuplicateExportDecl(element, exports);
         element = exportScope[name] = new ErroneousElementX(
             MessageKind.DUPLICATE_EXPORT, {'name': name}, name, library);
       }
     } else {
       exportScope[name] = element;
+      exporters[element] = exports;
     }
     return element;
   }
 
   /**
    * Propagates the exported [element] to all library nodes that depend upon
    * this node. If the propagation updated any pending exports, [:true:] is
    * returned.
    */
   bool propagateElement(Element element) {
     bool change = false;
     for (ExportLink link in dependencies) {
       if (link.exportElement(element)) {
         change = true;
       }
     }
     return change;
   }
 
   /**
    * Adds [element] to the pending exports of this node and returns [:true:] if
    * the pending export set was modified. The combinators of [export] are used
    * to filter the element.
    */
-  bool addElementToPendingExports(Element element) {
+  bool addElementToPendingExports(Element element, Export export) {
+    bool changed = false;
     if (!identical(exportScope[element.name], element)) {
-      if (!pendingExportSet.contains(element)) {
-        pendingExportSet.add(element);
-        return true;
-      }
+      Link<Export> exports = pendingExportMap.putIfAbsent(element, () {
+        changed = true;
+        return const Link<Export>();
+      });
+      pendingExportMap[element] = exports.prepend(export);
     }
-    return false;
+    return changed;
   }
 }
 
 /**
  * Helper class used for computing the possibly cyclic import/export scopes of
  * a set of libraries.
  *
  * This class is used by [ScannerTask.scanLibrary] to collect all newly loaded
  * libraries and to compute their import/export scopes through a fixed-point
  * algorithm.
@@ skipping 14 matching lines @@
 
   /**
    * Performs a fixed-point computation on the export scopes of all registered
    * libraries and creates the import/export of the libraries based on the
    * fixed-point.
    */
   void computeExports() {
     bool changed = true;
     while (changed) {
       changed = false;
-      Map<LibraryDependencyNode, List<Element>> tasks =
-          new LinkedHashMap<LibraryDependencyNode, List<Element>>();
+      Map<LibraryDependencyNode, Map<Element, Link<Export>>> tasks =
+          new Map<LibraryDependencyNode, Map<Element, Link<Export>>>();
 
       // Locally defined elements take precedence over exported
       // elements.  So we must propagate local elements first.  We
       // ensure this by pulling the pending exports before
       // propagating.  This enforces that we handle exports
       // breadth-first, with locally defined elements being level 0.
       nodeMap.forEach((_, LibraryDependencyNode node) {
-        List<Element> pendingExports = node.pullPendingExports();
+        Map<Element, Link<Export>> pendingExports = node.pullPendingExports();
         tasks[node] = pendingExports;
       });
-      tasks.forEach((LibraryDependencyNode node, List<Element> pendingExports) {
-        pendingExports.forEach((Element element) {
-          element = node.addElementToExportScope(compiler, element);
+      tasks.forEach((LibraryDependencyNode node,
+                     Map<Element, Link<Export>> pendingExports) {
+        pendingExports.forEach((Element element, Link<Export> exports) {
+          element = node.addElementToExportScope(compiler, element, exports);
           if (node.propagateElement(element)) {
             changed = true;
           }
         });
       });
     }
 
     // Setup export scopes. These have to be set before computing the import
     // scopes to avoid accessing uncomputed export scopes during handling of
     // imports.
@@ skipping 15 matching lines @@
                           LibraryElement loadedLibrary) {
     if (tag != null) {
       library.recordResolvedTag(tag, loadedLibrary);
     }
     if (tag is Export) {
       // [loadedLibrary] is exported by [library].
       LibraryDependencyNode exportingNode = nodeMap[library];
       if (loadedLibrary.exportsHandled) {
         // Export scope already computed on [loadedLibrary].
         var combinatorFilter = new CombinatorFilter.fromTag(tag);
-        exportingNode.registerHandledExports(loadedLibrary, combinatorFilter);
+        exportingNode.registerHandledExports(
+            loadedLibrary, tag, combinatorFilter);
         return;
       }
       LibraryDependencyNode exportedNode = nodeMap[loadedLibrary];
       assert(invariant(loadedLibrary, exportedNode != null,
           message: "$loadedLibrary has not been registered"));
       assert(invariant(library, exportingNode != null,
           message: "$library has not been registered"));
       exportedNode.registerExportDependency(tag, exportingNode);
     } else if (tag == null || tag is Import) {
       // [loadedLibrary] is imported by [library].
@@ skipping 12 matching lines @@
   }
 
   /**
    * Registers all top-level entities of [library] as starting point for the
    * fixed-point computation of the import/export scopes.
    */
   void registerLibraryExports(LibraryElement library) {
     nodeMap[library].registerInitialExports();
   }
 }