Replace @ReflectiveTestCase() with @reflectiveTest.

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.
 
 library engine.parser_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/incremental_scanner.dart';
@@ skipping 105 matching lines @@
   }
 }
 
 /**
  * The class `ComplexParserTest` defines parser tests that test the parsing of more complex
  * code fragments or the interactions between multiple parsing methods. For example, tests to ensure
  * that the precedence of operations is being handled correctly should be defined in this class.
  *
  * Simpler tests should be defined in the class [SimpleParserTest].
  */
-@ReflectiveTestCase()
+@reflectiveTest
 class ComplexParserTest extends ParserTestCase {
   void test_additiveExpression_normal() {
     BinaryExpression expression = ParserTestCase.parseExpression("x + y - z");
     EngineTestCase.assertInstanceOf(
         (obj) => obj is BinaryExpression,
         BinaryExpression,
         expression.leftOperand);
   }
 
   void test_additiveExpression_noSpaces() {
@@ skipping 440 matching lines @@
 
   void test_topLevelVariable_withMetadata() {
     ParserTestCase.parseCompilationUnit("String @A string;");
   }
 }
 
 /**
  * The class `ErrorParserTest` defines parser tests that test the parsing of code to ensure
  * that errors are correctly reported, and in some cases, not reported.
  */
-@ReflectiveTestCase()
+@reflectiveTest
 class ErrorParserTest extends ParserTestCase {
   void fail_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().
     TypedLiteral literal = ParserTestCase.parse3(
         "parseListOrMapLiteral",
@@ skipping 1973 matching lines @@
   }
 
   void test_wrongTerminatorForParameterGroup_optional() {
     ParserTestCase.parse4(
         "parseFormalParameterList",
         "(a, [b, c})",
         [ParserErrorCode.WRONG_TERMINATOR_FOR_PARAMETER_GROUP]);
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class IncrementalParserTest extends EngineTestCase {
   void fail_replace_identifier_with_functionLiteral_in_initializer_interp() {
     // TODO(paulberry, brianwilkerson): broken due to incremental scanning bugs
 
     // Function literals are allowed inside interpolation expressions in
     // initializers.
     //
     // 'class A { var a; A(b) : a = "${b}";'
     // 'class A { var a; A(b) : a = "${() {}}";'
     _assertParse(r'class A { var a; A(b) : a = "${', 'b', '() {}', '}";');
@@ skipping 370 matching lines @@
     expect(incrementalUnit, isNotNull);
     //
     // Validate that the results of the incremental parse are the same as the
     // full parse of the modified source.
     //
     expect(AstComparator.equalNodes(modifiedUnit, incrementalUnit), isTrue);
     // TODO(brianwilkerson) Verify that the errors are correct?
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class NonErrorParserTest extends ParserTestCase {
   void test_constFactory_external() {
     ParserTestCase.parse(
         "parseClassMember",
         <Object>["C"],
         "external const factory C();");
   }
 }
 
 class ParserTestCase extends EngineTestCase {
@@ skipping 277 matching lines @@
     expect(statements, hasLength(expectedCount));
     listener.assertErrorsWithCodes(errorCodes);
     return statements;
   }
 }
 
 /**
  * The class `RecoveryParserTest` defines parser tests that test the parsing of invalid code
  * sequences to ensure that the correct recovery steps are taken in the parser.
  */
-@ReflectiveTestCase()
+@reflectiveTest
 class RecoveryParserTest extends ParserTestCase {
   void fail_incomplete_returnType() {
     ParserTestCase.parseCompilationUnit(r'''
 Map<Symbol, convertStringToSymbolMap(Map<String, dynamic> map) {
   if (map == null) return null;
   Map<Symbol, dynamic> result = new Map<Symbol, dynamic>();
   map.forEach((name, value) {
     result[new Symbol(name)] = value;
   });
   return result;
@@ skipping 1225 matching lines @@
         (obj) => obj is FunctionTypeAlias,
         FunctionTypeAlias,
         member);
   }
 
   void test_unaryPlus() {
     ParserTestCase.parseExpression("+2", [ParserErrorCode.MISSING_IDENTIFIER]);
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class ResolutionCopierTest extends EngineTestCase {
   void test_visitAnnotation() {
     String annotationName = "proxy";
     Annotation fromNode =
         AstFactory.annotation(AstFactory.identifier3(annotationName));
     Element element = ElementFactory.topLevelVariableElement2(annotationName);
     fromNode.element = element;
     Annotation toNode =
         AstFactory.annotation(AstFactory.identifier3(annotationName));
     ResolutionCopier.copyResolutionData(fromNode, toNode);
@@ skipping 629 matching lines @@
   }
 }
 
 /**
  * The class `SimpleParserTest` defines parser tests that test individual parsing method. The
  * code fragments should be as minimal as possible in order to test the method, but should not test
  * the interactions between the method under test and other methods.
  *
  * More complex tests should be defined in the class [ComplexParserTest].
  */
-@ReflectiveTestCase()
+@reflectiveTest
 class SimpleParserTest extends ParserTestCase {
   void fail_parseCommentReference_this() {
     // This fails because we are returning null from the method and asserting
     // that the return value is not null.
     CommentReference reference =
         ParserTestCase.parse("parseCommentReference", <Object>["this", 5], "");
     SimpleIdentifier identifier = EngineTestCase.assertInstanceOf(
         (obj) => obj is SimpleIdentifier,
         SimpleIdentifier,
         reference.identifier);
@@ skipping 5804 matching lines @@
     // Parse the source.
     //
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(
         parser,
         methodName,
         <Object>[tokenStream],
         tokenStream) as Token;
   }
 }