Reapply "Add support for generic function type syntax, part 1"

pkg/analyzer/test/generated/resolver_test.dart

 // Copyright (c) 2014, 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.
 
 library analyzer.test.generated.resolver_test;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 394 matching lines @@
    */
   List<Expression> _unresolvedExpressions = new List<Expression>();
 
   /**
    * A list containing all of the AST Expression nodes for which a propagated type was computed but
    * where that type was not more specific than the static type.
    */
   List<Expression> _invalidlyPropagatedExpressions = new List<Expression>();
 
   /**
-   * A list containing all of the AST TypeName nodes that were not resolved.
+   * The TypeAnnotation nodes that were not resolved.
    */
-  List<TypeName> _unresolvedTypes = new List<TypeName>();
+  List<TypeAnnotation> _unresolvedTypes = new List<TypeAnnotation>();
 
   /**
    * Counter for the number of Expression nodes visited that are resolved.
    */
   int _resolvedExpressionCount = 0;
 
   /**
    * Counter for the number of Expression nodes visited that have propagated type information.
    */
   int _propagatedExpressionCount = 0;
 
   /**
    * Counter for the number of TypeName nodes visited that are resolved.
    */
   int _resolvedTypeCount = 0;
 
   /**
    * Assert that all of the visited nodes have a static type associated with them.
    */
   void assertResolved() {
     if (!_unresolvedExpressions.isEmpty || !_unresolvedTypes.isEmpty) {
       StringBuffer buffer = new StringBuffer();
       int unresolvedTypeCount = _unresolvedTypes.length;
       if (unresolvedTypeCount > 0) {
         buffer.write("Failed to resolve ");
         buffer.write(unresolvedTypeCount);
         buffer.write(" of ");
         buffer.write(_resolvedTypeCount + unresolvedTypeCount);
         buffer.writeln(" type names:");
-        for (TypeName identifier in _unresolvedTypes) {
+        for (TypeAnnotation identifier in _unresolvedTypes) {
           buffer.write("  ");
           buffer.write(identifier.toString());
           buffer.write(" (");
           buffer.write(_getFileName(identifier));
           buffer.write(" : ");
           buffer.write(identifier.offset);
           buffer.writeln(")");
         }
       }
       int unresolvedExpressionCount = _unresolvedExpressions.length;
@@ skipping 113 matching lines @@
         identical(node, parent.fieldName)) {
       return null;
     } else if (node.staticElement is PrefixElement) {
       // Prefixes don't have a type.
       return null;
     }
     return super.visitSimpleIdentifier(node);
   }
 
   @override
+  Object visitTypeAnnotation(TypeAnnotation node) {
+    if (node.type == null) {
+      _unresolvedTypes.add(node);
+    } else {
+      _resolvedTypeCount++;
+    }
+    return super.visitTypeAnnotation(node);
+  }
+
+  @override
   Object visitTypeName(TypeName node) {
     // Note: do not visit children from this node, the child SimpleIdentifier in
     // TypeName (i.e. "String") does not have a static type defined.
+    // TODO(brianwilkerson) Not visiting the children means that we won't catch
+    // type arguments that were not resolved.
     if (node.type == null) {
       _unresolvedTypes.add(node);
     } else {
       _resolvedTypeCount++;
     }
     return null;
   }
 
   String _getFileName(AstNode node) {
     // TODO (jwren) there are two copies of this method, one here and one in
@@ skipping 2996 matching lines @@
  */
 class _StaleElement extends ElementImpl {
   _StaleElement() : super("_StaleElement", -1);
 
   @override
   get kind => throw "_StaleElement's kind shouldn't be accessed";
 
   @override
   /*=T*/ accept/*<T>*/(_) => throw "_StaleElement shouldn't be visited";
 }