Import scope rules updated.

lib/compiler/implementation/elements/elements.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.
 
 #library('elements');
 
 #import('dart:uri');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
@@ skipping 347 matching lines @@
  * except [isErroneous] will currently throw an exception. (This might
  * change when we actually want more information on the erroneous element,
  * e.g., the name of the element we were trying to resolve.)
  *
  * Code that cannot not handle an [ErroneousElement] should use
  *   [: Element.isInvalid(element) :]
  * to check for unresolvable elements instead of
  *   [: element == null :].
  */
 class ErroneousElement extends Element {
-  final Message errorMessage;
+  final MessageKind messageKind;
+  final List messageArguments;
   final SourceString targetName;
 
-  ErroneousElement(this.errorMessage, this.targetName, Element enclosing)
+  ErroneousElement(this.messageKind, this.messageArguments,
+                   this.targetName, Element enclosing)
       : super(const SourceString('erroneous element'), null, enclosing);
 
   isErroneous() => true;
 
   unsupported() {
     throw 'unsupported operation on erroneous element';
   }
 
   SourceString get name => unsupported();
   ElementKind get kind => unsupported();
   Link<MetadataAnnotation> get metadata => unsupported();
 
   getLibrary() => enclosingElement.getLibrary();
 }
 
 class ErroneousFunctionElement extends ErroneousElement
                                implements FunctionElement {
-  ErroneousFunctionElement(Message errorMessage, SourceString targetName,
-                           Element enclosing)
-      : super(errorMessage, targetName, enclosing);
+  ErroneousFunctionElement(MessageKind messageKind, List messageArguments,
+                           SourceString targetName, Element enclosing)
+      : super(messageKind, messageArguments, targetName, enclosing);
 
   get type => unsupported();
   get cachedNode => unsupported();
   get functionSignature => unsupported();
   get patch => unsupported();
   get origin => unsupported();
   get defaultImplementation => unsupported();
   bool get isPatched => unsupported();
   bool get isPatch => unsupported();
   setPatch(patch) => unsupported();
@@ skipping 129 matching lines @@
 class LibraryElement extends ScopeContainerElement {
   final Uri uri;
   CompilationUnitElement entryCompilationUnit;
   Link<CompilationUnitElement> compilationUnits =
       const EmptyLink<CompilationUnitElement>();
   Link<LibraryTag> tags = const EmptyLink<LibraryTag>();
   LibraryTag libraryTag;
   bool canUseNative = false;
   LibraryElement patch = null;
 
+  /**
+   * 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;
+
   LibraryElement(Script script, [Uri uri])
     : this.uri = ((uri === null) ? script.uri : uri),
+      importScope = new Map<SourceString, Element>(),
       super(new SourceString(script.name), ElementKind.LIBRARY, null) {
     entryCompilationUnit = new CompilationUnitElement(script, this);
   }
 
 
   bool get isPatched => patch !== null;
 
   void addCompilationUnit(CompilationUnitElement element) {
     compilationUnits = compilationUnits.prepend(element);
   }
 
   void addTag(LibraryTag tag, DiagnosticListener listener) {
     tags = tags.prepend(tag);
   }
 
-  /** Look up a top-level element in this library. The element could
-    * potentially have been imported from another library. Returns
-    * null if no such element exist. */
+  /**
+   * 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) {
+    Element existing = importScope.putIfAbsent(element.name, () => element);
+    if (existing !== element && existing !== null) {
+      if (!existing.isErroneous()) {
+        // TODO(johnniwinther): Provide access to both the new and existing
+        // elements.
+        importScope[element.name] = new ErroneousElement(
+            MessageKind.DUPLICATE_IMPORT,
+            [element.name], element.name, this);
+      }
+    }
+  }
+
+
+  /**
+   * Look up a top-level element in this library. The element could
+   * potentially have been imported from another library. Returns
+   * null if no such element exist and an [ErroneousElement] if multiple
+   * elements have been imported.
+   */
   Element find(SourceString elementName) {
-    return localScope[elementName];
+    Element result = localScope[elementName];
+    if (result === null) {
+      result = importScope[elementName];
+    }
+    return result;
   }
 
   /** Look up a top-level element in this library, but only look for
     * non-imported elements. Returns null if no such element exist. */
   Element findLocal(SourceString elementName) {
     Element result = localScope[elementName];
     if (result === null || result.getLibrary() != this) return null;
     return result;
   }
 
@@ skipping 1178 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }