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 1250 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;

[ahe, 2013/02/05 11:26:29]

I don't think it is safe to call resolveTypeExpression from
resolveTypeAnnotation and vice versa. I cannot convince myself that is good. So
it would ease my mind if you could store the old value and restore it after the
call.

But no need to use try/finally.

+    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(

[ahe, 2013/02/05 11:26:29]

The old name was funnier ;-)

+          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 22 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) {

[ahe, 2013/02/05 11:26:29]

Please avoid for-in.

       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 855 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 319 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){

[ahe, 2013/02/05 11:26:29]

Please avoid for-in.

+      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 530 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }