update fasta parser compatibility tests to check error codes

pkg/analyzer/test/generated/parser_fasta_test.dart

 // Copyright (c) 2017, 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/token.dart' as analyzer;
 import 'package:analyzer/error/error.dart';
+import 'package:analyzer/error/listener.dart' show ErrorReporter;
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/fasta/ast_builder.dart';
 import 'package:analyzer/src/generated/parser.dart' as analyzer;
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/string_source.dart';
 import 'package:front_end/src/fasta/fasta_codes.dart' show Message;
 import 'package:front_end/src/fasta/kernel/kernel_builder.dart';
 import 'package:front_end/src/fasta/kernel/kernel_library_builder.dart';
 import 'package:front_end/src/fasta/parser.dart' show IdentifierContext;
 import 'package:front_end/src/fasta/parser.dart' as fasta;
@@ skipping 270 matching lines @@
   }
 
   @override
   analyzer.Parser get parser => _parserProxy;
 
   @override
   bool get usingFastaParser => true;
 
   @override
   void assertErrorsWithCodes(List<ErrorCode> expectedErrorCodes) {
-    // TODO(scheglov): implement assertErrorsWithCodes
-    fail('Not implemented');
+    _parserProxy._errorListener.assertErrorsWithCodes(expectedErrorCodes);
   }
 
   @override
   void assertNoErrors() {
-    // TODO(paulberry): implement assertNoErrors
+    _parserProxy._errorListener.assertNoErrors();
   }
 
   @override
   void createParser(String content) {
     var scanner = new StringScanner(content, includeComments: true);
     scanner.scanGenericMethodComments = enableGenericMethodComments;
     _fastaTokens = scanner.tokenize();
     _parserProxy = new ParserProxy(_fastaTokens,
         enableGenericMethodComments: enableGenericMethodComments);
   }
@@ skipping 391 matching lines @@
     super.test_parseNormalFormalParameter_function_void_nullable();
   }
 
   @override
   @failingTest
   void test_parseNormalFormalParameter_function_void_typeParameters_nullable() {
     // TODO(scheglov): Not implemented: Nnbd
     super
         .test_parseNormalFormalParameter_function_void_typeParameters_nullable();
   }
+
+  @failingTest
+  void test_parseNormalFormalParameter_field_const_noType2() {
+    // TODO(danrubel): should not be generating an error
+    super.test_parseNormalFormalParameter_field_const_noType();
+    assertNoErrors();
+  }
+
+  @failingTest
+  void test_parseNormalFormalParameter_field_const_type2() {
+    // TODO(danrubel): should not be generating an error
+    super.test_parseNormalFormalParameter_field_const_type();
+    assertNoErrors();
+  }
+
+  @failingTest
+  void test_parseNormalFormalParameter_simple_const_noType2() {
+    // TODO(danrubel): should not be generating an error
+    super.test_parseNormalFormalParameter_simple_const_noType();
+    assertNoErrors();
+  }
+
+  @failingTest
+  void test_parseNormalFormalParameter_simple_const_type2() {
+    // TODO(danrubel): should not be generating an error
+    super.test_parseNormalFormalParameter_simple_const_type();
+    assertNoErrors();
+  }
 }
 
 /**
  * Proxy implementation of [KernelLibraryBuilderProxy] used by Fasta parser
  * tests.
  */
 class KernelLibraryBuilderProxy implements KernelLibraryBuilder {
   @override
   final uri = Uri.parse('file:///test.dart');
 
@@ skipping 27 matching lines @@
    */
   final fasta.Parser _fastaParser;
 
   /**
    * The builder which creates the analyzer AST data structures expected by the
    * analyzer parser tests.
    */
   final AstBuilder _astBuilder;
 
   /**
+   * The error listener to which scanner and parser errors will be reported.
+   */
+  final GatheringErrorListener _errorListener;
+
+  /**
    * Creates a [ParserProxy] which is prepared to begin parsing at the given
    * Fasta token.
    */
   factory ParserProxy(analyzer.Token startingToken,
       {bool enableGenericMethodComments: false}) {
     var library = new KernelLibraryBuilderProxy();
     var member = new BuilderProxy();
     var scope = new ScopeProxy();
-    var astBuilder = new AstBuilder(null, library, member, scope, true);
+    TestSource source = new TestSource();
+    var errorListener = new GatheringErrorListener();
+    var errorReporter = new ErrorReporter(errorListener, source);
+    var astBuilder =
+        new AstBuilder(errorReporter, library, member, scope, true);
     astBuilder.parseGenericMethodComments = enableGenericMethodComments;
     var fastaParser = new fasta.Parser(new ForwardingTestListener(astBuilder));
     astBuilder.parser = fastaParser;
-    return new ParserProxy._(startingToken, fastaParser, astBuilder);
+    return new ParserProxy._(
+        startingToken, fastaParser, astBuilder, errorListener);
   }
 
-  ParserProxy._(this._currentFastaToken, this._fastaParser, this._astBuilder);
+  ParserProxy._(this._currentFastaToken, this._fastaParser, this._astBuilder,
+      this._errorListener);
 
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   ClassMember parseClassMember(String className) {
     _astBuilder.className = className;
     var result = _run((parser) => parser.parseMember) as ClassMember;
     _astBuilder.className = null;
     return result;
   }
@@ skipping 160 matching lines @@
     super.test_parsePartOfDirective_name();
   }
 
   @override
   @failingTest
   void test_parsePartOfDirective_uri() {
     // TODO(paulberry,ahe): URIs in "part of" declarations are not supported by
     // Fasta.
     super.test_parsePartOfDirective_uri();
   }
+
+  @failingTest
+  void test_parseCompilationUnit_operatorAsPrefix_parameterized2() {
+    // TODO(danrubel): should not be generating an error
+    super.test_parseCompilationUnit_operatorAsPrefix_parameterized();
+    assertNoErrors();
+  }
+
+  @failingTest
+  void test_parseCompilationUnit_typedefAsPrefix2() {
+    // TODO(danrubel): should not be generating an error
+    super.test_parseCompilationUnit_typedefAsPrefix();
+    assertNoErrors();
+  }
+
+  @failingTest
+  void test_parseCompilationUnitMember_abstractAsPrefix2() {
+    // TODO(danrubel): should not be generating an error
+    super.test_parseCompilationUnitMember_abstractAsPrefix();
+    assertNoErrors();
+  }
 }