Replace @ReflectiveTestCase() with @reflectiveTest.

pkg/analyzer/test/generated/resolver_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.resolver_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 445 matching lines @@
   }
 
   void runTasks() {
     AnalysisResult result = context.performAnalysisTask();
     while (result.changeNotices != null) {
       result = context.performAnalysisTask();
     }
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class AnalysisDeltaTest extends EngineTestCase {
   TestSource source1 = new TestSource('/1.dart');
   TestSource source2 = new TestSource('/2.dart');
   TestSource source3 = new TestSource('/3.dart');
 
   void test_getAddedSources() {
     AnalysisDelta delta = new AnalysisDelta();
     delta.setAnalysisLevel(source1, AnalysisLevel.ALL);
     delta.setAnalysisLevel(source2, AnalysisLevel.ERRORS);
     delta.setAnalysisLevel(source3, AnalysisLevel.NONE);
@@ skipping 19 matching lines @@
 
   void test_toString() {
     AnalysisDelta delta = new AnalysisDelta();
     delta.setAnalysisLevel(new TestSource(), AnalysisLevel.ALL);
     String result = delta.toString();
     expect(result, isNotNull);
     expect(result.length > 0, isTrue);
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class ChangeSetTest extends EngineTestCase {
   void test_changedContent() {
     TestSource source = new TestSource();
     String content = "";
     ChangeSet changeSet = new ChangeSet();
     changeSet.changedContent(source, content);
     expect(changeSet.addedSources, hasLength(0));
     expect(changeSet.changedSources, hasLength(0));
     Map<Source, String> map = changeSet.changedContents;
     expect(map, hasLength(1));
@@ skipping 32 matching lines @@
     changeSet.changedContent(new TestSource(), "");
     changeSet.changedRange(new TestSource(), "", 0, 0, 0);
     changeSet.deletedSource(new TestSource());
     changeSet.removedSource(new TestSource());
     changeSet.removedContainer(
         new SourceContainer_ChangeSetTest_test_toString());
     expect(changeSet.toString(), isNotNull);
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class CheckedModeCompileTimeErrorCodeTest extends ResolverTestCase {
   void test_fieldFormalParameterAssignableToField_extends() {
     // According to checked-mode type checking rules, a value of type B is
     // assignable to a field of type A, because B extends A (and hence is a
     // subtype of A).
     Source source = addSource(r'''
 class A {
   const A();
 }
 class B extends A {
@@ skipping 565 matching lines @@
     resolve(source);
     assertErrors(
         source,
         [
             CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH,
             StaticWarningCode.UNDEFINED_CLASS]);
     verify([source]);
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class ElementResolverTest extends EngineTestCase {
   /**
    * The error listener to which errors will be reported.
    */
   GatheringErrorListener _listener;
 
   /**
    * The type provider used to access the types.
    */
   TestTypeProvider _typeProvider;
@@ skipping 913 matching lines @@
         statement.accept(_resolver);
       } finally {
         _visitor.labelScope_J2DAccessor = outerScope;
       }
     } catch (exception) {
       throw new IllegalArgumentException("Could not resolve node", exception);
     }
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class EnclosedScopeTest extends ResolverTestCase {
   void test_define_duplicate() {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scope rootScope =
         new Scope_EnclosedScopeTest_test_define_duplicate(listener);
     EnclosedScope scope = new EnclosedScope(rootScope);
     VariableElement element1 =
         ElementFactory.localVariableElement(AstFactory.identifier3("v1"));
     VariableElement element2 =
         ElementFactory.localVariableElement(AstFactory.identifier3("v1"));
@@ skipping 10 matching lines @@
     VariableElement element1 =
         ElementFactory.localVariableElement(AstFactory.identifier3("v1"));
     VariableElement element2 =
         ElementFactory.localVariableElement(AstFactory.identifier3("v2"));
     outerScope.define(element1);
     innerScope.define(element2);
     listener.assertNoErrors();
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class ErrorResolverTest extends ResolverTestCase {
   void test_breakLabelOnSwitchMember() {
     Source source = addSource(r'''
 class A {
   void m(int i) {
     switch (i) {
       l: case 0:
         break;
       case 1:
         break l;
@@ skipping 42 matching lines @@
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     List<FunctionElement> functions = constructor.functions;
     expect(functions, isNotNull);
     expect(functions, hasLength(1));
     expect(functions[0].enclosingElement, constructor);
     assertErrors(source, [ParserErrorCode.GETTER_IN_FUNCTION]);
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class HintCodeTest extends ResolverTestCase {
   void fail_deadCode_statementAfterRehrow() {
     Source source = addSource(r'''
 f() {
   try {
     var one = 1;
   } catch (e) {
     rethrow;
     var two = 2;
   }
@@ skipping 2249 matching lines @@
   }
 }''');
     resolve(source);
     assertErrors(
         source,
         [HintCode.USE_OF_VOID_RESULT, HintCode.USE_OF_VOID_RESULT]);
     verify([source]);
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class InheritanceManagerTest extends EngineTestCase {
   /**
    * The type provider used to access the types.
    */
   TestTypeProvider _typeProvider;
 
   /**
    * The library containing the code being resolved.
    */
   LibraryElementImpl _definingLibrary;
@@ skipping 1197 matching lines @@
         new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
     CompilationUnitElementImpl definingCompilationUnit =
         new CompilationUnitElementImpl("test.dart");
     definingCompilationUnit.source = source;
     _definingLibrary = ElementFactory.library(context, "test");
     _definingLibrary.definingCompilationUnit = definingCompilationUnit;
     return new InheritanceManager(_definingLibrary);
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class LibraryElementBuilderTest extends EngineTestCase {
   /**
    * The analysis context used to analyze sources.
    */
   AnalysisContextImpl _context;
 
   /**
    * Add a source file to the content provider. The file path should be absolute.
    *
    * @param filePath the path of the file being added
@@ skipping 163 matching lines @@
         new LibraryElementBuilder(resolver.analysisContext, resolver.errorListener);
     Library library = resolver.createLibrary(librarySource);
     LibraryElement element = builder.buildLibrary(library);
     GatheringErrorListener listener = new GatheringErrorListener();
     listener.addAll2(resolver.errorListener);
     listener.assertErrorsWithCodes(expectedErrorCodes);
     return element;
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class LibraryImportScopeTest extends ResolverTestCase {
   void test_conflictingImports() {
     AnalysisContext context = new AnalysisContextImpl();
     context.sourceFactory = new SourceFactory([]);
     String typeNameA = "A";
     String typeNameB = "B";
     String typeNameC = "C";
     ClassElement typeA = ElementFactory.classElement2(typeNameA);
     ClassElement typeB1 = ElementFactory.classElement2(typeNameB);
     ClassElement typeB2 = ElementFactory.classElement2(typeNameB);
@@ skipping 175 matching lines @@
         scope.lookup(AstFactory.identifier5(prefixName, typeName), importingLibrary);
     errorListener.assertNoErrors();
     expect(prefixedElement, same(prefixedType));
     Element nonPrefixedElement =
         scope.lookup(AstFactory.identifier3(typeName), importingLibrary);
     errorListener.assertNoErrors();
     expect(nonPrefixedElement, same(nonPrefixedType));
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class LibraryResolver2Test extends ResolverTestCase {
   LibraryResolver2 _resolver;
 
   Source _coreLibrarySource;
 
   @override
   void setUp() {
     super.setUp();
     _resolver = new LibraryResolver2(analysisContext2);
     _coreLibrarySource =
@@ skipping 26 matching lines @@
 
   ResolvableLibrary _createResolvableLibrary(Source source) {
     CompilationUnit unit = analysisContext2.parseCompilationUnit(source);
     ResolvableLibrary resolvableLibrary = new ResolvableLibrary(source);
     resolvableLibrary.resolvableCompilationUnits =
         <ResolvableCompilationUnit>[new ResolvableCompilationUnit(source, unit)];
     return resolvableLibrary;
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class LibraryResolverTest extends ResolverTestCase {
   LibraryResolver _resolver;
 
   @override
   void setUp() {
     super.setUp();
     _resolver = new LibraryResolver(analysisContext2);
   }
 
   void test_imports_dart_html() {
@@ skipping 20 matching lines @@
     Source source = addSource(r'''
 library libA;
 import 'libB.dart';
 class A {}''');
     LibraryElement library = _resolver.resolveLibrary(source, true);
     List<LibraryElement> importedLibraries = library.importedLibraries;
     assertNamedElements(importedLibraries, ["dart.core", "libB"]);
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class LibraryScopeTest extends ResolverTestCase {
   void test_creation_empty() {
     LibraryElement definingLibrary = createDefaultTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
     new LibraryScope(definingLibrary, errorListener);
   }
 
   void test_creation_nonEmpty() {
     AnalysisContext context = new AnalysisContextImpl();
     context.sourceFactory = new SourceFactory([]);
@@ skipping 16 matching lines @@
   }
 
   void test_getErrorListener() {
     LibraryElement definingLibrary = createDefaultTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
     LibraryScope scope = new LibraryScope(definingLibrary, errorListener);
     expect(scope.errorListener, errorListener);
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class LibraryTest extends EngineTestCase {
   /**
    * The error listener to which all errors will be reported.
    */
   GatheringErrorListener _errorListener;
 
   /**
    * The source factory used to create libraries.
    */
   SourceFactory _sourceFactory;
@@ skipping 96 matching lines @@
   }
 
   Library _createLibrary(String definingCompilationUnitPath) =>
       new Library(
           _analysisContext,
           _errorListener,
           new FileBasedSource.con1(
               FileUtilities2.createFile(definingCompilationUnitPath)));
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class MemberMapTest {
   /**
    * The null type.
    */
   InterfaceType _nullType;
 
   void setUp() {
     _nullType = new TestTypeProvider().nullType;
   }
 
@@ skipping 25 matching lines @@
   void test_MemberMap_put() {
     MethodElement m1 = ElementFactory.methodElement("m1", _nullType);
     MemberMap map = new MemberMap();
     expect(map.size, 0);
     map.put(m1.name, m1);
     expect(map.size, 1);
     expect(map.get("m1"), m1);
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class NonHintCodeTest extends ResolverTestCase {
   void test_deadCode_deadBlock_conditionalElse_debugConst() {
     Source source = addSource(r'''
 const bool DEBUG = true;
 f() {
   DEBUG ? 1 : 2;
 }''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
@@ skipping 1628 matching lines @@
 
   @override
   AnalysisErrorListener get errorListener => listener;
 
   @override
   Element internalLookup(Identifier identifier, String name,
       LibraryElement referencingLibrary) =>
       null;
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class ScopeTest extends ResolverTestCase {
   void test_define_duplicate() {
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ScopeTest_TestScope scope = new ScopeTest_TestScope(errorListener);
     VariableElement element1 =
         ElementFactory.localVariableElement(AstFactory.identifier3("v1"));
     VariableElement element2 =
         ElementFactory.localVariableElement(AstFactory.identifier3("v1"));
     scope.define(element1);
     scope.define(element2);
@@ skipping 37 matching lines @@
   final AnalysisErrorListener errorListener;
 
   ScopeTest_TestScope(this.errorListener);
 
   @override
   Element internalLookup(Identifier identifier, String name,
       LibraryElement referencingLibrary) =>
       localLookup(name, referencingLibrary);
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class SimpleResolverTest extends ResolverTestCase {
   void fail_staticInvocation() {
     Source source = addSource(r'''
 class A {
   static int get g => (a,b) => 0;
 }
 class B {
   f() {
     A.g(1,0);
   }
@@ skipping 1321 matching lines @@
 }
 
 class SourceContainer_ChangeSetTest_test_toString implements SourceContainer {
   @override
   bool contains(Source source) => false;
 }
 
 /**
  * Like [StaticTypeAnalyzerTest], but as end-to-end tests.
  */
-@ReflectiveTestCase()
+@reflectiveTest
 class StaticTypeAnalyzer2Test extends ResolverTestCase {
   String testCode;
   Source testSource;
   CompilationUnit testUnit;
 
   void test_MethodInvocation_nameType_localVariable() {
     String code = r"""
 typedef Foo();
 main() {
   Foo foo;
@@ skipping 52 matching lines @@
   void _resolveTestUnit(String code) {
     testCode = code;
     testSource = addSource(testCode);
     LibraryElement library = resolve(testSource);
     assertNoErrors(testSource);
     verify([testSource]);
     testUnit = resolveCompilationUnit(testSource, library);
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class StaticTypeAnalyzerTest extends EngineTestCase {
   /**
    * The error listener to which errors will be reported.
    */
   GatheringErrorListener _listener;
 
   /**
    * The resolver visitor used to create the analyzer.
    */
   ResolverVisitor _visitor;
@@ skipping 1398 matching lines @@
       }
     }
     return "<unknown file- ASTNode is null>";
   }
 }
 
 /**
  * The class `StrictModeTest` contains tests to ensure that the correct errors and warnings
  * are reported when the analysis engine is run in strict mode.
  */
-@ReflectiveTestCase()
+@reflectiveTest
 class StrictModeTest extends ResolverTestCase {
   void fail_for() {
     Source source = addSource(r'''
 int f(List<int> list) {
   num sum = 0;
   for (num i = 0; i < list.length; i++) {
     sum += list[i];
   }
 }''');
     resolve(source);
@@ skipping 131 matching lines @@
     Source source = addSource(r'''
 int f() {
   num n = 1234;
   return n & 0x0F;
 }''');
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class SubtypeManagerTest extends EngineTestCase {
   /**
    * The inheritance manager being tested.
    */
   SubtypeManager _subtypeManager;
 
   /**
    * The compilation unit element containing all of the types setup in each test.
    */
   CompilationUnitElementImpl _definingCompilationUnit;
@@ skipping 545 matching lines @@
       FunctionTypeImpl functionType = method.type as FunctionTypeImpl;
       functionType.typeArguments = typeArguments;
     }
     for (ConstructorElement constructor in classElement.constructors) {
       FunctionTypeImpl functionType = constructor.type as FunctionTypeImpl;
       functionType.typeArguments = typeArguments;
     }
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class TypeOverrideManagerTest extends EngineTestCase {
   void test_exitScope_noScopes() {
     TypeOverrideManager manager = new TypeOverrideManager();
     try {
       manager.exitScope();
       fail("Expected IllegalStateException");
     } on IllegalStateException catch (exception) {
       // Expected
     }
   }
@@ skipping 50 matching lines @@
     manager.enterScope();
     expect(manager.getType(ElementFactory.localVariableElement2("v")), isNull);
   }
 
   void test_getType_noScope() {
     TypeOverrideManager manager = new TypeOverrideManager();
     expect(manager.getType(ElementFactory.localVariableElement2("v")), isNull);
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class TypePropagationTest extends ResolverTestCase {
   void fail_mergePropagatedTypesAtJoinPoint_1() {
     // https://code.google.com/p/dart/issues/detail?id=19929
     _assertTypeOfMarkedExpression(r'''
 f1(x) {
   var y = [];
   if (x) {
     y = 0;
   } else {
     y = '';
@@ skipping 1455 matching lines @@
       // assertion failure here should be a failure, in both "test_*" and
       // "fail_*" tests. However, an assertion failure is success for the
       // purpose of "fail_*" tests, so without catching them here "fail_*" tests
       // can succeed by failing for the wrong reason.
       throw new JavaException("Unexexpected assertion failure: $exception");
     }
   }
 }
 
 
-@ReflectiveTestCase()
+@reflectiveTest
 class TypeProviderImplTest extends EngineTestCase {
   void test_creation() {
     //
     // Create a mock library element with the types expected to be in dart:core.
     // We cannot use either ElementFactory or TestTypeProvider (which uses
     // ElementFactory) because we side-effect the elements in ways that would
     // break other tests.
     //
     InterfaceType objectType = _classElement("Object", null).type;
     InterfaceType boolType = _classElement("bool", objectType).type;
@@ skipping 66 matching lines @@
           typeParameter.type = typeArguments[i];
         }
         element.typeParameters = typeParameters;
         type.typeArguments = typeArguments;
       }
     }
     return element;
   }
 }
 
-@ReflectiveTestCase()
+@reflectiveTest
 class TypeResolverVisitorTest extends EngineTestCase {
   /**
    * The error listener to which errors will be reported.
    */
   GatheringErrorListener _listener;
 
   /**
    * The object representing the information about the library in which the types are being
    * resolved.
    */
@@ skipping 578 matching lines @@
         // check propagated type
         FunctionType propagatedType = node.propagatedType as FunctionType;
         expect(propagatedType.returnType, test.typeProvider.stringType);
       } on AnalysisException catch (e, stackTrace) {
         thrownException[0] = new CaughtException(e, stackTrace);
       }
     }
     return null;
   }
 }