report abstract as extraneous modifier

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/dart/ast/token.dart' show TokenType;
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart' show ErrorReporter;
 import 'package:analyzer/src/dart/scanner/scanner.dart';
@@ skipping 119 matching lines @@
 }
 
 /**
  * Tests of the fasta parser based on [ErrorParserTest].
  */
 @reflectiveTest
 class ErrorParserTest_Fasta extends FastaParserTestCase
     with ErrorParserTestMixin {
   @override
   @failingTest
-  void test_abstractClassMember_field() {
-    super.test_abstractClassMember_field();
-  }
-
-  @override
-  @failingTest
   void test_abstractEnum() {
     super.test_abstractEnum();
   }
 
   @override
   @failingTest
-  void test_abstractTopLevelFunction_function() {
-    super.test_abstractTopLevelFunction_function();
-  }
-
-  @override
-  @failingTest
-  void test_abstractTopLevelFunction_getter() {
-    super.test_abstractTopLevelFunction_getter();
-  }
-
-  @override
-  @failingTest
-  void test_abstractTopLevelFunction_setter() {
-    super.test_abstractTopLevelFunction_setter();
-  }
-
-  @override
-  @failingTest
-  void test_abstractTopLevelVariable() {
-    super.test_abstractTopLevelVariable();
-  }
-
-  @override
-  @failingTest
   void test_abstractTypeDef() {
     super.test_abstractTypeDef();
   }
 
   @override
   @failingTest
   void test_annotationOnEnumConstant_first() {
     super.test_annotationOnEnumConstant_first();
   }
 
@@ skipping 2044 matching lines @@
   }
 
   @override
   analyzer.Parser get parser => _parserProxy;
 
   @override
   bool get usingFastaParser => true;
 
   @override
   void assertErrorsWithCodes(List<ErrorCode> expectedErrorCodes) {
-    expectedErrorCodes = expectedErrorCodes.map((code) {
-      if (code == ParserErrorCode.ABSTRACT_CLASS_MEMBER)
-        return ParserErrorCode.EXTRANEOUS_MODIFIER;
-      return code;
-    }).toList();
-    _parserProxy._errorListener.assertErrorsWithCodes(expectedErrorCodes);
+    _parserProxy._errorListener.assertErrorsWithCodes(
+        _toFastaGeneratedAnalyzerErrorCodes(expectedErrorCodes));
   }
 
   @override
   void assertNoErrors() {
     _parserProxy._errorListener.assertNoErrors();
   }
 
   @override
   void createParser(String content) {
     var scanner = new StringScanner(content, includeComments: true);
@@ skipping 69 matching lines @@
     var scanner = new Scanner.fasta(source, listener);
     scanner.scanGenericMethodComments = enableGenericMethodComments;
     _fastaTokens = scanner.tokenize();
 
     // Run parser
     analyzer.Parser parser =
         new analyzer.Parser(source, listener, useFasta: true);
     CompilationUnit unit = parser.parseCompilationUnit(_fastaTokens);
 
     // Assert and return result
-    listener.assertErrorsWithCodes(expectedErrorCodes);
+    listener.assertErrorsWithCodes(
+        _toFastaGeneratedAnalyzerErrorCodes(expectedErrorCodes));
     expect(unit, isNotNull);
     return unit;
   }
 
   @override
   ConditionalExpression parseConditionalExpression(String code) {
     return _parseExpression(code);
   }
 
   @override
@@ skipping 246 matching lines @@
   Object _runParser(
       String source, ParseFunction getParseFunction(fasta.Parser parser),
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
     if (errorCodes.isNotEmpty) {
       // TODO(paulberry): Check that the parser generates the proper errors.
       throw new UnimplementedError();
     }
     createParser(source);
     return _parserProxy._run(getParseFunction);
   }
+
+  List<ErrorCode> _toFastaGeneratedAnalyzerErrorCodes(
+          List<ErrorCode> expectedErrorCodes) =>
+      expectedErrorCodes.map((code) {
+        if (code == ParserErrorCode.ABSTRACT_CLASS_MEMBER ||
+            code == ParserErrorCode.ABSTRACT_TOP_LEVEL_FUNCTION ||
+            code == ParserErrorCode.ABSTRACT_TOP_LEVEL_VARIABLE)
+          return ParserErrorCode.EXTRANEOUS_MODIFIER;
+        return code;
+      }).toList();
 }
 
 /**
  * Tests of the fasta parser based on [FormalParameterParserTestMixin].
  */
 @reflectiveTest
 class FormalParameterParserTest_Fasta extends FastaParserTestCase
     with FormalParameterParserTestMixin {
   @override
   @failingTest
@@ skipping 395 matching lines @@
     assertNoErrors();
   }
 
   @failingTest
   void test_parseCompilationUnitMember_abstractAsPrefix2() {
     // TODO(danrubel): should not be generating an error
     super.test_parseCompilationUnitMember_abstractAsPrefix();
     assertNoErrors();
   }
 }