update analyzer parser tests for fasta scanner

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.
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 1257 matching lines @@
       Token next = _peek();
       bool isFollowedByIdentifier = _tokenMatchesIdentifier(next);
       if (keyword == Keyword.GET && isFollowedByIdentifier) {
         _validateModifiersForGetterOrSetterOrMethod(modifiers);
         return parseGetter(commentAndMetadata, modifiers.externalKeyword,
             modifiers.staticKeyword, returnType);
       } else if (keyword == Keyword.SET && isFollowedByIdentifier) {
         _validateModifiersForGetterOrSetterOrMethod(modifiers);
         return parseSetter(commentAndMetadata, modifiers.externalKeyword,
             modifiers.staticKeyword, returnType);
-      } else if (keyword == Keyword.OPERATOR && _isOperator(next)) {
+      } else if (keyword == Keyword.OPERATOR &&
+          (_isOperator(next) || next.type == TokenType.EQ_EQ_EQ)) {

[Brian Wilkerson, 2017/06/06 14:00:17]

What is "==="?

That operator hasn't been part of the language for a long time, so I'm guessing
that this is here for recovery. But is there any reason to think that there's
value in supporting this kind of recovery? There have not been any issues that
I'm aware of where people were confused by its absence. I think it would be
better to keep the code cleaner rather than add recovery for a rare case.

If we really think this is useful, then we should document (in the fasta parser,
presumably) that this support is here for recovery purposes.

[danrubel, 2017/06/07 15:03:46]

Good question. It exists for the purpose of better recovery. I'll add docs for
the token indicating as much.

         _validateModifiersForOperator(modifiers);
         return _parseOperatorAfterKeyword(commentAndMetadata,
             modifiers.externalKeyword, returnType, getAndAdvance());
       } else if (_matchesIdentifier() &&
           _peek().matchesAny(const <TokenType>[
             TokenType.OPEN_PAREN,
             TokenType.OPEN_CURLY_BRACKET,
             TokenType.FUNCTION,
             TokenType.LT
           ])) {
@@ skipping 5913 matching lines @@
    *     operatorSignature ::=
    *         'external'? returnType? 'operator' operator formalParameterList
    */
   MethodDeclaration _parseOperatorAfterKeyword(
       CommentAndMetadata commentAndMetadata,
       Token externalKeyword,
       TypeAnnotation returnType,
       Token operatorKeyword) {
     if (!_currentToken.isUserDefinableOperator) {
       _reportErrorForCurrentToken(
-          ParserErrorCode.NON_USER_DEFINABLE_OPERATOR, [_currentToken.lexeme]);
+          _currentToken.type == TokenType.EQ_EQ_EQ
+              ? ParserErrorCode.INVALID_OPERATOR
+              : ParserErrorCode.NON_USER_DEFINABLE_OPERATOR,
+          [_currentToken.lexeme]);
     }
     SimpleIdentifier name =
         astFactory.simpleIdentifier(getAndAdvance(), isDeclaration: true);
     if (_matches(TokenType.EQ)) {
       Token previous = _currentToken.previous;
       if ((_tokenMatches(previous, TokenType.EQ_EQ) ||
               _tokenMatches(previous, TokenType.BANG_EQ)) &&
           _currentToken.offset == previous.offset + 2) {
         _reportErrorForCurrentToken(ParserErrorCode.INVALID_OPERATOR,
             ["${previous.lexeme}${_currentToken.lexeme}"]);
@@ skipping 1375 matching lines @@
     }
   }
 }
 
 /**
  * Instances of this class are thrown when the parser detects that AST has
  * too many nested expressions to be parsed safely and avoid possibility of
  * [StackOverflowError] in the parser or during later analysis.
  */
 class _TooDeepTreeError {}