Revert "Add support for generic function type syntax, part 1" (TBR)

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:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
@@ skipping 392 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>();
 
   /**
-   * The TypeAnnotation nodes that were not resolved.
+   * A list containing all of the AST TypeName nodes that were not resolved.
    */
-  List<TypeAnnotation> _unresolvedTypes = new List<TypeAnnotation>();
+  List<TypeName> _unresolvedTypes = new List<TypeName>();
 
   /**
    * 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 (TypeAnnotation identifier in _unresolvedTypes) {
+        for (TypeName 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 3118 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";
 }