update fasta parser compatibility tests to check error codes

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';
@@ skipping 7587 matching lines @@
     expect(list.parameters[0].toSource(), 'io. ');
     expect(list.parameters[1].toSource(), 'a');
     expect(list.rightDelimiter, isNull);
     expect(list.rightParenthesis, isNotNull);
   }
 
   void test_parseNormalFormalParameter_field_const_noType() {
     NormalFormalParameter parameter =
         parseNormalFormalParameter('const this.a');
     expect(parameter, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      // TODO(danrubel): should not be generating an error
+      assertErrorsWithCodes([ParserErrorCode.UNEXPECTED_TOKEN]);
+    } else {
+      assertNoErrors();
+    }
     expect(parameter, new isInstanceOf<FieldFormalParameter>());
     FieldFormalParameter fieldParameter = parameter;
     expect(fieldParameter.keyword, isNotNull);
     expect(fieldParameter.type, isNull);
     expect(fieldParameter.identifier, isNotNull);
     expect(fieldParameter.parameters, isNull);
   }
 
   void test_parseNormalFormalParameter_field_const_type() {
     NormalFormalParameter parameter =
         parseNormalFormalParameter('const A this.a');
     expect(parameter, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      // TODO(danrubel): should not be generating an error
+      assertErrorsWithCodes([ParserErrorCode.UNEXPECTED_TOKEN]);
+    } else {
+      assertNoErrors();
+    }
     expect(parameter, new isInstanceOf<FieldFormalParameter>());
     FieldFormalParameter fieldParameter = parameter;
     expect(fieldParameter.keyword, isNotNull);
     expect(fieldParameter.type, isNotNull);
     expect(fieldParameter.identifier, isNotNull);
     expect(fieldParameter.parameters, isNull);
   }
 
   void test_parseNormalFormalParameter_field_final_noType() {
     NormalFormalParameter parameter =
@@ skipping 335 matching lines @@
 
   void test_parseNormalFormalParameter_function_withDocComment() {
     var parameter = parseFormalParameter('/// Doc\nf()', ParameterKind.REQUIRED)
         as FunctionTypedFormalParameter;
     expectCommentText(parameter.documentationComment, '/// Doc');
   }
 
   void test_parseNormalFormalParameter_simple_const_noType() {
     NormalFormalParameter parameter = parseNormalFormalParameter('const a');
     expect(parameter, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      // TODO(danrubel): should not be generating an error
+      assertErrorsWithCodes([ParserErrorCode.UNEXPECTED_TOKEN]);
+    } else {
+      assertNoErrors();
+    }
     expect(parameter, new isInstanceOf<SimpleFormalParameter>());
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.keyword, isNotNull);
     expect(simpleParameter.type, isNull);
     expect(simpleParameter.identifier, isNotNull);
   }
 
   void test_parseNormalFormalParameter_simple_const_type() {
     NormalFormalParameter parameter = parseNormalFormalParameter('const A a');
     expect(parameter, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      // TODO(danrubel): should not be generating an error
+      assertErrorsWithCodes([ParserErrorCode.UNEXPECTED_TOKEN]);
+    } else {
+      assertNoErrors();
+    }
     expect(parameter, new isInstanceOf<SimpleFormalParameter>());
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.keyword, isNotNull);
     expect(simpleParameter.type, isNotNull);
     expect(simpleParameter.identifier, isNotNull);
   }
 
   void test_parseNormalFormalParameter_simple_final_noType() {
     NormalFormalParameter parameter = parseNormalFormalParameter('final a');
     expect(parameter, isNotNull);
@@ skipping 5759 matching lines @@
     assertNoErrors();
     expect(unit.scriptTag, isNull);
     expect(unit.directives, hasLength(0));
     expect(unit.declarations, hasLength(1));
   }
 
   void test_parseCompilationUnit_operatorAsPrefix_parameterized() {
     createParser('operator<dynamic> _operator = new operator.A();');
     CompilationUnit unit = parser.parseCompilationUnit2();
     expect(unit, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      // TODO(danrubel): should not be generating an error
+      assertErrorsWithCodes([ParserErrorCode.EXPECTED_TYPE_NAME]);
+    } else {
+      assertNoErrors();
+    }
     expect(unit.scriptTag, isNull);
     expect(unit.directives, hasLength(0));
     expect(unit.declarations, hasLength(1));
   }
 
   void test_parseCompilationUnit_script() {
     createParser('#! /bin/dart');
     CompilationUnit unit = parser.parseCompilationUnit2();
     expect(unit, isNotNull);
     assertNoErrors();
@@ skipping 23 matching lines @@
     expect(unit.beginToken, isNotNull);
     expect(unit.beginToken.keyword, Keyword.CLASS);
     expect(unit.endToken, isNotNull);
     expect(unit.endToken.type, TokenType.EOF);
   }
 
   void test_parseCompilationUnit_typedefAsPrefix() {
     createParser('typedef.A _typedef = new typedef.A();');
     CompilationUnit unit = parser.parseCompilationUnit2();
     expect(unit, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      // TODO(danrubel): should not be generating an error
+      assertErrorsWithCodes([ParserErrorCode.EXPECTED_TYPE_NAME]);
+    } else {
+      assertNoErrors();
+    }
     expect(unit.scriptTag, isNull);
     expect(unit.directives, hasLength(0));
     expect(unit.declarations, hasLength(1));
   }
 
   void test_parseCompilationUnitMember_abstractAsPrefix() {
     createParser('abstract.A _abstract = new abstract.A();');
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      // TODO(danrubel): should not be generating an error
+      assertErrorsWithCodes([ParserErrorCode.EXPECTED_TYPE_NAME]);
+    } else {
+      assertNoErrors();
+    }
     expect(member, new isInstanceOf<TopLevelVariableDeclaration>());
     TopLevelVariableDeclaration declaration = member;
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
   }
 
   void test_parseCompilationUnitMember_class() {
     createParser('class A {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
@@ skipping 1341 matching lines @@
     expectCommentText(typeVariable.documentationComment, '/// Doc');
   }
 
   /**
    * Assert that the given [name] is in declaration context.
    */
   void _assertIsDeclarationName(SimpleIdentifier name) {
     expect(name.inDeclarationContext(), isTrue);
   }
 }