Merge libv1.

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 159 matching lines @@
  * Accessing any field or calling any method defined on [ErroneousElement]
  * 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 {
+class ErroneousElement extends Element implements FunctionElement {
   final MessageKind messageKind;
   final List messageArguments;
-  final SourceString targetName;
 
   ErroneousElement(this.messageKind, this.messageArguments,
-                   this.targetName, Element enclosing)
-      : super(const SourceString('erroneous element'),
-              ElementKind.ERROR, enclosing);
+                   SourceString name, Element enclosing)
+      : super(name, ElementKind.ERROR, enclosing);
 
   isErroneous() => true;
 
   unsupported() {
     throw 'unsupported operation on erroneous element';
   }
 
-  SourceString get name => unsupported();
   Link<MetadataAnnotation> get metadata => unsupported();
-
-  getLibrary() => enclosingElement.getLibrary();
-
-  String toString() {
-    String n = targetName.slowToString();
-    return '<$n: ${messageKind.message(messageArguments)}>';
-  }
-}
-
-class ErroneousFunctionElement extends ErroneousElement
-                               implements FunctionElement {
-  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();
   computeSignature(compiler) => unsupported();
   requiredParameterCount(compiler) => unsupported();
   optionalParameterCount(compiler) => unsupported();
   parameterCount(copmiler) => unsupported();
+
+  get redirectionTarget => this;
+
+  getLibrary() => enclosingElement.getLibrary();
+
+  String toString() {
+    String n = name.slowToString();
+    return '<$n: ${messageKind.message(messageArguments)}>';
+  }
+}
+
+/**
+ * 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 a warning/error should be
+ * 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 first element that this ambiguous element might refer to.
+   */
+  final Element existingElement;
+
+  /**
+   * The second element that this ambiguous element might refer to.
+   */
+  final Element newElement;
+
+  AmbiguousElement(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;
 }
 
 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 220 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);
-      }
+      // 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 {
       importScope[element.name] = element;
     }
   }
 
   /**
    * Returns [:true:] if the export scope has already been computed for this
    * library.
    */
   bool get exportsHandled => slotForExports != null;
@@ skipping 414 matching lines @@
   /**
    * A function declaration that should be parsed instead of the current one.
    * The patch should be parsed as if it was in the current scope. Its
    * signature must match this function's signature.
    */
   // TODO(lrn): Consider using [defaultImplementation] to store the patch.
   FunctionElement patch = null;
   FunctionElement origin = null;
 
   /**
-   * If this is an interface constructor, [defaultImplementation] will
-   * changed by the resolver to point to the default
-   * implementation. Otherwise, [:defaultImplementation === this:].
+   * If this is a redirecting factory, [defaultImplementation] will be
+   * changed by the resolver to point to the redirection target.  If
+   * this is an interface constructor, [defaultImplementation] will be
+   * changed by the resolver to point to the default implementation.
+   * Otherwise, [:defaultImplementation === this:].
    */
+  // TODO(ahe): Rename this field to redirectionTarget and remove
+  // mention of interface constructors above.
   FunctionElement defaultImplementation;
 
   FunctionElement(SourceString name,
                   ElementKind kind,
                   Modifiers modifiers,
                   Element enclosing)
       : this.tooMuchOverloading(name, null, kind, modifiers, enclosing, null);
 
   FunctionElement.node(SourceString name,
                        FunctionExpression node,
@@ skipping 16 matching lines @@
                                      Element enclosing,
                                      FunctionSignature this.functionSignature)
       : super(name, kind, enclosing) {
     assert(modifiers != null);
     defaultImplementation = this;
   }
 
   bool get isPatched => patch != null;
   bool get isPatch => origin != null;
 
+  FunctionElement get redirectionTarget {
+    if (this == defaultImplementation) return this;
+    Element target = defaultImplementation;
+    Set<Element> seen = new Set<Element>();
+    seen.add(target);
+    while (!target.isErroneous() && target != target.defaultImplementation) {
+      target = target.defaultImplementation;
+      if (seen.contains(target)) {
+        // TODO(ahe): This is expedient for now, but it should be
+        // checked by the resolver.  Keeping http://dartbug.com/3970
+        // open to track this.
+        throw new SpannableAssertionFailure(
+            target, 'redirecting factory leads to cycle');
+      }
+    }
+    return target;
+  }
+
   /**
    * Applies a patch function to this function. The patch function's body
    * is used as replacement when parsing this function's body.
    * This method must not be called after the function has been parsed,
    * and it must be called at most once.
    */
   void setPatch(FunctionElement patchElement) {
     // Sanity checks. The caller must check these things before calling.
     assert(patch == null);
     this.patch = patchElement;
@@ skipping 802 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }