Give correct warnings/errors on type expressions.

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 1288 matching lines @@
     nestingLevel++;
   }
 
   void exitSwitch() {
     nestingLevel--;
     breakTargetStack = breakTargetStack.tail;
     labels = labels.outer;
   }
 }
 
+/**
+ * Interface for the predicates and methods needed by the [TypeResolver].
+ */
+abstract class TypeResolverContext {
+  Scope get scope;
+  Element get enclosingElement;
+
+  void error(Node node, MessageKind kind, [Map arguments = const {}]);
+  void warning(Node node, MessageKind kind, [Map arguments = const {}]);
+  void useType(Node node, DartType type);
+}
+
 class TypeResolver {
   final Compiler compiler;
+  TypeResolverContext context;
+  bool isTypeExpression;
 
   TypeResolver(this.compiler);
 
+  Scope get scope => context.scope;
+  Element get enclosingElement => context.enclosingElement;
+
+  void error(Node node, MessageKind kind, [Map arguments = const {}]) {
+    context.error(node, kind, arguments);
+  }
+
+  void warning(Node node, MessageKind kind, [Map arguments = const {}]) {
+    context.warning(node, kind, arguments);
+  }
+
+  void reportFailure(bool failureIsError,
+                     Node node, MessageKind kind, [Map arguments = const {}]) {
+    if (failureIsError) {
+      error(node, kind, arguments);
+    } else {
+      warning(node, kind, arguments);
+    }
+  }
+
+  void whenResolved(Node node, DartType type) {
+    context.useType(node, type);
+  }
+
   Element resolveTypeName(Scope scope,
                           SourceString prefixName,
                           Identifier typeName) {
     if (prefixName != null) {
       Element e = scope.lookup(prefixName);
       if (e != null) {
         if (identical(e.kind, ElementKind.PREFIX)) {
           // The receiver is a prefix. Lookup in the imported members.
           PrefixElement prefix = e;
           return prefix.lookupLocalMember(typeName.source);
@@ skipping 15 matching lines @@
         compiler.onDeprecatedFeature(typeName, 'Dynamic');
         return compiler.dynamicClass;
       } 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(
-      TypeAnnotation node,
-      Scope scope,
-      Element enclosingElement,
-      {onFailure(Node node, MessageKind kind, [Map arguments]),
-       whenResolved(Node node, DartType type)}) {
-    if (onFailure == null) {
-      onFailure = (n, k, [arguments]) {};
-    }
-    if (whenResolved == null) {
-      whenResolved = (n, t) {};
-    }
-    if (scope == null) {
-      compiler.internalError('resolveTypeAnnotation: no scope specified');
-    }
-    return resolveTypeAnnotationInContext(scope, node, enclosingElement,
-        onFailure, whenResolved);
+  DartType resolveTypeExpression(TypeAnnotation node) {
+    this.isTypeExpression = true;
+    return resolveTypeAnnotationInternal(node);
   }
 
-  DartType resolveTypeAnnotationInContext(Scope scope, TypeAnnotation node,
-                                          Element enclosingElement,
-                                          onFailure, whenResolved) {
+  DartType resolveTypeAnnotation(TypeAnnotation node) {
+    this.isTypeExpression = false;
+    return resolveTypeAnnotationInternal(node);
+  }
+
+  DartType resolveTypeAnnotationInternal(TypeAnnotation node) {
     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(scope, prefixName, typeName);
     DartType type;
 
-    DartType reportFailureAndCreateType(MessageKind messageKind,
+    DartType reportFailureAndCreateType(bool failureIsError,
+                                        MessageKind messageKind,
                                         Map messageArguments) {
-      onFailure(node, messageKind, messageArguments);
+      reportFailure(failureIsError, node, messageKind, messageArguments);
       var erroneousElement = new ErroneousElementX(
           messageKind, messageArguments, typeName.source, enclosingElement);
       var arguments = new LinkBuilder<DartType>();
-      resolveTypeArguments(
-          node, null, enclosingElement,
-          scope, onFailure, whenResolved, arguments);
+      resolveTypeArguments(node, null, arguments);
       return new MalformedType(erroneousElement, null, arguments.toLink());
     }
 
     DartType checkNoTypeArguments(DartType type) {
       var arguments = new LinkBuilder<DartType>();
-      bool hashTypeArgumentMismatch = resolveTypeArguments(
-          node, const Link<DartType>(), enclosingElement,
-          scope, onFailure, whenResolved, arguments);
-      if (hashTypeArgumentMismatch) {
+      bool hasTypeArgumentMismatch = resolveTypeArguments(
+          node, const Link<DartType>(), arguments);
+      if (hasTypeArgumentMismatch) {
         type = new MalformedType(
             new ErroneousElementX(MessageKind.TYPE_ARGUMENT_COUNT_MISMATCH,
                 {'type': node}, typeName.source, enclosingElement),
                 type, arguments.toLink());
       }
       return type;
     }
 
     if (element == null) {
-      type = reportFailureAndCreateType(
+      type = reportFailureAndCreateType(false,
           MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.typeName});
     } else if (element.isAmbiguous()) {
       AmbiguousElement ambiguous = element;
-      type = reportFailureAndCreateType(
+      type = reportFailureAndCreateType(isTypeExpression,
           ambiguous.messageKind, ambiguous.messageArguments);
     } else if (!element.impliesType()) {
-      type = reportFailureAndCreateType(
+      type = reportFailureAndCreateType(false,
           MessageKind.NOT_A_TYPE, {'node': node.typeName});
     } else {
       if (identical(element, compiler.types.voidType.element) ||
           identical(element, compiler.types.dynamicType.element)) {
         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(
-            node, cls.typeVariables, enclosingElement,
-            scope, onFailure, whenResolved, arguments);
-        if (hashTypeArgumentMismatch) {
+        bool hasTypeArgumentMismatch = resolveTypeArguments(
+            node, cls.typeVariables, arguments);
+        if (hasTypeArgumentMismatch) {
           type = new MalformedType(
               new ErroneousElementX(MessageKind.TYPE_ARGUMENT_COUNT_MISMATCH,
                   {'type': node}, typeName.source, enclosingElement),
               new InterfaceType(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(
-            node, typdef.typeVariables, enclosingElement,
-            scope, onFailure, whenResolved, arguments);
+            node, typdef.typeVariables, arguments);
         if (hashTypeArgumentMismatch) {
           type = new MalformedType(
               new ErroneousElementX(MessageKind.TYPE_ARGUMENT_COUNT_MISMATCH,
                   {'type': node}, typeName.source, enclosingElement),
               new TypedefType(typdef, arguments.toLink()));
         } else {
           if (arguments.isEmpty) {
             type = typdef.rawType;
           } else {
            type = new TypedefType(typdef, arguments.toLink());
@@ skipping 23 matching lines @@
     whenResolved(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(
-      TypeAnnotation node,
-      Link<DartType> typeVariables,
-      Element enclosingElement,
-      Scope scope,
-      onFailure, whenResolved,
-      LinkBuilder<DartType> arguments) {
+  bool resolveTypeArguments(TypeAnnotation node,
+                            Link<DartType> typeVariables,
+                            LinkBuilder<DartType> arguments) {
     if (node.typeArguments == null) {
       return false;
     }
     bool typeArgumentCountMismatch = false;
-    for (Link<Node> typeArguments = node.typeArguments.nodes;
-         !typeArguments.isEmpty;
-         typeArguments = typeArguments.tail) {
+    for (Node typeArgument in node.typeArguments.nodes) {
       if (typeVariables != null && typeVariables.isEmpty) {
-        onFailure(typeArguments.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
+        reportFailure(isTypeExpression,
+                      typeArgument, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
         typeArgumentCountMismatch = true;
       }
-      DartType argType = resolveTypeAnnotationInContext(scope,
-                                                        typeArguments.head,
-                                                        enclosingElement,
-                                                        onFailure,
-                                                        whenResolved);
+      DartType argType = resolveTypeAnnotationInternal(typeArgument);
       arguments.addLast(argType);
       if (typeVariables != null && !typeVariables.isEmpty) {
         typeVariables = typeVariables.tail;
       }
     }
     if (typeVariables != null && !typeVariables.isEmpty) {
-      onFailure(node.typeArguments, MessageKind.MISSING_TYPE_ARGUMENT);
+      reportFailure(isTypeExpression,
+                    node.typeArguments, MessageKind.MISSING_TYPE_ARGUMENT);
       typeArgumentCountMismatch = true;
     }
     return typeArgumentCountMismatch;
   }
 }
 
 /**
  * Core implementation of resolution.
  *
  * Do not subclass or instantiate this class outside this library
  * except for testing.
  */
-class ResolverVisitor extends CommonResolverVisitor<Element> {
+class ResolverVisitor extends CommonResolverVisitor<Element>
+    implements TypeResolverContext {
   final TreeElementMapping mapping;
   Element enclosingElement;
   final TypeResolver typeResolver;
   bool inInstanceContext;
   bool inCheckContext;
   bool inCatchBlock;
   Scope scope;
   ClassElement currentClass;
   ExpressionStatement currentExpressionStatement;
   bool typeRequired = false;
   StatementScope statementScope;
   int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION
       | ElementCategory.IMPLIES_TYPE;
 
   ResolverVisitor(Compiler compiler, Element element, this.mapping)
     : this.enclosingElement = element,
       // When the element is a field, we are actually resolving its
       // initial value, which should not have access to instance
       // fields.
       inInstanceContext = (element.isInstanceMember() && !element.isField())
           || element.isGenerativeConstructor(),
       this.currentClass = element.isMember() ? element.getEnclosingClass()
                                              : null,
       this.statementScope = new StatementScope(),
       typeResolver = new TypeResolver(compiler),
       scope = element.buildScope(),
       inCheckContext = compiler.enableTypeAssertions,
       inCatchBlock = false,
-      super(compiler);
+      super(compiler) {
+    typeResolver.context = this;
+  }
 
   ResolutionEnqueuer get world => compiler.enqueuer.resolution;
 
   Element lookup(Node node, SourceString name) {
     Element result = scope.lookup(name);
     if (!Elements.isUnresolved(result)) {
       if (!inInstanceContext && result.isInstanceMember()) {
         compiler.reportErrorCode(
             node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': name});
         return new ErroneousElementX(MessageKind.NO_INSTANCE_AVAILABLE,
@@ skipping 877 matching lines @@
           argument.element.enclosingElement);
     } else if (argument is InterfaceType) {
       InterfaceType type = argument;
       type.typeArguments.forEach((DartType argument) {
         analyzeTypeArgument(type, argument);
       });
     }
   }
 
   DartType resolveTypeAnnotation(TypeAnnotation node) {
-    Function report = typeRequired ? error : warning;
-    DartType type = typeResolver.resolveTypeAnnotation(
-        node, scope, enclosingElement,
-        onFailure: report, whenResolved: useType);
+    DartType type = typeRequired ?
+        typeResolver.resolveTypeExpression(node) :
+        typeResolver.resolveTypeAnnotation(node);
     if (type == null) return null;
     if (inCheckContext) {
       compiler.enqueuer.resolution.registerIsCheck(type);
     }
     if (typeRequired || inCheckContext) {
       if (type is InterfaceType) {
         InterfaceType itf = type;
         itf.typeArguments.forEach((DartType argument) {
           analyzeTypeArgument(type, argument);
         });
@@ skipping 330 matching lines @@
     inCatchBlock = true;
     visitIn(node.block, blockScope);
     inCatchBlock = oldInCatchBlock;
   }
 
   visitTypedef(Typedef node) {
     unimplemented(node, 'typedef');
   }
 }
 
-class TypeDefinitionVisitor extends CommonResolverVisitor<DartType> {
+class TypeDefinitionVisitor extends CommonResolverVisitor<DartType>
+    implements TypeResolverContext {
   Scope scope;
-  TypeDeclarationElement element;
+  final TypeDeclarationElement element;
   TypeResolver typeResolver;
+  Element get enclosingElement => element;
 
   TypeDefinitionVisitor(Compiler compiler, TypeDeclarationElement element)
       : this.element = element,
         scope = Scope.buildEnclosingScope(element),
         typeResolver = new TypeResolver(compiler),
-        super(compiler);
+        super(compiler) {
+    typeResolver.context = this;
+  }
+
+  void useType(Node node, DartType type) {
+    // Do not register used types.
+  }
 
   void resolveTypeVariableBounds(NodeList node) {
     if (node == null) return;
 
     var nameSet = new Set<SourceString>();
     // Resolve the bounds of type variables.
     Link<DartType> typeLink = element.typeVariables;
     Link<Node> nodeLink = node.nodes;
     while (!nodeLink.isEmpty) {
       TypeVariableType typeVariable = typeLink.head;
       SourceString typeName = typeVariable.name;
       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(
-            typeNode.bound, scope, element, onFailure: warning);
+        DartType boundType = typeResolver.resolveTypeAnnotation(typeNode.bound);
         if (boundType != null && boundType.element == variableElement) {
           // TODO(johnniwinther): Check for more general cycles, like
           // [: <A extends B, B extends C, C extends B> :].
           warning(node, MessageKind.CYCLIC_TYPE_VARIABLE,
                   {'typeVariableName': variableElement.name});
         } else if (boundType != null) {
           variableElement.bound = boundType;
         } else {
           // TODO(johnniwinther): Should be an erroneous type.
           variableElement.bound = compiler.objectClass.computeType(compiler);
@@ skipping 56 matching lines @@
     // TODO(ahe): It is not safe to call resolveTypeVariableBounds yet.
     // As a side-effect, this may get us back here trying to
     // resolve this class again.
     resolveTypeVariableBounds(node.typeParameters);
 
     // Setup the supertype for the element.
     assert(element.supertype == null);
     if (node.superclass != null) {
       MixinApplication superMixin = node.superclass.asMixinApplication();
       if (superMixin != null) {
-        DartType supertype = resolveSupertype(element, superMixin.superclass);
+        DartType supertype = resolveSupertype(superMixin.superclass);
         Link<Node> link = superMixin.mixins.nodes;
         while (!link.isEmpty) {
           supertype = applyMixin(supertype, visit(link.head));
           link = link.tail;
         }
         element.supertype = supertype;
       } else {
-        element.supertype = resolveSupertype(element, node.superclass);
+        element.supertype = resolveSupertype(node.superclass);
       }
     }
 
     // If the super type isn't specified, we make it Object.
     final objectElement = compiler.objectClass;
     if (!identical(element, objectElement) && element.supertype == null) {
       if (objectElement == null) {
         compiler.internalError("Internal error: cannot resolve Object",
                                node: node);
       } else {
@@ skipping 16 matching lines @@
   DartType visitNamedMixinApplication(NamedMixinApplication node) {
     compiler.ensure(element != null);
     compiler.ensure(element.resolutionState == STATE_STARTED);
 
     InterfaceType type = element.computeType(compiler);
     scope = new TypeDeclarationScope(scope, element);
     resolveTypeVariableBounds(node.typeParameters);
 
     // Generate anonymous mixin application elements for the
     // intermediate mixin applications (excluding the last).
-    DartType supertype = resolveSupertype(element, node.superclass);
+    DartType supertype = resolveSupertype(node.superclass);
     Link<Node> link = node.mixins.nodes;
     while (!link.tail.isEmpty) {
       supertype = applyMixin(supertype, visit(link.head));
       link = link.tail;
     }
     doApplyMixinTo(element, supertype, visit(link.head));
     return element.computeType(compiler);
   }
 
   DartType applyMixin(DartType supertype, DartType mixinType) {
@@ skipping 108 matching lines @@
     Identifier selector = node.selector.asIdentifier();
     var e = prefixElement.lookupLocalMember(selector.source);
     if (e == null || !e.impliesType()) {
       error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE,
             {'typeName': node.selector});
       return null;
     }
     return e.computeType(compiler);
   }
 
-  DartType resolveSupertype(ClassElement cls, TypeAnnotation superclass) {
-    DartType supertype = typeResolver.resolveTypeAnnotation(
-        superclass, scope, cls, onFailure: error);
+  DartType resolveSupertype(TypeAnnotation superclass) {
+    DartType supertype = typeResolver.resolveTypeExpression(superclass);
     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(
-          link.head, scope, element, onFailure: error);
+    for (TypeAnnotation interface in interfaces.nodes){
+      DartType interfaceType = typeResolver.resolveTypeExpression(interface);
       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);
+          error(interface.typeName, MessageKind.CLASS_NAME_EXPECTED);
         } else {
           if (interfaceType == element.supertype) {
             compiler.reportErrorCode(
                 superclass,
                 MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS,
                 {'type': interfaceType});
             compiler.reportErrorCode(
-                link.head,
+                interface,
                 MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS,
                 {'type': interfaceType});
           }
           if (result.contains(interfaceType)) {
             compiler.reportErrorCode(
-                link.head,
+                interface,
                 MessageKind.DUPLICATE_IMPLEMENTS,
                 {'type': interfaceType});
           }
           result = result.prepend(interfaceType);
           if (isBlackListed(interfaceType)) {
-            error(link.head, MessageKind.CANNOT_IMPLEMENT,
+            error(interface, MessageKind.CANNOT_IMPLEMENT,
                   {'type': interfaceType});
           }
         }
       }
     }
     return result;
   }
 
   void calculateAllSupertypes(ClassElement cls) {
     // TODO(karlklose): Check if type arguments match, if a class
@@ skipping 535 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }