Introduce AmbiguousElement

sdk/lib/_internal/compiler/implementation/resolution/members.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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
@@ skipping 1065 matching lines @@
     return resolveTypeAnnotationInContext(scope, node, onFailure,
                                           whenResolved);
   }
 
   DartType resolveTypeAnnotationInContext(Scope scope, TypeAnnotation node,
                                           onFailure, whenResolved) {
     Element element = resolveTypeName(scope, node);
     DartType type;
     if (element == null) {
       onFailure(node, MessageKind.CANNOT_RESOLVE_TYPE, [node.typeName]);
-    } else if (element.isErroneous()) {
-      ErroneousElement error = element;
-      onFailure(node, error.messageKind, error.messageArguments);
+    } else if (element.isAmbiguous()) {
+      AmbiguousElement ambiguous = element;
+      onFailure(node, ambiguous.messageKind, ambiguous.messageArguments);
     } else if (!element.impliesType()) {
       onFailure(node, MessageKind.NOT_A_TYPE, [node.typeName]);
     } else {
       if (identical(element, compiler.types.voidType.element) ||
           identical(element, compiler.types.dynamicType.element)) {
         type = element.computeType(compiler);
       } else if (element.isClass()) {
         ClassElement cls = element;
         cls.ensureResolved(compiler);
         Link<DartType> arguments =
@@ skipping 135 matching lines @@
   }
 
   visitInStaticContext(Node node) {
     inStaticContext(() => visit(node));
   }
 
   ErroneousElement warnAndCreateErroneousElement(Node node,
                                                  SourceString name,
                                                  MessageKind kind,
                                                  List<Node> arguments) {
-    return warnOnErroneousElement(node,
-        new ErroneousElement(kind, arguments, name, enclosingElement));
-  }
-
-  ErroneousElement warnOnErroneousElement(Node node,
-                                          ErroneousElement erroneousElement) {
-    ResolutionWarning warning =
-        new ResolutionWarning(erroneousElement.messageKind,
-                              erroneousElement.messageArguments);
+    ResolutionWarning warning = new ResolutionWarning(kind, arguments);
     compiler.reportWarning(node, warning);
-    return erroneousElement;
+    return new ErroneousElement(kind, arguments, name, enclosingElement);
   }
 
   Element visitIdentifier(Identifier node) {
     if (node.isThis()) {
       if (!inInstanceContext) {
         error(node, MessageKind.NO_INSTANCE_AVAILABLE, [node]);
       }
       return null;
     } else if (node.isSuper()) {
       if (!inInstanceContext) error(node, MessageKind.NO_SUPER_IN_STATIC);
       if ((ElementCategory.SUPER & allowedCategory) == 0) {
         error(node, MessageKind.INVALID_USE_OF_SUPER);
       }
       return null;
     } else {
       Element element = lookup(node, node.source);
       if (element == null) {
         if (!inInstanceContext) {
           element = warnAndCreateErroneousElement(node, node.source,
                                                   MessageKind.CANNOT_RESOLVE,
                                                   [node]);
         }
-      } else if (element.isErroneous()) {
-        element = warnOnErroneousElement(node, element);
+      } else if (element.isAmbiguous()) {
+        AmbiguousElement ambiguous = element;
+        element = warnAndCreateErroneousElement(node, node.source,
+            ambiguous.messageKind, ambiguous.messageArguments);

[karlklose, 2012/11/07 11:41:24]

I would prefer this formatting:
  warnAndCreateErroneousElement(node, node.source, ambiguous.messageKind,  
                                ambiguous.messageArguments);

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

Done.

       } else {
         if ((element.kind.category & allowedCategory) == 0) {
           // TODO(ahe): Improve error message. Need UX input.
           error(node, MessageKind.GENERIC, ["is not an expression $element"]);
         }
       }
       if (!Elements.isUnresolved(element)
           && element.kind == ElementKind.CLASS) {
         ClassElement classElement = element;
         classElement.ensureResolved(compiler);
@@ skipping 1749 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Expression expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }