Fix for issue 19100 - better recovery

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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser;
 
 import 'dart:collection';
@@ skipping 2273 matching lines @@
    * </pre>
    *
    * @return the formal parameters that were parsed
    */
   FormalParameterList parseFormalParameterList() {
     Token leftParenthesis = _expect(TokenType.OPEN_PAREN);
     if (_matches(TokenType.CLOSE_PAREN)) {
       return new FormalParameterList(leftParenthesis, null, null, null, andAdvance);
     }
     //
-    // Even though it is invalid to have default parameters outside of brackets, required parameters
-    // inside of brackets, or multiple groups of default and named parameters, we allow all of these
-    // cases so that we can recover better.
+    // Even though it is invalid to have default parameters outside of brackets,
+    // required parameters inside of brackets, or multiple groups of default and
+    // named parameters, we allow all of these cases so that we can recover
+    // better.
     //
     List<FormalParameter> parameters = new List<FormalParameter>();
     List<FormalParameter> normalParameters = new List<FormalParameter>();
     List<FormalParameter> positionalParameters = new List<FormalParameter>();
     List<FormalParameter> namedParameters = new List<FormalParameter>();
     List<FormalParameter> currentParameters = normalParameters;
     Token leftSquareBracket = null;
     Token rightSquareBracket = null;
     Token leftCurlyBracket = null;
     Token rightCurlyBracket = null;
@@ skipping 213 matching lines @@
    * @return the map literal entry that was parsed
    */
   MapLiteralEntry parseMapLiteralEntry() {
     Expression key = parseExpression2();
     Token separator = _expect(TokenType.COLON);
     Expression value = parseExpression2();
     return new MapLiteralEntry(key, separator, value);
   }
 
   /**
-   * Parse a normal formal parameter.
+   * Parse a normal formal parameter and return the normal formal parameter that
+   * was parsed.
    *
    * <pre>
    * normalFormalParameter ::=
    *     functionSignature
    *   | fieldFormalParameter
    *   | simpleFormalParameter
    *
    * functionSignature:
    *     metadata returnType? identifier formalParameterList
    *
    * fieldFormalParameter ::=
    *     metadata finalConstVarOrType? 'this' '.' identifier
    *
    * simpleFormalParameter ::=
    *     declaredIdentifier
    *   | metadata identifier
    * </pre>
-   *
-   * @return the normal formal parameter that was parsed
    */
   NormalFormalParameter parseNormalFormalParameter() {
     CommentAndMetadata commentAndMetadata = _parseCommentAndMetadata();
     FinalConstVarOrType holder = _parseFinalConstVarOrType(true);
     Token thisKeyword = null;
     Token period = null;
     if (_matchesKeyword(Keyword.THIS)) {
       thisKeyword = andAdvance;
       period = _expect(TokenType.PERIOD);
     }
@@ skipping 833 matching lines @@
       token = token.next.next;
     }
     if (token.type == TokenType.KEYWORD) {
       Keyword keyword = (token as KeywordToken).keyword;
       return keyword == Keyword.CASE || keyword == Keyword.DEFAULT;
     }
     return false;
   }
 
   /**
-   * Return `true` if the given token appears to be the first token of a type name that is
-   * followed by a variable or field formal parameter.
-   *
-   * @param startToken the first token of the sequence being checked
-   * @return `true` if there is a type name and variable starting at the given token
+   * Return `true` if the [startToken] appears to be the first token of a type
+   * name that is followed by a variable or field formal parameter.
    */
   bool _isTypedIdentifier(Token startToken) {
     Token token = _skipReturnType(startToken);
     if (token == null) {
       return false;
     } else if (_tokenMatchesIdentifier(token)) {
       return true;
-    } else if (_tokenMatchesKeyword(token, Keyword.THIS) && _tokenMatches(token.next, TokenType.PERIOD) && _tokenMatchesIdentifier(token.next.next)) {
+    } else if (_tokenMatchesKeyword(token, Keyword.THIS)
+        && _tokenMatches(token.next, TokenType.PERIOD)
+        && _tokenMatchesIdentifier(token.next.next)) {
+      return true;
+    } else if (_tokenMatchesKeyword(startToken, Keyword.VOID)) {
+      // The keyword 'void' isn't a valid identifier, so it should be assumed to
+      // be a type name.
+      return true;
+    } else if (startToken.next != token) {
+      // The type is more than a simple identifier, so it should be assumed to
+      // be a type name.
       return true;
     }
     return false;
   }
 
   /**
    * Compare the given tokens to find the token that appears first in the source being parsed. That
    * is, return the left-most of all of the tokens. The arguments are allowed to be `null`.
    * Return the token with the smallest offset, or `null` if there are no arguments or if all
    * of the arguments are `null`.
@@ skipping 6524 matching lines @@
         return trampoline(target, arguments[0], arguments[1]);
       case 3:
         return trampoline(target, arguments[0], arguments[1], arguments[2]);
       case 4:
         return trampoline(target, arguments[0], arguments[1], arguments[2], arguments[3]);
       default:
         throw new IllegalArgumentException("Not implemented for > 4 arguments");
     }
   }
 }