Print the location of duplicated elements.

dart/sdk/lib/_internal/compiler/implementation/elements/modelx.dart

 // Copyright (c) 2013, 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.
 
 library elements.modelx;
 
 import 'dart:collection' show LinkedHashMap;
 
 import 'elements.dart';
 import '../../compiler.dart' as api;
@@ skipping 359 matching lines @@
    */
   final Element newElement;
 
   AmbiguousElementX(this.messageKind, this.messageArguments,
       Element enclosingElement, Element existingElement, Element newElement)
       : this.existingElement = existingElement,
         this.newElement = newElement,
         super(existingElement.name, ElementKind.AMBIGUOUS, enclosingElement);
 
   bool isAmbiguous() => true;
+
+  Set flatten() {
+    Element element = this;
+    var set = new Set();
+    while (element.isAmbiguous()) {
+      AmbiguousElement ambiguous = element;
+      set.add(ambiguous.newElement);
+      element = ambiguous.existingElement;
+    }
+    set.add(element);
+    return set;
+  }
+
+  void diagnose(Element context, DiagnosticListener listener) {
+    Set ambiguousElements = flatten();
+    MessageKind code = (ambiguousElements.length == 1)
+        ? MessageKind.AMBIGUOUS_REEXPORT : MessageKind.AMBIGUOUS_LOCATION;
+    LibraryElementX importer = context.getLibrary();
+    for (Element element in ambiguousElements) {
+      var arguments = {'element': element};
+      listener.reportInfo(element, code, arguments);
+      Link<Import> importers = importer.importers[element];
+      listener.withCurrentElement(importer, () {
+        for (; !importers.isEmpty; importers = importers.tail) {
+          listener.reportInfo(
+              importers.head, MessageKind.IMPORTED_HERE, arguments);
+        }
+      });
+    }
+  }
 }
 
 class ScopeX {
   final Map<SourceString, Element> contents = new Map<SourceString, Element>();
 
   bool get isEmpty => contents.isEmpty;
   Iterable<Element> get values => contents.values;
 
   Element lookup(SourceString name) {
     return contents[name];
@@ skipping 169 matching lines @@
   final LibraryElementX origin;
 
   /**
    * Map for elements imported through import declarations.
    *
    * Addition to the map is performed by [addImport]. Lookup is done trough
    * [find].
    */
   final Map<SourceString, Element> importScope;
 
+  /// A mapping from an imported element to the "import" tag.
+  final Map<Element, Link<Import>> importers;
+
   /**
    * Link for elements exported either through export declarations or through
    * declaration. This field should not be accessed directly but instead through
    * the [exports] getter.
    *
    * [LibraryDependencyHandler] sets this field through [setExports] when the
    * library is loaded.
    */
   Link<Element> slotForExports;
 
   final Map<LibraryDependency, LibraryElement> tagMapping =
       new LinkedHashMap<LibraryDependency, LibraryElement>();
 
   LibraryElementX(Script script, [Uri canonicalUri, LibraryElement this.origin])
     : this.canonicalUri = ((canonicalUri == null) ? script.uri : canonicalUri),
       importScope = new Map<SourceString, Element>(),
+      importers = new Map<Element, Link<Import>>(),
       super(new SourceString(script.name), ElementKind.LIBRARY, null) {
     entryCompilationUnit = new CompilationUnitElementX(script, this);
     if (isPatch) {
       origin.patch = this;
     }
   }
 
   bool get isPatched => patch != null;
   bool get isPatch => origin != null;
 
@@ skipping 26 matching lines @@
 
   LibraryElement getLibraryFromTag(LibraryDependency tag) => tagMapping[tag];
 
   /**
    * Adds [element] to the import scope of this library.
    *
    * If an element by the same name is already in the imported scope, an
    * [ErroneousElement] will be put in the imported scope, allowing for the
    * detection of ambiguous uses of imported names.
    */
-  void addImport(Element element, DiagnosticListener listener) {
+  void addImport(Element element, Import import, DiagnosticListener listener) {
+    importers[element] =
+        importers.putIfAbsent(element, () => const Link<Import>())
+        .prepend(import);
     Element existing = importScope[element.name];
     if (existing != null) {
       // TODO(johnniwinther): Provide access to the import tags from which
       // the elements came.
       importScope[element.name] = new AmbiguousElementX(
           MessageKind.DUPLICATE_IMPORT, {'name': element.name},
           this, existing, element);
     } else {
       importScope[element.name] = element;
     }
@@ skipping 1500 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }