Treat ambiguous types as malformed.

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 get currentElement;
   Set<Node> get superUses;
 
@@ skipping 1410 matching lines @@
         return compiler.types.voidType.element;
       } else if (identical(stringValue, 'dynamic')) {
         return compiler.dynamicClass;
       } else {
         return scope.lookup(typeName.source);
       }
     }
   }
 
   DartType resolveTypeAnnotation(MappingVisitor visitor, TypeAnnotation node,
-                                 {bool malformedIsError: false,
-                                  bool ambiguousIsError: false}) {
+                                 {bool malformedIsError: false}) {
     Identifier typeName;
     SourceString prefixName;
     Send send = node.typeName.asSend();
     if (send != null) {
       // The type name is of the form [: prefix . identifier :].
       prefixName = send.receiver.asIdentifier().source;
       typeName = send.selector.asIdentifier();
     } else {
       typeName = node.typeName.asIdentifier();
     }
 
     Element element = resolveTypeName(visitor.scope, prefixName, typeName);
     DartType type;
 
     DartType reportFailureAndCreateType(DualKind messageKind,
                                         Map messageArguments,
-                                        {DartType userProvidedBadType,
-                                         bool isError: false,
-                                         bool isAmbiguous: false}) {
-      if (isError) {
+                                        {DartType userProvidedBadType}) {
+      if (malformedIsError) {
         visitor.error(node, messageKind.error, messageArguments);
       } else {
         visitor.warning(node, messageKind.warning, messageArguments);
       }
       var erroneousElement = new ErroneousElementX(
           messageKind.error, messageArguments, typeName.source,
           visitor.enclosingElement);
       var arguments = new LinkBuilder<DartType>();
       resolveTypeArguments(visitor, node, null, arguments);
-      return isAmbiguous
-          ? new AmbiguousType(erroneousElement, arguments.toLink())
-          : new MalformedType(erroneousElement,
+      return new MalformedType(erroneousElement,
               userProvidedBadType, arguments.toLink());
     }
 
     DartType checkNoTypeArguments(DartType type) {
       var arguments = new LinkBuilder<DartType>();
       bool hasTypeArgumentMismatch = resolveTypeArguments(
           visitor, node, const Link<DartType>(), arguments);
       if (hasTypeArgumentMismatch) {
         type = new MalformedType(
             new ErroneousElementX(MessageKind.TYPE_ARGUMENT_COUNT_MISMATCH,
                 {'type': node}, typeName.source, visitor.enclosingElement),
                 type, arguments.toLink());
       }
       return type;
     }
 
     if (element == null) {
       type = reportFailureAndCreateType(
-          MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.typeName},
-          isError: malformedIsError);
+          MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.typeName});
     } else if (element.isAmbiguous()) {
       AmbiguousElement ambiguous = element;
       type = reportFailureAndCreateType(
-          ambiguous.messageKind, ambiguous.messageArguments,
-          isError: ambiguousIsError, isAmbiguous: true);
+          ambiguous.messageKind, ambiguous.messageArguments);
       ambiguous.diagnose(visitor.mapping.currentElement, compiler);
     } else if (!element.impliesType()) {
       type = reportFailureAndCreateType(
-          MessageKind.NOT_A_TYPE, {'node': node.typeName},
-          isError: malformedIsError);
+          MessageKind.NOT_A_TYPE, {'node': node.typeName});
     } else {
       if (identical(element, compiler.types.voidType.element) ||
           identical(element, compiler.dynamicClass)) {
         type = checkNoTypeArguments(element.computeType(compiler));
       } else if (element.isClass()) {
         ClassElement cls = element;
         compiler.resolver._ensureClassWillBeResolved(cls);
         element.computeType(compiler);
         var arguments = new LinkBuilder<DartType>();
         bool hasTypeArgumentMismatch = resolveTypeArguments(
@@ skipping 33 matching lines @@
         bool isInFactoryConstructor =
             outer != null && outer.isFactoryConstructor();
         if (!outer.isClass() &&
             !outer.isTypedef() &&
             !isInFactoryConstructor &&
             Elements.isInStaticContext(visitor.enclosingElement)) {
           compiler.backend.registerThrowRuntimeError(visitor.mapping);
           type = reportFailureAndCreateType(
               MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
               {'typeVariableName': node},
-              userProvidedBadType: element.computeType(compiler),
-              isError: malformedIsError);
+              userProvidedBadType: element.computeType(compiler));
         } else {
           type = element.computeType(compiler);
         }
         type = checkNoTypeArguments(type);
       } else {
         compiler.cancel("unexpected element kind ${element.kind}",
                         node: node);
       }
     }
     visitor.useType(node, type);
     return type;
   }
 
   /**
    * Resolves the type arguments of [node] and adds these to [arguments].
    *
    * Returns [: true :] if the number of type arguments did not match the
    * number of type variables.
    */
   bool resolveTypeArguments(
       MappingVisitor visitor,
       TypeAnnotation node,
       Link<DartType> typeVariables,
-      LinkBuilder<DartType> arguments,
-      {bool ambiguousIsError: false}) {
+      LinkBuilder<DartType> arguments) {
     if (node.typeArguments == null) {
       return false;
     }
     bool typeArgumentCountMismatch = false;
     for (Link<Node> typeArguments = node.typeArguments.nodes;
          !typeArguments.isEmpty;
          typeArguments = typeArguments.tail) {
       if (typeVariables != null && typeVariables.isEmpty) {
         visitor.warning(
             typeArguments.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT.warning);
         typeArgumentCountMismatch = true;
       }
-      DartType argType = resolveTypeAnnotation(visitor, typeArguments.head,
-          ambiguousIsError: ambiguousIsError);
+      DartType argType = resolveTypeAnnotation(visitor, typeArguments.head);
       arguments.addLast(argType);
       if (typeVariables != null && !typeVariables.isEmpty) {
         typeVariables = typeVariables.tail;
       }
     }
     if (typeVariables != null && !typeVariables.isEmpty) {
       visitor.warning(node.typeArguments,
                       MessageKind.MISSING_TYPE_ARGUMENT.warning);
       typeArgumentCountMismatch = true;
     }
@@ skipping 1080 matching lines @@
    */
   FunctionElement resolveConstructor(NewExpression node) {
     return node.accept(new ConstructorResolver(compiler, this));
   }
 
   FunctionElement resolveRedirectingFactory(Return node) {
     return node.accept(new ConstructorResolver(compiler, this));
   }
 
   DartType resolveTypeExpression(TypeAnnotation node) {
-    return resolveTypeAnnotation(node, isTypeExpression: true);
+    return resolveTypeAnnotation(node);
   }
 
-  DartType resolveTypeAnnotation(TypeAnnotation node,
-                                 {bool isTypeExpression: false}) {
-    DartType type = typeResolver.resolveTypeAnnotation(
-        this, node, ambiguousIsError: isTypeExpression);
+  DartType resolveTypeAnnotation(TypeAnnotation node) {
+    DartType type = typeResolver.resolveTypeAnnotation(this, node);
     if (type == null) return null;
     if (inCheckContext) {
       compiler.enqueuer.resolution.registerIsCheck(type, mapping);
       compiler.backend.registerRequiredType(type, enclosingElement);
     }
     return type;
   }
 
   visitModifiers(Modifiers node) {
     // TODO(ngeoffray): Implement this.
@@ skipping 1370 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }