Recover better from illegally named constructors (issue 28807)

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 1361 matching lines @@
                 _createSyntheticToken(TokenType.OPEN_PAREN),
                 <FormalParameter>[],
                 null,
                 null,
                 _createSyntheticToken(TokenType.CLOSE_PAREN)),
             astFactory
                 .emptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON)));
       }
       return null;
     } else if (_tokenMatches(next, TokenType.PERIOD) &&
-        _tokenMatchesIdentifier(_peekAt(2)) &&
+        _tokenMatchesIdentifierOrKeyword(_peekAt(2)) &&
         _tokenMatches(_peekAt(3), TokenType.OPEN_PAREN)) {
+      if (!_tokenMatchesIdentifier(_peekAt(2))) {
+        _reportErrorForToken(ParserErrorCode.INVALID_CONSTRUCTOR_NAME,
+            _peekAt(2), [_peekAt(2).lexeme]);
+      }
       return _parseConstructor(
           commentAndMetadata,
           modifiers.externalKeyword,
           _validateModifiersForConstructor(modifiers),
           modifiers.factoryKeyword,
           parseSimpleIdentifier(),
           getAndAdvance(),
-          parseSimpleIdentifier(isDeclaration: true),
+          parseSimpleIdentifier(allowKeyword: true, isDeclaration: true),
           parseFormalParameterList());
     } else if (_tokenMatches(next, TokenType.OPEN_PAREN)) {
       TypeName returnType = _parseOptionalTypeNameComment();
       SimpleIdentifier methodName = parseSimpleIdentifier(isDeclaration: true);
       TypeParameterList typeParameters = _parseGenericCommentTypeParameters();
       FormalParameterList parameters = parseFormalParameterList();
       if (_matches(TokenType.COLON) ||
           modifiers.factoryKeyword != null ||
           methodName.name == className) {
         return _parseConstructor(
@@ skipping 3273 matching lines @@
     }
     return expression;
   }
 
   /**
    * Parse a simple identifier. Return the simple identifier that was parsed.
    *
    *     identifier ::=
    *         IDENTIFIER
    */
-  SimpleIdentifier parseSimpleIdentifier({bool isDeclaration: false}) {
-    if (_matchesIdentifier()) {
+  SimpleIdentifier parseSimpleIdentifier(
+      {bool allowKeyword: false, bool isDeclaration: false}) {
+    if (_matchesIdentifier() ||
+        (allowKeyword && _tokenMatchesIdentifierOrKeyword(_currentToken))) {
       return _parseSimpleIdentifierUnchecked(isDeclaration: isDeclaration);
     }
     _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER);
     return createSyntheticIdentifier(isDeclaration: isDeclaration);
   }
 
   /**
    * Parse a statement, starting with the given [token]. Return the statement
    * that was parsed, or `null` if the tokens do not represent a recognizable
    * statement.
@@ skipping 3258 matching lines @@
 
   /**
    * 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) ||
       _tokenMatchesPseudoKeyword(token);
 
   /**
+   * Return `true` if the given [token] is either an identifier or a keyword.
+   */
+  bool _tokenMatchesIdentifierOrKeyword(Token token) =>
+      _tokenMatches(token, TokenType.IDENTIFIER) ||
+      _tokenMatches(token, TokenType.KEYWORD);
+
+  /**
    * Return `true` if the given [token] matches the given [keyword].
    */
   bool _tokenMatchesKeyword(Token token, Keyword keyword) =>
       token.keyword == keyword;
 
   /**
    * Return `true` if the given [token] matches a pseudo keyword.
    */
   bool _tokenMatchesPseudoKeyword(Token token) =>
       token.keyword?.isPseudoKeyword ?? false;
@@ skipping 518 matching lines @@
    */
   Parser_SyntheticKeywordToken(Keyword keyword, int offset)
       : super(keyword, offset);
 
   @override
   int get length => 0;
 
   @override
   Token copy() => new Parser_SyntheticKeywordToken(keyword, offset);
 }