Better recovery for getters in functions

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 3172 matching lines @@
    * @return the token that was just added to the token stream
    */
   Token _injectToken(Token token) {
     Token previous = _currentToken.previous;
     token.setNext(_currentToken);
     previous.setNext(token);
     return token;
   }
 
   /**
-   * Return `true` if the current token appears to be the beginning of a function declaration.
-   *
-   * @return `true` if the current token appears to be the beginning of a function declaration
+   * Return `true` if the current token appears to be the beginning of a
+   * function declaration.
    */
   bool _isFunctionDeclaration() {
     if (_matchesKeyword(Keyword.VOID)) {
       return true;
     }
     Token afterReturnType = _skipTypeName(_currentToken);
     if (afterReturnType == null) {
-      // There was no return type, but it is optional, so go back to where we started.
+      // 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.
+      // 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);
     }
     if (afterIdentifier == null) {
       return false;
     }
     if (_isFunctionExpression(afterIdentifier)) {
       return true;
     }
-    // It's possible that we have found a getter. While this isn't valid at this point we test for
-    // it in order to recover better.
+    // It's possible that we have found a getter. While this isn't valid at this
+    // point we test for it in order to recover better.
     if (_matchesKeyword(Keyword.GET)) {
       Token afterName = _skipSimpleIdentifier(_currentToken.next);
       if (afterName == null) {
         return false;
       }
-      return _tokenMatches(afterName, TokenType.FUNCTION) || _tokenMatches(afterName, TokenType.OPEN_CURLY_BRACKET);
+      return _tokenMatches(afterName, TokenType.FUNCTION)
+          || _tokenMatches(afterName, TokenType.OPEN_CURLY_BRACKET);
+    } else if (_tokenMatchesKeyword(afterReturnType, Keyword.GET)) {
+      Token afterName = _skipSimpleIdentifier(afterReturnType.next);
+      if (afterName == null) {
+        return false;
+      }
+      return _tokenMatches(afterName, TokenType.FUNCTION)
+          || _tokenMatches(afterName, TokenType.OPEN_CURLY_BRACKET);
     }
     return false;
   }
 
   /**
    * Return `true` if the given token appears to be the beginning of a function expression.
    *
    * @param startToken the token that might be the start of a function expression
    * @return `true` if the given token appears to be the beginning of a function expression
    */
@@ skipping 6282 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");
     }
   }
 }