Re-enable generic function type support in analyzer

pkg/analyzer/lib/src/generated/parser.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.src.generated.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 231 matching lines @@
    */
   bool _inSwitch = false;
 
   /**
    * A flag indicating whether the parser is currently in a constructor field
    * initializer, with no intervening parentheses, braces, or brackets.
    */
   bool _inInitializer = false;
 
   /**
-   * A flag indicating whether the parser is to parse generic function type
-   * syntax.
-   */
-  bool parseGenericFunctionTypes = false;
-
-  /**
    * A flag indicating whether the parser is to parse generic method syntax.
    */
   @deprecated
   bool parseGenericMethods = false;
 
   /**
    * A flag indicating whether to parse generic method comments, of the form
    * `/*=T*/` and `/*<T>*/`.
    */
   bool parseGenericMethodComments = false;
@@ skipping 4782 matching lines @@
   }
 
   /**
    * Parse a type.
    *
    *     type ::=
    *         typeWithoutFunction
    *       | functionType
    */
   TypeAnnotation parseTypeAnnotation(bool inExpression) {
-    if (parseGenericFunctionTypes) {
-      TypeAnnotation type = null;
-      if (_atGenericFunctionTypeAfterReturnType(_currentToken)) {
-        // Generic function type with no return type.
-        type = parseGenericFunctionTypeAfterReturnType(null);
-      } else if (_currentToken.keyword == Keyword.VOID &&
-          _atGenericFunctionTypeAfterReturnType(_currentToken.next)) {
-        type = astFactory.typeName(
-            astFactory.simpleIdentifier(getAndAdvance()), null);
-      } else {
-        type = parseTypeName(inExpression);
-      }
-      while (_atGenericFunctionTypeAfterReturnType(_currentToken)) {
-        type = parseGenericFunctionTypeAfterReturnType(type);
-      }
-      return type;
+    TypeAnnotation type = null;
+    if (_atGenericFunctionTypeAfterReturnType(_currentToken)) {
+      // Generic function type with no return type.
+      type = parseGenericFunctionTypeAfterReturnType(null);
+    } else if (_currentToken.keyword == Keyword.VOID &&
+        _atGenericFunctionTypeAfterReturnType(_currentToken.next)) {
+      type = astFactory.typeName(
+          astFactory.simpleIdentifier(getAndAdvance()), null);
+    } else {
+      type = parseTypeName(inExpression);
     }
-    return parseTypeName(inExpression);
+    while (_atGenericFunctionTypeAfterReturnType(_currentToken)) {
+      type = parseGenericFunctionTypeAfterReturnType(type);
+    }
+    return type;
   }
 
   /**
    * Parse a list of type arguments. Return the type argument list that was
    * parsed.
    *
    * This method assumes that the current token matches `TokenType.LT`.
    *
    *     typeArguments ::=
    *         '<' typeList '>'
@@ skipping 440 matching lines @@
 
   /**
    * Parse a type annotation, starting at the [startToken], without actually
    * creating a type annotation or changing the current token. Return the token
    * following the type annotation that was parsed, or `null` if the given token
    * is not the first token in a valid type annotation.
    *
    * This method must be kept in sync with [parseTypeAnnotation].
    */
   Token skipTypeAnnotation(Token startToken) {
-    if (parseGenericFunctionTypes) {
-      Token next = null;
-      if (_atGenericFunctionTypeAfterReturnType(startToken)) {
-        next = skipGenericFunctionTypeAfterReturnType(startToken);
-      } else if (_currentToken.keyword == Keyword.VOID &&
-          _atGenericFunctionTypeAfterReturnType(_currentToken.next)) {
-        next = next.next;
-      } else {
-        next = skipTypeName(startToken);
-      }
-      while (next != null && _tokenMatchesString(next, 'Function')) {
-        next = skipGenericFunctionTypeAfterReturnType(next);
-      }
-      return next;
+    Token next = null;
+    if (_atGenericFunctionTypeAfterReturnType(startToken)) {
+      next = skipGenericFunctionTypeAfterReturnType(startToken);
+    } else if (_currentToken.keyword == Keyword.VOID &&
+        _atGenericFunctionTypeAfterReturnType(_currentToken.next)) {
+      next = next.next;
+    } else {
+      next = skipTypeName(startToken);
     }
-    return skipTypeName(startToken);
+    while (next != null && _atGenericFunctionTypeAfterReturnType(next)) {
+      next = skipGenericFunctionTypeAfterReturnType(next);
+    }
+    return next;
   }
 
   /**
    * Parse a list of type arguments, starting at the [startToken], without
    * actually creating a type argument list or changing the current token.
    * Return the token following the type argument list that was parsed, or
    * `null` if the given token is not the first token in a valid type argument
    * list.
    *
    * This method must be kept in sync with [parseTypeArgumentList].
@@ skipping 2941 matching lines @@
    */
   Parser_SyntheticKeywordToken(Keyword keyword, int offset)
       : super(keyword, offset);
 
   @override
   int get length => 0;
 
   @override
   Token copy() => new Parser_SyntheticKeywordToken(keyword, offset);
 }