Handle clash of prefix/non-prefix imports.

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 616 matching lines @@
   }
 
   bool get hasMembers => !localMembers.isEmpty;
 
   int compareTo(CompilationUnitElement other) {
     if (this == other) return 0;
     return '${script.uri}'.compareTo('${other.script.uri}');
   }
 }
 
+class ImportScope {
+  /**
+   * 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 =
+      new Map<SourceString, Element>();
+
+  /**
+   * 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
+   * detection of ambiguous uses of imported names.
+   */
+  void addImport(Element enclosingElement,
+                 Element element,
+                 Import import,
+                 DiagnosticListener listener) {
+    LibraryElementX library = enclosingElement.getLibrary();
+    Map<Element, Link<Import>> importers = library.importers;
+    importers[element] =
+        importers.putIfAbsent(element, () => const Link<Import>())
+            .prepend(import);
+    SourceString name = element.name;
+    Element existing = importScope.putIfAbsent(name, () => element);
+
+    Element createWarnOnUseElement(Spannable spannable,
+                                   MessageKind messageKind,
+                                   Element hidingElement,
+                                   Element hiddenElement) {
+        Uri hiddenUri = hiddenElement.getLibrary().canonicalUri;
+        Uri hidingUri = hidingElement.getLibrary().canonicalUri;
+        return new WarnOnUseElementX(
+            new WrappedMessage(
+                null, // Report on reference to [hidingElement].
+                messageKind,
+                {'name': name, 'hiddenUri': hiddenUri, 'hidingUri': hidingUri}),
+            new WrappedMessage(
+                listener.spanFromSpannable(spannable),
+                MessageKind.IMPORTED_HERE,
+                {'name': name}),
+            enclosingElement, hidingElement);
+    }
+
+    if (existing != element) {
+      if (existing.getLibrary().isPlatformLibrary &&
+          !element.getLibrary().isPlatformLibrary) {
+        // [existing] is implicitly hidden.
+        importScope[name] = createWarnOnUseElement(
+            import, MessageKind.HIDDEN_IMPORT, element, existing);
+      } else if (!existing.getLibrary().isPlatformLibrary &&
+                 element.getLibrary().isPlatformLibrary) {
+        // [element] is implicitly hidden.
+        if (import == null) {
+          // [element] is imported implicitly (probably through dart:core).
+          importScope[name] = createWarnOnUseElement(
+              importers[existing].head, MessageKind.HIDDEN_IMPLICIT_IMPORT,
+              existing, element);
+        } else {
+          importScope[name] = createWarnOnUseElement(
+              import, MessageKind.HIDDEN_IMPORT, existing, element);
+        }
+      } else {
+        importScope[name] = new AmbiguousElementX(
+            MessageKind.DUPLICATE_IMPORT, {'name': name},
+            enclosingElement, existing, element);
+      }
+    }
+  }
+
+  Element operator [](SourceString name) => importScope[name];
+}
+
 class LibraryElementX extends ElementX implements LibraryElement {
   final Uri canonicalUri;
   CompilationUnitElement entryCompilationUnit;
   Link<CompilationUnitElement> compilationUnits =
       const Link<CompilationUnitElement>();
   Link<LibraryTag> tags = const Link<LibraryTag>();
   LibraryName libraryTag;
   bool canUseNative = false;
   Link<Element> localMembers = const Link<Element>();
   final ScopeX localScope = new ScopeX();
+  final ImportScope importScope = new ImportScope();
 
   /**
    * If this library is patched, [patch] points to the patch library.
    *
    * See [:patch_parser.dart:] for a description of the terminology.
    */
   LibraryElementX patch = null;
 
   /**
    * If this is a patch library, [origin] points to the origin library.
    *
    * See [:patch_parser.dart:] for a description of the terminology.
    */
   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 27 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 detection of ambiguous uses of imported names.
    */
   void addImport(Element element, Import import, DiagnosticListener listener) {
-    importers[element] =
-        importers.putIfAbsent(element, () => const Link<Import>())
-        .prepend(import);
-    SourceString name = element.name;
-    Element existing = importScope.putIfAbsent(name, () => element);
-
-    Element createWarnOnUseElement(Spannable spannable,
-                                   MessageKind messageKind,
-                                   Element hidingElement,
-                                   Element hiddenElement) {
-        Uri hiddenUri = hiddenElement.getLibrary().canonicalUri;
-        Uri hidingUri = hidingElement.getLibrary().canonicalUri;
-        return new WarnOnUseElementX(
-            new WrappedMessage(
-                null, // Report on reference to [hidingElement].
-                messageKind,
-                {'name': name, 'hiddenUri': hiddenUri, 'hidingUri': hidingUri}),
-            new WrappedMessage(
-                listener.spanFromSpannable(spannable),
-                MessageKind.IMPORTED_HERE,
-                {'name': name}),
-            this, hidingElement);
-    }
-
-    if (existing != element) {
-      if (existing.getLibrary().isPlatformLibrary &&
-          !element.getLibrary().isPlatformLibrary) {
-        // [existing] is implicitly hidden.
-        importScope[name] = createWarnOnUseElement(
-            import, MessageKind.HIDDEN_IMPORT, element, existing);
-      } else if (!existing.getLibrary().isPlatformLibrary &&
-                 element.getLibrary().isPlatformLibrary) {
-        // [element] is implicitly hidden.
-        if (import == null) {
-          // [element] is imported implicitly (probably through dart:core).
-          importScope[name] = createWarnOnUseElement(
-              importers[existing].head, MessageKind.HIDDEN_IMPLICIT_IMPORT,
-              existing, element);
-        } else {
-          importScope[name] = createWarnOnUseElement(
-              import, MessageKind.HIDDEN_IMPORT, existing, element);
-        }
-      } else {
-        // TODO(johnniwinther): Provide access to the import tags from which
-        // the elements came.
-        importScope[name] = new AmbiguousElementX(
-            MessageKind.DUPLICATE_IMPORT, {'name': name},
-            this, existing, element);
-      }
-    }
+    importScope.addImport(this, element, import, listener);
   }
 
   void addMember(Element element, DiagnosticListener listener) {
     localMembers = localMembers.prepend(element);
     addToScope(element, listener);
   }
 
   void addToScope(Element element, DiagnosticListener listener) {
     localScope.add(element, listener);
   }
@@ skipping 129 matching lines @@
     }
   }
 
   int compareTo(LibraryElement other) {
     if (this == other) return 0;
     return getLibraryOrScriptName().compareTo(other.getLibraryOrScriptName());
   }
 }
 
 class PrefixElementX extends ElementX implements PrefixElement {
-  Map<SourceString, Element> imported;
   Token firstPosition;
 
+  final ImportScope importScope = new ImportScope();
+
   PrefixElementX(SourceString prefix, Element enclosing, this.firstPosition)
-      : imported = new Map<SourceString, Element>(),
-        super(prefix, ElementKind.PREFIX, enclosing);
+      : super(prefix, ElementKind.PREFIX, enclosing);
 
-  Element lookupLocalMember(SourceString memberName) => imported[memberName];
+  Element lookupLocalMember(SourceString memberName) => importScope[memberName];
 
   DartType computeType(Compiler compiler) => compiler.types.dynamicType;
 
   Token position() => firstPosition;
+
+  void addImport(Element element, Import import, DiagnosticListener listener) {
+    importScope.addImport(this, element, import, listener);
+  }
 }
 
 class TypedefElementX extends ElementX implements TypedefElement {
   Typedef cachedNode;
 
   /**
    * The type of this typedef in which the type arguments are the type
    * variables.
    *
    * This resembles the [ClassElement.thisType] though a typedef has no notion
@@ skipping 1349 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }