Introduce AmbiguousElement

sdk/lib/_internal/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';
 
 // TODO(ahe): Rename prefix to 'api' when VM bug is fixed.
 import '../../compiler.dart' as api_e;
@@ skipping 98 matching lines @@
   static const ElementKind TYPEDEF =
     const ElementKind('typedef', ElementCategory.ALIAS);
 
   static const ElementKind STATEMENT =
     const ElementKind('statement', ElementCategory.NONE);
   static const ElementKind LABEL =
     const ElementKind('label', ElementCategory.NONE);
   static const ElementKind VOID =
     const ElementKind('void', ElementCategory.NONE);
 
+  static const ElementKind AMBIGUOUS =
+      const ElementKind('ambiguous', ElementCategory.NONE);
   static const ElementKind ERROR =
       const ElementKind('error', ElementCategory.NONE);
 
   toString() => id;
 }
 
 class Element implements Spannable {
   static int elementHashCode = 0;
 
   final SourceString name;
@@ skipping 59 matching lines @@
   bool isSetter() => identical(kind, ElementKind.SETTER);
   bool isAccessor() => isGetter() || isSetter();
   bool isForeign() => identical(kind, ElementKind.FOREIGN);
   bool isLibrary() => identical(kind, ElementKind.LIBRARY);
   bool impliesType() => (kind.category & ElementCategory.IMPLIES_TYPE) != 0;
   bool isExtendable() => (kind.category & ElementCategory.IS_EXTENDABLE) != 0;
 
   /** See [ErroneousElement] for documentation. */
   bool isErroneous() => false;
 
+  /** See [AmbiguousElement] for documentation. */
+  bool isAmbiguous() => false;
+
   /**
    * Is [:true:] if this element has a corresponding patch.
    *
    * If [:true:] this element has a non-null [patch] field.
    *
    * See [:patch_parser.dart:] for a description of the terminology.
    */
   bool get isPatched => false;
 
   /**
@@ skipping 207 matching lines @@
   get defaultImplementation => unsupported();
   bool get isPatched => unsupported();
   bool get isPatch => unsupported();
   setPatch(patch) => unsupported();
   computeSignature(compiler) => unsupported();
   requiredParameterCount(compiler) => unsupported();
   optionalParameterCount(compiler) => unsupported();
   parameterCount(copmiler) => unsupported();
 }
 
+/**
+ * An ambiguous element represent multiple elements accessible by the same name.
+ *
+ * Ambiguous elements are created during handling of import/export scopes. If an
+ * ambiguous element is encountered during resolution an warning/error should be

[ahe, 2012/11/06 16:28:10]

an -> a

[Johnni Winther, 2012/11/07 08:24:43]

Done.

+ * reported.
+ */
+class AmbiguousElement extends Element {
+  /**
+   * The message to report on resolving this element.
+   */
+  final MessageKind messageKind;
+
+  /**
+   * The message arguments to report on resolving this element.
+   */
+  final List messageArguments;
+
+  /**
+   * The elements that this ambiguous element might refer to.
+   */
+  Link<Element> elements = const Link<Element>();

[ahe, 2012/11/06 16:28:10]

Should this also be final? I would be more comfortable creating a new element
rather than adding to an existing.

[Johnni Winther, 2012/11/07 08:24:43]

We need this to handle cases where more than two elements share the same name.

[ahe, 2012/11/07 11:18:19]

In my mind that would be handled with:

new AbiguousElement(newElement, existingAmbiguousElement)

[Johnni Winther, 2012/11/07 13:02:01]

Done.

+
+  AmbiguousElement(MessageKind this.messageKind, List this.messageArguments,
+      Element enclosingElement, Element existingElement, Element newElement)
+      : super(existingElement.name, ElementKind.AMBIGUOUS, enclosingElement) {
+    addAmbiguousElement(existingElement);
+    addAmbiguousElement(newElement);
+  }
+
+  bool isAmbiguous() => true;
+
+  /**
+   * Adds an element as one of the elements that this ambiguous element might
+   * refer to.
+   */
+  void addAmbiguousElement(Element element) {
+    elements = elements.prepend(element);
+  }
+}
+
 class ContainerElement extends Element {
   Link<Element> localMembers = const Link<Element>();
 
   ContainerElement(name, kind, enclosingElement)
     : super(name, kind, enclosingElement);
 
   void addMember(Element element, DiagnosticListener listener) {
     localMembers = localMembers.prepend(element);
   }
 }
@@ skipping 218 matching lines @@
   /**
    * 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[element.name];
     if (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);
+      if (!existing.isAmbiguous()) {
+        // TODO(johnniwinther): Provide access to the import tags from which
+        // the elements came.
+        importScope[element.name] = new AmbiguousElement(
+            MessageKind.DUPLICATE_IMPORT, [element.name],
+            this, existing, element);
+      } else {
+        (existing as AmbiguousElement).addAmbiguousElement(element);

[ahe, 2012/11/06 16:28:10]

Please don't use casts. There is a dynamic check involved.

[Johnni Winther, 2012/11/07 08:24:43]

Replaced by another workaround.

       }
     } else {
       importScope[element.name] = element;
     }
   }
 
   /**
    * Returns [:true:] if the export scope has already been computed for this
    * library.
    */
@@ skipping 1277 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }