Disable generic function types

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 225 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 4730 matching lines @@
   }
 
   /**
    * Parse a type.
    *
    *     type ::=
    *         typeWithoutFunction
    *       | functionType
    */
   TypeAnnotation parseTypeAnnotation(bool inExpression) {
-    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);
+    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;
     }
-    while (_atGenericFunctionTypeAfterReturnType(_currentToken)) {
-      type = parseGenericFunctionTypeAfterReturnType(type);
-    }
-    return type;
+    return parseTypeName(inExpression);
   }
 
   /**
    * 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) {
-    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);
+    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;
     }
-    while (next != null && _tokenMatchesString(next, 'Function')) {
-      next = skipGenericFunctionTypeAfterReturnType(next);
-    }
-    return next;
+    return skipTypeName(startToken);
   }
 
   /**
    * 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 2912 matching lines @@
    */
   Parser_SyntheticKeywordToken(Keyword keyword, int offset)
       : super(keyword, offset);
 
   @override
   int get length => 0;
 
   @override
   Token copy() => new Parser_SyntheticKeywordToken(keyword, offset);
 }