Improve recovery for local variable declarations.

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 engine.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'ast.dart';
@@ skipping 4020 matching lines @@
     if (_matchesKeyword(Keyword.CONST)) {
       // Look to see whether we might be at the start of a list or map literal,
       // otherwise this should be the start of a variable declaration.
       return !_peek().matchesAny([
         TokenType.LT,
         TokenType.OPEN_CURLY_BRACKET,
         TokenType.OPEN_SQUARE_BRACKET,
         TokenType.INDEX
       ]);
     }
+    bool allowAdditionalTokens = true;
     // 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 (token.type != TokenType.IDENTIFIER) {
+      allowAdditionalTokens = false;
+    }
     token = _skipSimpleIdentifier(token);
     if (token == null) {
       return false;
     }
     TokenType type = token.type;
-    return type == TokenType.EQ ||
+    // Usual cases in valid code:
+    //     String v = '';
+    //     String v, v2;
+    //     String v;
+    //     for (String item in items) {}
+    if (type == TokenType.EQ ||
         type == TokenType.COMMA ||
         type == TokenType.SEMICOLON ||
-        _tokenMatchesKeyword(token, Keyword.IN);
+        _tokenMatchesKeyword(token, Keyword.IN)) {
+      return true;
+    }
+    // It is OK to parse as a variable declaration in these cases:
+    //     String v }
+    //     String v if (true) print('OK');
+    //     String v { print(42); }
+    // ...but not in these cases:
+    //     get getterName {
+    //     String get getterName
+    if (allowAdditionalTokens) {
+      if (type == TokenType.CLOSE_CURLY_BRACKET ||
+          type == TokenType.KEYWORD ||
+          type == TokenType.IDENTIFIER ||
+          type == TokenType.OPEN_CURLY_BRACKET) {
+        return true;
+      }
+    }
+    return false;
   }
 
   bool _isLikelyParameterList() {
     if (_matches(TokenType.OPEN_PAREN)) {
       return true;
     }
     if (!parseGenericMethods) {
       return false;
     }
     Token token = _skipTypeArgumentList(_currentToken);
@@ skipping 4207 matching lines @@
    * token following the simple identifier that was parsed, or `null` if the
    * given token is not the first token in a valid simple identifier.
    *
    * This method must be kept in sync with [parseSimpleIdentifier].
    *
    *     identifier ::=
    *         IDENTIFIER
    */
   Token _skipSimpleIdentifier(Token startToken) {
     if (_tokenMatches(startToken, TokenType.IDENTIFIER) ||
-        (_tokenMatches(startToken, TokenType.KEYWORD) &&
-            (startToken as KeywordToken).keyword.isPseudoKeyword)) {
+        _tokenMatchesPseudoKeyword(startToken)) {
       return startToken.next;
     }
     return null;
   }
 
   /**
    * Parse a string literal that contains interpolations, starting at the
    * [startToken], without actually creating a string literal or changing the
    * current token. Return the token following the string literal that was
    * parsed, or `null` if the given token is not the first token in a valid
@@ skipping 203 matching lines @@
    * Return `true` if the given [token] has the given [type].
    */
   bool _tokenMatches(Token token, TokenType type) => token.type == type;
 
   /**
    * Return `true` if the given [token] is a valid identifier. Valid identifiers
    * include built-in identifiers (pseudo-keywords).
    */
   bool _tokenMatchesIdentifier(Token token) =>
       _tokenMatches(token, TokenType.IDENTIFIER) ||
-          (_tokenMatches(token, TokenType.KEYWORD) &&
-              (token as KeywordToken).keyword.isPseudoKeyword);
+          _tokenMatchesPseudoKeyword(token);
 
   /**
    * Return `true` if the given [token] matches the given [keyword].
    */
   bool _tokenMatchesKeyword(Token token, Keyword keyword) =>
       token.type == TokenType.KEYWORD &&
           (token as KeywordToken).keyword == keyword;
 
   /**
+   * Return `true` if the given [token] matches a pseudo keyword.
+   */
+  bool _tokenMatchesPseudoKeyword(Token token) =>
+      _tokenMatches(token, TokenType.KEYWORD) &&
+          (token as KeywordToken).keyword.isPseudoKeyword;
+
+  /**
    * Return `true` if the given [token] matches the given [identifier].
    */
   bool _tokenMatchesString(Token token, String identifier) =>
       token.type == TokenType.IDENTIFIER && token.lexeme == identifier;
 
   /**
    * Translate the characters at the given [index] in the given [lexeme],
    * appending the translated character to the given [buffer]. The index is
    * assumed to be valid.
    */
@@ skipping 2488 matching lines @@
   }
 
   /**
    * Copy resolution data from the [fromNode] to the [toNode].
    */
   static void copyResolutionData(AstNode fromNode, AstNode toNode) {
     ResolutionCopier copier = new ResolutionCopier();
     copier._isEqualNodes(fromNode, toNode);
   }
 }