update analyzer parser tests for fasta scanner

pkg/analyzer/test/generated/parser_test.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 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/dart/ast/token.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/testing/token_factory.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
+import 'package:front_end/src/scanner/scanner.dart' as fe;
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'test_support.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(ClassMemberParserTest);
     defineReflectiveTests(ComplexParserTest);
     defineReflectiveTests(ErrorParserTest);
@@ skipping 2487 matching lines @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expectNotNullIfNoErrors(member);
     listener.assertErrors(
         [new AnalysisError(null, 0, 1, ParserErrorCode.EXPECTED_EXECUTABLE)]);
   }
 
   void test_expectedInterpolationIdentifier() {
     createParser("'\$x\$'");
     StringLiteral literal = parser.parseStringLiteral();
     expectNotNullIfNoErrors(literal);
-    listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
+    listener.assertErrorsWithCodes([
+      fe.Scanner.useFasta
+          ? ScannerErrorCode.MISSING_IDENTIFIER
+          : ParserErrorCode.MISSING_IDENTIFIER
+    ]);
   }
 
   void test_expectedInterpolationIdentifier_emptyString() {
     // The scanner inserts an empty string token between the two $'s; we need to
     // make sure that the MISSING_IDENTIFIER error that is generated has a
     // nonzero width so that it will show up in the editor UI.
     createParser("'\$\$foo'");
     StringLiteral literal = parser.parseStringLiteral();
     expectNotNullIfNoErrors(literal);
-    listener.assertErrors(
-        [new AnalysisError(null, 2, 1, ParserErrorCode.MISSING_IDENTIFIER)]);
+    listener.assertErrors(fe.Scanner.useFasta
+        ? [new AnalysisError(null, 2, 1, ScannerErrorCode.MISSING_IDENTIFIER)]
+        : [new AnalysisError(null, 2, 1, ParserErrorCode.MISSING_IDENTIFIER)]);
   }
 
   @failingTest
   void test_expectedListOrMapLiteral() {
     // It isn't clear that this test can ever pass. The parser is currently
     // create a synthetic list literal in this case, but isSynthetic() isn't
     // overridden for ListLiteral. The problem is that the synthetic list
     // literals that are being created are not always zero length (because they
     // could have type parameters), which violates the contract of
     // isSynthetic().
@@ skipping 307 matching lines @@
         "void f(const x()) {}", [ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR]);
   }
 
   void test_functionTypedParameter_final() {
     parseCompilationUnit(
         "void f(final x()) {}", [ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR]);
   }
 
   void test_functionTypedParameter_incomplete1() {
     // This caused an exception at one point.
-    parseCompilationUnit("void f(int Function(", [
-      ParserErrorCode.MISSING_FUNCTION_BODY,
-      ParserErrorCode.MISSING_CLOSING_PARENTHESIS,
-      ParserErrorCode.EXPECTED_EXECUTABLE,
-      ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE,
-      ParserErrorCode.EXPECTED_TOKEN,
-      ParserErrorCode.EXPECTED_TOKEN
-    ]);
+    parseCompilationUnit(
+        "void f(int Function(",
+        fe.Scanner.useFasta
+            ? [
+                ScannerErrorCode.EXPECTED_TOKEN,
+                ScannerErrorCode.EXPECTED_TOKEN,
+                ParserErrorCode.MISSING_FUNCTION_BODY,
+                ParserErrorCode.MISSING_IDENTIFIER,
+              ]
+            : [
+                ParserErrorCode.MISSING_FUNCTION_BODY,
+                ParserErrorCode.MISSING_CLOSING_PARENTHESIS,
+                ParserErrorCode.EXPECTED_EXECUTABLE,
+                ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE,
+                ParserErrorCode.EXPECTED_TOKEN,
+                ParserErrorCode.EXPECTED_TOKEN
+              ]);
   }
 
   void test_functionTypedParameter_var() {
     parseCompilationUnit(
         "void f(var x()) {}", [ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR]);
   }
 
   void test_getterInFunction_block_noReturnType() {
     FunctionDeclarationStatement statement =
         parseStatement("get x { return _x; }");
@@ skipping 152 matching lines @@
     createParser("'\\x0'");
     StringLiteral literal = parser.parseStringLiteral();
     expectNotNullIfNoErrors(literal);
     listener.assertErrorsWithCodes([ParserErrorCode.INVALID_HEX_ESCAPE]);
   }
 
   void test_invalidInterpolationIdentifier_startWithDigit() {
     createParser("'\$1'");
     StringLiteral literal = parser.parseStringLiteral();
     expectNotNullIfNoErrors(literal);
-    listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
+    listener.assertErrorsWithCodes([
+      fe.Scanner.useFasta
+          ? ScannerErrorCode.MISSING_IDENTIFIER
+          : ParserErrorCode.MISSING_IDENTIFIER
+    ]);
   }
 
   void test_invalidLiteralInConfiguration() {
     createParser("if (a == 'x \$y z') 'a.dart'");
     Configuration configuration = parser.parseConfiguration();
     expectNotNullIfNoErrors(configuration);
     listener.assertErrorsWithCodes(
         [ParserErrorCode.INVALID_LITERAL_IN_CONFIGURATION]);
   }
 
@@ skipping 242 matching lines @@
   }
 
   @failingTest
   void test_missingClosingParenthesis() {
     // It is possible that it is not possible to generate this error (that it's
     // being reported in code that cannot actually be reached), but that hasn't
     // been proven yet.
     createParser('(int a, int b ;');
     FormalParameterList list = parser.parseFormalParameterList();
     expectNotNullIfNoErrors(list);
-    listener
-        .assertErrorsWithCodes([ParserErrorCode.MISSING_CLOSING_PARENTHESIS]);
+    listener.assertErrorsWithCodes([
+      fe.Scanner.useFasta
+          ? ScannerErrorCode.EXPECTED_TOKEN
+          : ParserErrorCode.MISSING_CLOSING_PARENTHESIS
+    ]);
   }
 
   void test_missingConstFinalVarOrType_static() {
     parseCompilationUnit("class A { static f; }",
         [ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE]);
   }
 
   void test_missingConstFinalVarOrType_topLevel() {
     createParser('a;');
     FinalConstVarOrType result = parser.parseFinalConstVarOrType(false);
@@ skipping 252 matching lines @@
 
   void test_missingStatement_afterVoid() {
     parseStatement("void;");
     assertErrorsWithCodes([ParserErrorCode.MISSING_STATEMENT]);
   }
 
   void test_missingTerminatorForParameterGroup_named() {
     createParser('(a, {b: 0)');
     FormalParameterList list = parser.parseFormalParameterList();
     expectNotNullIfNoErrors(list);
-    listener.assertErrorsWithCodes(
-        [ParserErrorCode.MISSING_TERMINATOR_FOR_PARAMETER_GROUP]);
+    listener.assertErrorsWithCodes([
+      fe.Scanner.useFasta
+          ? ScannerErrorCode.EXPECTED_TOKEN
+          : ParserErrorCode.MISSING_TERMINATOR_FOR_PARAMETER_GROUP
+    ]);
   }
 
   void test_missingTerminatorForParameterGroup_optional() {
     createParser('(a, [b = 0)');
     FormalParameterList list = parser.parseFormalParameterList();
     expectNotNullIfNoErrors(list);
-    listener.assertErrorsWithCodes(
-        [ParserErrorCode.MISSING_TERMINATOR_FOR_PARAMETER_GROUP]);
+    listener.assertErrorsWithCodes([
+      fe.Scanner.useFasta
+          ? ScannerErrorCode.EXPECTED_TOKEN
+          : ParserErrorCode.MISSING_TERMINATOR_FOR_PARAMETER_GROUP
+    ]);
   }
 
   void test_missingTypedefParameters_nonVoid() {
     parseCompilationUnit(
         "typedef int F;", [ParserErrorCode.MISSING_TYPEDEF_PARAMETERS]);
   }
 
   void test_missingTypedefParameters_typeParameters() {
     parseCompilationUnit(
         "typedef F<E>;", [ParserErrorCode.MISSING_TYPEDEF_PARAMETERS]);
@@ skipping 343 matching lines @@
         "static var x;", [ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION]);
   }
 
   void test_string_unterminated_interpolation_block() {
     parseCompilationUnit(
         r'''
 m() {
  {
  '${${
 ''',
-        [
-          ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-          ParserErrorCode.EXPECTED_TOKEN,
-          ParserErrorCode.EXPECTED_TOKEN,
-          ParserErrorCode.EXPECTED_TOKEN,
-          ParserErrorCode.EXPECTED_TOKEN,
-          ParserErrorCode.EXPECTED_TOKEN,
-          ParserErrorCode.EXPECTED_TOKEN,
-        ]);
+        fe.Scanner.useFasta
+            ? [
+                ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+                ScannerErrorCode.EXPECTED_TOKEN,
+                ScannerErrorCode.EXPECTED_TOKEN,
+                ScannerErrorCode.EXPECTED_TOKEN,
+                ScannerErrorCode.EXPECTED_TOKEN,
+                ParserErrorCode.EXPECTED_TOKEN,
+                ParserErrorCode.EXPECTED_TOKEN,
+                ParserErrorCode.EXPECTED_TOKEN,
+                ParserErrorCode.UNEXPECTED_TOKEN,
+                ParserErrorCode.EXPECTED_EXECUTABLE,
+              ]
+            : [
+                ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+                ParserErrorCode.EXPECTED_TOKEN,
+                ParserErrorCode.EXPECTED_TOKEN,
+                ParserErrorCode.EXPECTED_TOKEN,
+                ParserErrorCode.EXPECTED_TOKEN,
+                ParserErrorCode.EXPECTED_TOKEN,
+                ParserErrorCode.EXPECTED_TOKEN,
+              ]);
   }
 
   void test_switchHasCaseAfterDefaultCase() {
     createParser('switch (a) {default: return 0; case 1: return 1;}');
     SwitchStatement statement = parser.parseSwitchStatement();
     expectNotNullIfNoErrors(statement);
     listener.assertErrorsWithCodes(
         [ParserErrorCode.SWITCH_HAS_CASE_AFTER_DEFAULT_CASE]);
   }
 
@@ skipping 103 matching lines @@
 
   void test_typedefInClass_withReturnType() {
     parseCompilationUnit("class C { typedef int F(int x); }",
         [ParserErrorCode.TYPEDEF_IN_CLASS]);
   }
 
   void test_unexpectedTerminatorForParameterGroup_named() {
     createParser('(a, b})');
     FormalParameterList list = parser.parseFormalParameterList();
     expectNotNullIfNoErrors(list);
-    listener.assertErrorsWithCodes(
-        [ParserErrorCode.UNEXPECTED_TERMINATOR_FOR_PARAMETER_GROUP]);
+    listener.assertErrorsWithCodes(fe.Scanner.useFasta
+        ? [ScannerErrorCode.EXPECTED_TOKEN]
+        : [ParserErrorCode.UNEXPECTED_TERMINATOR_FOR_PARAMETER_GROUP]);
   }
 
   void test_unexpectedTerminatorForParameterGroup_optional() {
     createParser('(a, b])');
     FormalParameterList list = parser.parseFormalParameterList();
     expectNotNullIfNoErrors(list);
-    listener.assertErrorsWithCodes(
-        [ParserErrorCode.UNEXPECTED_TERMINATOR_FOR_PARAMETER_GROUP]);
+    listener.assertErrorsWithCodes(fe.Scanner.useFasta
+        ? [ScannerErrorCode.EXPECTED_TOKEN]
+        : [ParserErrorCode.UNEXPECTED_TERMINATOR_FOR_PARAMETER_GROUP]);
   }
 
   void test_unexpectedToken_endOfFieldDeclarationStatement() {
     parseStatement("String s = (null));");
     assertErrorsWithCodes([ParserErrorCode.UNEXPECTED_TOKEN]);
   }
 
   @failingTest
   void test_unexpectedToken_invalidPostfixExpression() {
     // Note: this might not be the right error to produce, but some error should
@@ skipping 20 matching lines @@
   void test_unterminatedString_at_eof() {
     // Although the "unterminated string" error message is produced by the
     // scanner, we need to verify that the parser can handle the tokens
     // produced by the scanner when an unterminated string is encountered.
     parseCompilationUnit(
         r'''
 void main() {
   var x = "''',
         [
           ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-          ParserErrorCode.EXPECTED_TOKEN,
+          fe.Scanner.useFasta
+              ? ScannerErrorCode.EXPECTED_TOKEN
+              : ParserErrorCode.EXPECTED_TOKEN,
           ParserErrorCode.EXPECTED_TOKEN
         ]);
   }
 
   void test_unterminatedString_at_eol() {
     // Although the "unterminated string" error message is produced by the
     // scanner, we need to verify that the parser can handle the tokens
     // produced by the scanner when an unterminated string is encountered.
     parseCompilationUnit(
         r'''
 void main() {
   var x = "
 ;
 }
 ''',
         [ScannerErrorCode.UNTERMINATED_STRING_LITERAL]);
   }
 
   void test_unterminatedString_multiline_at_eof_3_quotes() {
     // Although the "unterminated string" error message is produced by the
     // scanner, we need to verify that the parser can handle the tokens
     // produced by the scanner when an unterminated string is encountered.
     parseCompilationUnit(
         r'''
 void main() {
   var x = """''',
         [
           ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-          ParserErrorCode.EXPECTED_TOKEN,
+          fe.Scanner.useFasta
+              ? ScannerErrorCode.EXPECTED_TOKEN
+              : ParserErrorCode.EXPECTED_TOKEN,
           ParserErrorCode.EXPECTED_TOKEN
         ]);
   }
 
   void test_unterminatedString_multiline_at_eof_4_quotes() {
     // Although the "unterminated string" error message is produced by the
     // scanner, we need to verify that the parser can handle the tokens
     // produced by the scanner when an unterminated string is encountered.
     parseCompilationUnit(
         r'''
 void main() {
   var x = """"''',
         [
           ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-          ParserErrorCode.EXPECTED_TOKEN,
+          fe.Scanner.useFasta
+              ? ScannerErrorCode.EXPECTED_TOKEN
+              : ParserErrorCode.EXPECTED_TOKEN,
           ParserErrorCode.EXPECTED_TOKEN
         ]);
   }
 
   void test_unterminatedString_multiline_at_eof_5_quotes() {
     // Although the "unterminated string" error message is produced by the
     // scanner, we need to verify that the parser can handle the tokens
     // produced by the scanner when an unterminated string is encountered.
     parseCompilationUnit(
         r'''
 void main() {
   var x = """""''',
         [
           ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-          ParserErrorCode.EXPECTED_TOKEN,
+          fe.Scanner.useFasta
+              ? ScannerErrorCode.EXPECTED_TOKEN
+              : ParserErrorCode.EXPECTED_TOKEN,
           ParserErrorCode.EXPECTED_TOKEN
         ]);
   }
 
   void test_useOfUnaryPlusOperator() {
     createParser('+x');
     Expression expression = parser.parseUnaryExpression();
     expectNotNullIfNoErrors(expression);
     listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
     var identifier = expression as SimpleIdentifier;
@@ skipping 120 matching lines @@
     FormalParameterList list = parser.parseFormalParameterList();
     expectNotNullIfNoErrors(list);
     listener.assertErrorsWithCodes(
         [ParserErrorCode.WRONG_SEPARATOR_FOR_POSITIONAL_PARAMETER]);
   }
 
   void test_wrongTerminatorForParameterGroup_named() {
     createParser('(a, {b, c])');
     FormalParameterList list = parser.parseFormalParameterList();
     expectNotNullIfNoErrors(list);
-    listener.assertErrorsWithCodes(
-        [ParserErrorCode.WRONG_TERMINATOR_FOR_PARAMETER_GROUP]);
+    listener.assertErrorsWithCodes(fe.Scanner.useFasta
+        ? [ScannerErrorCode.EXPECTED_TOKEN, ScannerErrorCode.EXPECTED_TOKEN]
+        : [ParserErrorCode.WRONG_TERMINATOR_FOR_PARAMETER_GROUP]);
   }
 
   void test_wrongTerminatorForParameterGroup_optional() {
     createParser('(a, [b, c})');
     FormalParameterList list = parser.parseFormalParameterList();
     expectNotNullIfNoErrors(list);
-    listener.assertErrorsWithCodes(
-        [ParserErrorCode.WRONG_TERMINATOR_FOR_PARAMETER_GROUP]);
+    listener.assertErrorsWithCodes(fe.Scanner.useFasta
+        ? [ScannerErrorCode.EXPECTED_TOKEN, ScannerErrorCode.EXPECTED_TOKEN]
+        : [ParserErrorCode.WRONG_TERMINATOR_FOR_PARAMETER_GROUP]);
   }
 }
 
 @reflectiveTest
 class ExpressionParserTest extends ParserTestCase
     with ExpressionParserTestMixin {}
 
 abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   void test_namedArgument() {
     var invocation = parseExpression('m(a: 1, b: 2)') as MethodInvocation;
@@ skipping 6900 matching lines @@
     expectNotNullIfNoErrors(functionBody);
     listener.assertNoErrors();
     expect(functionBody, new isInstanceOf<EmptyFunctionBody>());
   }
 
   void test_parseFunctionBody_skip_block_invalid() {
     ParserTestCase.parseFunctionBodies = false;
     createParser('{');
     FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
     expectNotNullIfNoErrors(functionBody);
-    listener.assertErrorsWithCodes([ParserErrorCode.EXPECTED_TOKEN]);
+    listener.assertErrorsWithCodes([
+      fe.Scanner.useFasta
+          ? ScannerErrorCode.EXPECTED_TOKEN
+          : ParserErrorCode.EXPECTED_TOKEN
+    ]);
     expect(functionBody, new isInstanceOf<EmptyFunctionBody>());
   }
 
   void test_parseFunctionBody_skip_blocks() {
     ParserTestCase.parseFunctionBodies = false;
     createParser('{ {} }');
     FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
     expectNotNullIfNoErrors(functionBody);
     listener.assertNoErrors();
     expect(functionBody, new isInstanceOf<EmptyFunctionBody>());
@@ skipping 3810 matching lines @@
     expectCommentText(typeVariable.documentationComment, '/// Doc');
   }
 
   /**
    * Assert that the given [name] is in declaration context.
    */
   void _assertIsDeclarationName(SimpleIdentifier name) {
     expect(name.inDeclarationContext(), isTrue);
   }
 }