More parser fixes for 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 406 matching lines @@
   /**
    * Return `true` if the current token appears to be the beginning of a
    * function declaration.
    */
   bool isFunctionDeclaration() {
     Keyword keyword = _currentToken.keyword;
     if (keyword == Keyword.VOID) {
       return true;
     }
     Token afterReturnType = skipTypeName(_currentToken);
+    if (afterReturnType != null &&
+        _tokenMatchesKeyword(afterReturnType, Keyword.FUNCTION)) {
+      afterReturnType = skipGenericFunctionTypeAfterReturnType(afterReturnType);
+    }
     if (afterReturnType == null) {
       // There was no return type, but it is optional, so go back to where we
       // started.
       afterReturnType = _currentToken;
     }
     Token afterIdentifier = skipSimpleIdentifier(afterReturnType);
     if (afterIdentifier == null) {
       // It's possible that we parsed the function name as if it were a type
       // name, so see whether it makes sense if we assume that there is no type.
       afterIdentifier = skipSimpleIdentifier(_currentToken);
@@ skipping 94 matching lines @@
     // We know that we have an identifier, and need to see whether it might be
     // a type name.
     if (_currentToken.type != TokenType.IDENTIFIER) {
       allowAdditionalTokens = false;
     }
     Token token = skipTypeName(_currentToken);
     if (token == null) {
       // There was no type name, so this can't be a declaration.
       return false;
     }
+    if (_tokenMatchesKeyword(token, Keyword.FUNCTION)) {
+      token = skipGenericFunctionTypeAfterReturnType(token);
+    }
     if (token.type != TokenType.IDENTIFIER) {
       allowAdditionalTokens = false;
     }
     token = skipSimpleIdentifier(token);
     if (token == null) {
       return false;
     }
     TokenType type = token.type;
     // Usual cases in valid code:
     //     String v = '';
@@ skipping 714 matching lines @@
       } else if (_matchesIdentifier() &&
           _peek().matchesAny(const <TokenType>[
             TokenType.OPEN_PAREN,
             TokenType.OPEN_CURLY_BRACKET,
             TokenType.FUNCTION,
             TokenType.LT
           ])) {
         _validateModifiersForGetterOrSetterOrMethod(modifiers);
         return _parseMethodDeclarationAfterReturnType(commentAndMetadata,
             modifiers.externalKeyword, modifiers.staticKeyword, returnType);
+      } else if (_matchesIdentifier() &&
+          _peek().matchesAny(const <TokenType>[
+            TokenType.EQ,
+            TokenType.COMMA,
+            TokenType.SEMICOLON
+          ])) {
+        if (returnType is! GenericFunctionType) {
+          _reportErrorForNode(ParserErrorCode.VOID_VARIABLE, returnType);
+        }
+        return parseInitializedIdentifierList(
+            commentAndMetadata,
+            modifiers.staticKeyword,
+            modifiers.covariantKeyword,
+            _validateModifiersForField(modifiers),
+            returnType);
       } else {
         //
         // We have found an error of some kind. Try to recover.
         //
-        if (_matchesIdentifier()) {
-          if (_peek().matchesAny(const <TokenType>[
-            TokenType.EQ,
-            TokenType.COMMA,
-            TokenType.SEMICOLON
-          ])) {
-            //
-            // We appear to have a variable declaration with a type of "void".
-            //
-            _reportErrorForNode(ParserErrorCode.VOID_VARIABLE, returnType);
-            return parseInitializedIdentifierList(
-                commentAndMetadata,
-                modifiers.staticKeyword,
-                modifiers.covariantKeyword,
-                _validateModifiersForField(modifiers),
-                returnType);
-          }
-        }
         if (_isOperator(_currentToken)) {
           //
           // We appear to have found an operator declaration without the
           // 'operator' keyword.
           //
           _validateModifiersForOperator(modifiers);
           return parseOperator(
               commentAndMetadata, modifiers.externalKeyword, returnType);
         }
         _reportErrorForToken(
@@ skipping 764 matching lines @@
       } else if (_matchesIdentifier() &&
           next.matchesAny(const <TokenType>[
             TokenType.OPEN_PAREN,
             TokenType.OPEN_CURLY_BRACKET,
             TokenType.FUNCTION,
             TokenType.LT
           ])) {
         _validateModifiersForTopLevelFunction(modifiers);
         return parseFunctionDeclaration(
             commentAndMetadata, modifiers.externalKeyword, returnType);
+      } else if (_matchesIdentifier() &&
+          next.matchesAny(const <TokenType>[
+            TokenType.EQ,
+            TokenType.COMMA,
+            TokenType.SEMICOLON
+          ])) {
+        if (returnType is! GenericFunctionType) {
+          _reportErrorForNode(ParserErrorCode.VOID_VARIABLE, returnType);
+        }
+        return astFactory.topLevelVariableDeclaration(
+            commentAndMetadata.comment,
+            commentAndMetadata.metadata,
+            parseVariableDeclarationListAfterType(
+                null, _validateModifiersForTopLevelVariable(modifiers), null),
+            _expect(TokenType.SEMICOLON));
       } else {
         //
         // We have found an error of some kind. Try to recover.
         //
-        if (_matchesIdentifier()) {
-          if (next.matchesAny(const <TokenType>[
-            TokenType.EQ,
-            TokenType.COMMA,
-            TokenType.SEMICOLON
-          ])) {
-            //
-            // We appear to have a variable declaration with a type of "void".
-            //
-            _reportErrorForNode(ParserErrorCode.VOID_VARIABLE, returnType);
-            return astFactory.topLevelVariableDeclaration(
-                commentAndMetadata.comment,
-                commentAndMetadata.metadata,
-                parseVariableDeclarationListAfterType(null,
-                    _validateModifiersForTopLevelVariable(modifiers), null),
-                _expect(TokenType.SEMICOLON));
-          }
-        }
         _reportErrorForToken(
             ParserErrorCode.EXPECTED_EXECUTABLE, _currentToken);
         return null;
       }
     } else if ((keyword == Keyword.GET || keyword == Keyword.SET) &&
         _tokenMatchesIdentifier(next)) {
       _validateModifiersForTopLevelFunction(modifiers);
       return parseFunctionDeclaration(
           commentAndMetadata, modifiers.externalKeyword, null);
     } else if (keyword == Keyword.OPERATOR && _isOperator(next)) {
@@ skipping 2018 matching lines @@
       Token next = _currentToken.next;
       if (_matchesIdentifier() &&
           next.matchesAny(const <TokenType>[
             TokenType.OPEN_PAREN,
             TokenType.OPEN_CURLY_BRACKET,
             TokenType.FUNCTION,
             TokenType.LT
           ])) {
         return _parseFunctionDeclarationStatementAfterReturnType(
             commentAndMetadata, returnType);
+      } else if (_matchesIdentifier() &&
+          next.matchesAny(const <TokenType>[
+            TokenType.EQ,
+            TokenType.COMMA,
+            TokenType.SEMICOLON
+          ])) {
+        if (returnType is! GenericFunctionType) {
+          _reportErrorForNode(ParserErrorCode.VOID_VARIABLE, returnType);
+        }
+        return _parseVariableDeclarationStatementAfterType(
+            commentAndMetadata, null, returnType);
       } else {
         //
         // We have found an error of some kind. Try to recover.
         //
-        if (_matchesIdentifier()) {
-          if (next.matchesAny(const <TokenType>[
-            TokenType.EQ,
-            TokenType.COMMA,
-            TokenType.SEMICOLON
-          ])) {
-            //
-            // We appear to have a variable declaration with a type of "void".
-            //
-            _reportErrorForNode(ParserErrorCode.VOID_VARIABLE, returnType);
-            return parseVariableDeclarationStatementAfterMetadata(
-                commentAndMetadata);
-          }
-        } else if (_matches(TokenType.CLOSE_CURLY_BRACKET)) {
+        if (_matches(TokenType.CLOSE_CURLY_BRACKET)) {
           //
           // We appear to have found an incomplete statement at the end of a
           // block. Parse it as a variable declaration.
           //
           return _parseVariableDeclarationStatementAfterType(
               commentAndMetadata, null, returnType);
         }
         _reportErrorForCurrentToken(ParserErrorCode.MISSING_STATEMENT);
         // TODO(brianwilkerson) Recover from this error.
         return astFactory
@@ skipping 1308 matching lines @@
    * actually creating a formal parameter list or changing the current token.
    * Return the token following the parameter list that was parsed, or `null`
    * if the given token is not the first token in a valid parameter list.
    *
    * This method must be kept in sync with [parseFormalParameterList].
    */
   Token skipFormalParameterList(Token startToken) {
     if (!_tokenMatches(startToken, TokenType.OPEN_PAREN)) {
       return null;
     }
-    return (startToken as BeginToken).endToken;
+    return (startToken as BeginToken).endToken.next;
   }
 
   /**
    * Parse the portion of a generic function type after the return type,
    * starting at the [startToken], without actually creating a generic function
    * type or changing the current token. Return the token following the generic
    * function type that was parsed, or `null` if the given token is not the
    * first token in a valid generic function type.
    *
    * This method must be kept in sync with
@@ skipping 2092 matching lines @@
    * metadata to be associated with the variable declaration statement, or
    * `null` if there is no attempt at parsing the comment and metadata. The
    * [keyword] is the token representing the 'final', 'const' or 'var' keyword,
    * or `null` if there is no keyword. The [type] is the type of the variables
    * in the list. Return the variable declaration statement that was parsed.
    *
    *     variableDeclarationStatement ::=
    *         variableDeclarationList ';'
    */
   VariableDeclarationStatement _parseVariableDeclarationStatementAfterType(
-      CommentAndMetadata commentAndMetadata, Token keyword, TypeName type) {
+      CommentAndMetadata commentAndMetadata,
+      Token keyword,
+      TypeAnnotation type) {
     VariableDeclarationList variableList =
         parseVariableDeclarationListAfterType(
             commentAndMetadata, keyword, type);
     Token semicolon = _expect(TokenType.SEMICOLON);
     return astFactory.variableDeclarationStatement(variableList, semicolon);
   }
 
   /**
    * Return the token that is immediately after the current token. This is
    * equivalent to [_peekAt](1).
@@ skipping 946 matching lines @@
     }
     if (modifiers.finalKeyword != null) {
       _reportErrorForToken(
           ParserErrorCode.FINAL_TYPEDEF, modifiers.finalKeyword);
     }
     if (modifiers.varKeyword != null) {
       _reportErrorForToken(ParserErrorCode.VAR_TYPEDEF, modifiers.varKeyword);
     }
   }
 }