Fix more parser bugs

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 524 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 (_atGenericFunctionTypeAfterReturnType(token)) {
+    while (_atGenericFunctionTypeAfterReturnType(token)) {
       token = skipGenericFunctionTypeAfterReturnType(token);
       if (token == null) {
         // There was no type name, so this can't be a declaration.
         return false;
       }
     }
     if (token.type != TokenType.IDENTIFIER) {
       allowAdditionalTokens = false;
     }
     token = skipSimpleIdentifier(token);
@@ skipping 3498 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 4470 matching lines @@
     }
     if (modifiers.finalKeyword != null) {
       _reportErrorForToken(
           ParserErrorCode.FINAL_TYPEDEF, modifiers.finalKeyword);
     }
     if (modifiers.varKeyword != null) {
       _reportErrorForToken(ParserErrorCode.VAR_TYPEDEF, modifiers.varKeyword);
     }
   }
 }