Support new malformed types semantics.

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 1409 matching lines @@
       if (identical(stringValue, 'void')) {
         return compiler.types.voidType.element;
       } else if (identical(stringValue, 'dynamic')) {
         return compiler.dynamicClass;
       } else {
         return scope.lookup(typeName.source);
       }
     }
   }
 
-  // TODO(johnniwinther): Change  [onFailure] and [whenResolved] to use boolean
-  // flags instead of closures.
-  DartType resolveTypeAnnotation(
-      MappingVisitor visitor,
-      TypeAnnotation node,
-      {onFailure(Node node, DualKind kind, [Map arguments])}) {
-    if (onFailure == null) {
-      onFailure = (n, k, [arguments]) {};
-    }
-    return resolveTypeAnnotationInContext(visitor, node, onFailure);
-  }
-
-  DartType resolveTypeAnnotationInContext(
-      MappingVisitor visitor,
-      TypeAnnotation node,
-      onFailure(Node node, DualKind kind, [Map arguments])) {
+  DartType resolveTypeAnnotation(MappingVisitor visitor, TypeAnnotation node,
+                                 {bool malformedIsError: false,
+                                  bool ambiguousIsError: 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) {
-      onFailure(node, messageKind, messageArguments);
+                                        Map messageArguments,
+                                        {DartType userProvidedBadType,
+                                         bool isError: false,
+                                         bool isAmbiguous: false}) {
+      if (isError) {
+        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,
-          onFailure, arguments);
-      return new MalformedType(erroneousElement, null, arguments.toLink());
+      resolveTypeArguments(visitor, node, null, arguments);
+      return isAmbiguous
+          ? new AmbiguousType(erroneousElement, arguments.toLink())
+          : new MalformedType(erroneousElement,
+              userProvidedBadType, arguments.toLink());
     }
 
     DartType checkNoTypeArguments(DartType type) {
       var arguments = new LinkBuilder<DartType>();
-      bool hashTypeArgumentMismatch = resolveTypeArguments(
-          visitor, node, const Link<DartType>(),
-          onFailure, arguments);
-      if (hashTypeArgumentMismatch) {
+      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});
+          MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.typeName},
+          isError: malformedIsError);
     } else if (element.isAmbiguous()) {
       AmbiguousElement ambiguous = element;
       type = reportFailureAndCreateType(
-          ambiguous.messageKind, ambiguous.messageArguments);
+          ambiguous.messageKind, ambiguous.messageArguments,
+          isError: ambiguousIsError, isAmbiguous: true);
       ambiguous.diagnose(visitor.mapping.currentElement, compiler);
     } else if (!element.impliesType()) {
       type = reportFailureAndCreateType(
-          MessageKind.NOT_A_TYPE, {'node': node.typeName});
+          MessageKind.NOT_A_TYPE, {'node': node.typeName},
+          isError: malformedIsError);
     } else {
       if (identical(element, compiler.types.voidType.element) ||
-          identical(element, compiler.types.dynamicType.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 hashTypeArgumentMismatch = resolveTypeArguments(
-            visitor, node, cls.typeVariables,
-            onFailure, arguments);
-        if (hashTypeArgumentMismatch) {
-          type = new MalformedType(
-              new ErroneousElementX(MessageKind.TYPE_ARGUMENT_COUNT_MISMATCH,
-                  {'type': node}, typeName.source, visitor.enclosingElement),
-              new InterfaceType.userProvidedBadType(cls.declaration,
-                                                    arguments.toLink()));
+        bool hasTypeArgumentMismatch = resolveTypeArguments(
+            visitor, node, cls.typeVariables, arguments);
+        if (hasTypeArgumentMismatch) {
+          type = new BadInterfaceType(cls.declaration,
+              new InterfaceType.forUserProvidedBadType(cls.declaration,
+                                                       arguments.toLink()));
         } else {
           if (arguments.isEmpty) {
             type = cls.rawType;
           } else {
             type = new InterfaceType(cls.declaration, arguments.toLink());
           }
         }
       } else if (element.isTypedef()) {
         TypedefElement typdef = element;
         // TODO(ahe): Should be [ensureResolved].
         compiler.resolveTypedef(typdef);
         var arguments = new LinkBuilder<DartType>();
-        bool hashTypeArgumentMismatch = resolveTypeArguments(
-            visitor, node, typdef.typeVariables,
-            onFailure, arguments);
-        if (hashTypeArgumentMismatch) {
-          type = new MalformedType(
-              new ErroneousElementX(MessageKind.TYPE_ARGUMENT_COUNT_MISMATCH,
-                  {'type': node}, typeName.source, visitor.enclosingElement),
-              new TypedefType.userProvidedBadType(typdef, arguments.toLink()));
+        bool hasTypeArgumentMismatch = resolveTypeArguments(
+            visitor, node, typdef.typeVariables, arguments);
+        if (hasTypeArgumentMismatch) {
+          type = new BadTypedefType(typdef,
+              new TypedefType.forUserProvidedBadType(typdef, 
+                                                     arguments.toLink()));
         } else {
           if (arguments.isEmpty) {
             type = typdef.rawType;
           } else {
            type = new TypedefType(typdef, arguments.toLink());
           }
         }
       } else if (element.isTypeVariable()) {
         Element outer =
             visitor.enclosingElement.getOutermostEnclosingMemberOrTopLevel();
         bool isInFactoryConstructor =
             outer != null && outer.isFactoryConstructor();
         if (!outer.isClass() &&
             !outer.isTypedef() &&
             !isInFactoryConstructor &&
             Elements.isInStaticContext(visitor.enclosingElement)) {
           compiler.backend.registerThrowRuntimeError(visitor.mapping);
-          compiler.reportWarningCode(
-              node,
-              MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER.warning,
-              {'typeVariableName': node});
-          type = new MalformedType(
-              new ErroneousElementX(
-                  MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER.error,
-                  {'typeVariableName': node},
-                  typeName.source, visitor.enclosingElement),
-                  element.computeType(compiler));
+          type = reportFailureAndCreateType(
+              MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
+              {'typeVariableName': node},
+              userProvidedBadType: element.computeType(compiler),
+              isError: malformedIsError);
         } 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,
-      onFailure(Node node, DualKind kind, [Map arguments]),
-      LinkBuilder<DartType> arguments) {
+      LinkBuilder<DartType> arguments,
+      {bool ambiguousIsError: false}) {
     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) {
-        onFailure(typeArguments.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
+        visitor.warning(
+            typeArguments.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT.warning);
         typeArgumentCountMismatch = true;
       }
-      DartType argType = resolveTypeAnnotationInContext(visitor,
-                                                        typeArguments.head,
-                                                        onFailure);
+      DartType argType = resolveTypeAnnotation(visitor, typeArguments.head,
+          ambiguousIsError: ambiguousIsError);
       arguments.addLast(argType);
       if (typeVariables != null && !typeVariables.isEmpty) {
         typeVariables = typeVariables.tail;
       }
     }
     if (typeVariables != null && !typeVariables.isEmpty) {
-      onFailure(node.typeArguments, MessageKind.MISSING_TYPE_ARGUMENT);
+      visitor.warning(node.typeArguments,
+                      MessageKind.MISSING_TYPE_ARGUMENT.warning);
       typeArgumentCountMismatch = true;
     }
     return typeArgumentCountMismatch;
   }
 }
 
 /**
  * Common supertype for resolver visitors that record resolutions in a
  * [TreeElements] mapping.
  */
@@ skipping 35 matching lines @@
    *
    * This field is updated when nested closures are visited.
    */
   Element enclosingElement;
   bool inInstanceContext;
   bool inCheckContext;
   bool inCatchBlock;
   Scope scope;
   ClassElement currentClass;
   ExpressionStatement currentExpressionStatement;
-  bool typeRequired = false;
   bool sendIsMemberAccess = false;
   StatementScope statementScope;
   int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION
       | ElementCategory.IMPLIES_TYPE;
 
   // TODO(ahe): Find a way to share this with runtime implementation.
   static final RegExp symbolValidationPattern =
       new RegExp(r'^(?:[a-zA-Z$][a-zA-Z$0-9_]*\.)*(?:[a-zA-Z$][a-zA-Z$0-9_]*=?|'
                  r'-|'
                  r'unary-|'
@@ skipping 598 matching lines @@
         mapping.setType(node, compiler.typeClass.computeType(compiler));
         world.registerTypeLiteral(target, mapping);
       }
     }
 
     bool resolvedArguments = false;
     if (node.isOperator) {
       String operatorString = node.selector.asOperator().source.stringValue;
       if (operatorString == 'is') {
         DartType type =
-            resolveTypeRequired(node.typeAnnotationFromIsCheckOrCast);
+            resolveTypeExpression(node.typeAnnotationFromIsCheckOrCast);
         if (type != null) {
           compiler.enqueuer.resolution.registerIsCheck(type, mapping);
         }
         resolvedArguments = true;
       } else if (operatorString == 'as') {
-        DartType type = resolveTypeRequired(node.arguments.head);
+        DartType type = resolveTypeExpression(node.arguments.head);
         if (type != null) {
           compiler.enqueuer.resolution.registerAsCheck(type, mapping);
         }
         resolvedArguments = true;
       }
     }
 
     if (!resolvedArguments) {
       oldSendIsMemberAccess = sendIsMemberAccess;
       sendIsMemberAccess = false;
@@ skipping 391 matching lines @@
    * [null], if there is no corresponding constructor, class or library.
    */
   FunctionElement resolveConstructor(NewExpression node) {
     return node.accept(new ConstructorResolver(compiler, this));
   }
 
   FunctionElement resolveRedirectingFactory(Return node) {
     return node.accept(new ConstructorResolver(compiler, this));
   }
 
-  DartType resolveTypeRequired(TypeAnnotation node) {
-    bool old = typeRequired;
-    typeRequired = true;
-    DartType result = resolveTypeAnnotation(node);
-    typeRequired = old;
-    return result;
+  DartType resolveTypeExpression(TypeAnnotation node) {
+    return resolveTypeAnnotation(node, isTypeExpression: true);
   }
 
-  DartType resolveTypeAnnotation(TypeAnnotation node) {
-    Function report = typeRequired ? dualError : dualWarning;
+  DartType resolveTypeAnnotation(TypeAnnotation node,
+                                 {bool isTypeExpression: false}) {
     DartType type = typeResolver.resolveTypeAnnotation(
-        this, node, onFailure: report);
+        this, node, ambiguousIsError: isTypeExpression);
     if (type == null) return null;
     if (inCheckContext) {
       compiler.enqueuer.resolution.registerIsCheck(type, mapping);
-    }
-    if (typeRequired || inCheckContext) {
       compiler.backend.registerRequiredType(type, enclosingElement);
     }
     return type;
   }
 
   visitModifiers(Modifiers node) {
     // TODO(ngeoffray): Implement this.
     unimplemented(node, 'modifiers');
   }
 
   visitLiteralList(LiteralList node) {
     NodeList arguments = node.typeArguments;
     DartType typeArgument;
     if (arguments != null) {
       Link<Node> nodes = arguments.nodes;
       if (nodes.isEmpty) {
+        // The syntax [: <>[] :] is not allowed.
         error(arguments, MessageKind.MISSING_TYPE_ARGUMENT.error);
       } else {
-        typeArgument = resolveTypeRequired(nodes.head);
+        typeArgument = resolveTypeExpression(nodes.head);
         for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
-          error(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT.error);
-          resolveTypeRequired(nodes.head);
+          warning(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT.warning);
+          resolveTypeAnnotation(nodes.head);
         }
       }
     }
     DartType listType;
     if (typeArgument != null) {
       if (node.isConst() && typeArgument.containsTypeVariables) {
         compiler.reportError(arguments.nodes.head,
             MessageKind.TYPE_VARIABLE_IN_CONSTANT);
       }
       listType = new InterfaceType(compiler.listClass,
                                    new Link<DartType>.fromList([typeArgument]));
     } else {
       compiler.listClass.computeType(compiler);
       listType = compiler.listClass.rawType;
     }
     mapping.setType(node, listType);
     world.registerInstantiatedType(listType, mapping);
+    compiler.backend.registerRequiredType(listType, enclosingElement);
     visit(node.elements);
   }
 
   visitConditional(Conditional node) {
     node.visitChildren(this);
   }
 
   visitStringInterpolation(StringInterpolation node) {
     world.registerInstantiatedClass(compiler.stringClass, mapping);
     compiler.backend.registerStringInterpolation(mapping);
@@ skipping 161 matching lines @@
     }
   }
 
   visitLiteralMap(LiteralMap node) {
     NodeList arguments = node.typeArguments;
     DartType keyTypeArgument;
     DartType valueTypeArgument;
     if (arguments != null) {
       Link<Node> nodes = arguments.nodes;
       if (nodes.isEmpty) {
+        // The syntax [: <>{} :] is not allowed.
         error(arguments, MessageKind.MISSING_TYPE_ARGUMENT.error);
       } else {
-        keyTypeArgument = resolveTypeRequired(nodes.head);
+        keyTypeArgument = resolveTypeExpression(nodes.head);
         nodes = nodes.tail;
         if (nodes.isEmpty) {
-          error(arguments, MessageKind.MISSING_TYPE_ARGUMENT.error);
+          warning(arguments, MessageKind.MISSING_TYPE_ARGUMENT.warning);
         } else {
-          valueTypeArgument = resolveTypeRequired(nodes.head);
+          valueTypeArgument = resolveTypeExpression(nodes.head);
           for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
-            error(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT.error);
-            resolveTypeRequired(nodes.head);
+            warning(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT.warning);
+            resolveTypeAnnotation(nodes.head);
           }
         }
       }
     }
     DartType mapType;
     if (valueTypeArgument != null) {
       mapType = new InterfaceType(compiler.mapClass,
           new Link<DartType>.fromList([keyTypeArgument, valueTypeArgument]));
     } else {
       compiler.mapClass.computeType(compiler);
       mapType = compiler.mapClass.rawType;
     }
     if (node.isConst() && mapType.containsTypeVariables) {
       compiler.reportError(arguments,
           MessageKind.TYPE_VARIABLE_IN_CONSTANT);
     }
     mapping.setType(node, mapType);
     world.registerInstantiatedClass(compiler.mapClass, mapping);
     if (node.isConst()) {
       compiler.backend.registerConstantMap(mapping);
     }
+    compiler.backend.registerRequiredType(mapType, enclosingElement);
     node.visitChildren(this);
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     node.visitChildren(this);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
@@ skipping 125 matching lines @@
           }
           TypeAnnotation type = declaration.type;
           if (type != null) {
             error(type, MessageKind.PARAMETER_WITH_TYPE_IN_CATCH);
           }
         }
       }
     }
 
     Scope blockScope = new BlockScope(scope);
-    var wasTypeRequired = typeRequired;
-    typeRequired = true;
     doInCheckContext(() => visitIn(node.type, blockScope));
-    typeRequired = wasTypeRequired;
     visitIn(node.formals, blockScope);
     var oldInCatchBlock = inCatchBlock;
     inCatchBlock = true;
     visitIn(node.block, blockScope);
     inCatchBlock = oldInCatchBlock;
 
     if (node.type != null && exceptionDefinition != null) {
       DartType exceptionType = mapping.getType(node.type);
       Node exceptionVariable = exceptionDefinition.definitions.nodes.head;
       VariableElementX exceptionElement = mapping[exceptionVariable];
@@ skipping 37 matching lines @@
       TypeVariable typeNode = nodeLink.head;
       if (nameSet.contains(typeName)) {
         error(typeNode, MessageKind.DUPLICATE_TYPE_VARIABLE_NAME,
               {'typeVariableName': typeName});
       }
       nameSet.add(typeName);
 
       TypeVariableElement variableElement = typeVariable.element;
       if (typeNode.bound != null) {
         DartType boundType = typeResolver.resolveTypeAnnotation(
-            this, typeNode.bound, onFailure: dualWarning);
+            this, typeNode.bound);
         variableElement.bound = boundType;
 
         void checkTypeVariableBound() {
           Link<TypeVariableElement> seenTypeVariables =
               const Link<TypeVariableElement>();
           seenTypeVariables = seenTypeVariables.prepend(variableElement);
           DartType bound = boundType;
           while (bound.element.isTypeVariable()) {
             TypeVariableElement element = bound.element;
             if (seenTypeVariables.contains(element)) {
@@ skipping 251 matching lines @@
     return mixin;
   }
 
   DartType resolveType(TypeAnnotation node) {
     // TODO(johnniwinther): Report errors/warnings on resolution failures.
     return typeResolver.resolveTypeAnnotation(this, node);
   }
 
   DartType resolveSupertype(ClassElement cls, TypeAnnotation superclass) {
     DartType supertype = typeResolver.resolveTypeAnnotation(
-        this, superclass, onFailure: dualError);
+        this, superclass, malformedIsError: true);
     if (supertype != null) {
       if (identical(supertype.kind, TypeKind.MALFORMED_TYPE)) {
         // Error has already been reported.
         return null;
       } else if (!identical(supertype.kind, TypeKind.INTERFACE)) {
         // TODO(johnniwinther): Handle dynamic.
         error(superclass.typeName, MessageKind.CLASS_NAME_EXPECTED);
         return null;
       } else if (isBlackListed(supertype)) {
         error(superclass, MessageKind.CANNOT_EXTEND, {'type': supertype});
         return null;
       }
     }
     return supertype;
   }
 
   Link<DartType> resolveInterfaces(NodeList interfaces, Node superclass) {
     Link<DartType> result = const Link<DartType>();
     if (interfaces == null) return result;
     for (Link<Node> link = interfaces.nodes; !link.isEmpty; link = link.tail) {
       DartType interfaceType = typeResolver.resolveTypeAnnotation(
-          this, link.head, onFailure: dualError);
+          this, link.head, malformedIsError: true);
       if (interfaceType != null) {
         if (identical(interfaceType.kind, TypeKind.MALFORMED_TYPE)) {
           // Error has already been reported.
         } else if (!identical(interfaceType.kind, TypeKind.INTERFACE)) {
           // TODO(johnniwinther): Handle dynamic.
           TypeAnnotation typeAnnotation = link.head;
           error(typeAnnotation.typeName, MessageKind.CLASS_NAME_EXPECTED);
         } else {
           if (interfaceType == element.supertype) {
             compiler.reportError(
@@ skipping 95 matching lines @@
       supertypes = supertypes.tail;
     }
   }
 
   isBlackListed(DartType type) {
     LibraryElement lib = element.getLibrary();
     return
       !identical(lib, compiler.coreLibrary) &&
       !identical(lib, compiler.jsHelperLibrary) &&
       !identical(lib, compiler.interceptorsLibrary) &&
-      (identical(type.element, compiler.dynamicClass) ||
+      (identical(type, compiler.types.dynamicType) ||
        identical(type.element, compiler.boolClass) ||
        identical(type.element, compiler.numClass) ||
        identical(type.element, compiler.intClass) ||
        identical(type.element, compiler.doubleClass) ||
        identical(type.element, compiler.stringClass) ||
        identical(type.element, compiler.nullClass) ||
        identical(type.element, compiler.functionClass));
   }
 }
 
@@ skipping 423 matching lines @@
     // Find the unnamed constructor if the reference resolved to a
     // class.
     if (!Elements.isUnresolved(e) && e.isClass()) {
       ClassElement cls = e;
       cls.ensureResolved(compiler);
       // The unnamed constructor may not exist, so [e] may become unresolved.
       e = lookupConstructor(cls, diagnosticNode, const SourceString(''));
     }
     if (type == null) {
       if (Elements.isUnresolved(e)) {
-        type = compiler.dynamicClass.computeType(compiler);
+        type = compiler.types.dynamicType;
       } else {
         type = e.getEnclosingClass().computeType(compiler).asRaw();
       }
     }
     resolver.mapping.setType(expression, type);
     return e;
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
     assert(invariant(node, type == null));
-    type = resolver.resolveTypeRequired(node);
+    type = resolver.resolveTypeExpression(node);
+    compiler.backend.registerRequiredType(type, resolver.enclosingElement);
     return resolver.mapping[node];
   }
 
   visitSend(Send node) {
     Element e = visit(node.receiver);
     if (Elements.isUnresolved(e)) return e;
     Identifier name = node.selector.asIdentifier();
     if (name == null) internalError(node.selector, 'unexpected node');
 
     if (identical(e.kind, ElementKind.CLASS)) {
@@ skipping 41 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }