Clean-up the registration of plugins

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/context/context.dart' as newContext;
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 1279 matching lines @@
     _listener.assertNoErrors();
   }
 
   void fail_visitRedirectingConstructorInvocation() {
     fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   @override
   void setUp() {
+    super.setUp();
     _listener = new GatheringErrorListener();
     _typeProvider = new TestTypeProvider();
     _resolver = _createResolver();
   }
 
   void test_lookUpMethodInInterfaces() {
     InterfaceType intType = _typeProvider.intType;
     //
     // abstract class A { int operator[](int index); }
     //
@@ skipping 3518 matching lines @@
   }
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [HintCode.USE_OF_VOID_RESULT, HintCode.USE_OF_VOID_RESULT]);
     verify([source]);
   }
 }
 
 @reflectiveTest
-class InheritanceManagerTest extends EngineTestCase {
+class InheritanceManagerTest {
   /**
    * The type provider used to access the types.
    */
   TestTypeProvider _typeProvider;
 
   /**
    * The library containing the code being resolved.
    */
   LibraryElementImpl _definingLibrary;
 
   /**
    * The inheritance manager being tested.
    */
   InheritanceManager _inheritanceManager;
 
   /**
    * The number of members that Object implements (as determined by [TestTypeProvider]).
    */
   int _numOfMembersInObject = 0;
 
-  @override
   void setUp() {
     _typeProvider = new TestTypeProvider();
     _inheritanceManager = _createInheritanceManager();
     InterfaceType objectType = _typeProvider.objectType;
     _numOfMembersInObject =
         objectType.methods.length + objectType.accessors.length;
   }
 
   void test_getMapOfMembersInheritedFromClasses_accessor_extends() {
     // class A { int get g; }
@@ skipping 1183 matching lines @@
         new CompilationUnitElementImpl("test.dart");
     definingCompilationUnit.librarySource =
         definingCompilationUnit.source = source;
     _definingLibrary = ElementFactory.library(context, "test");
     _definingLibrary.definingCompilationUnit = definingCompilationUnit;
     return new InheritanceManager(_definingLibrary);
   }
 }
 
 @reflectiveTest
-class LibraryElementBuilderTest extends EngineTestCase {
+class LibraryElementBuilderTest {
   /**
    * The analysis context used to analyze sources.
    */
   InternalAnalysisContext _context;
 
   /**
    * Add a source file to the content provider. The file path should be absolute.
    *
    * @param filePath the path of the file being added
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the added file
    */
   Source addSource(String filePath, String contents) {
     Source source = new FileBasedSource(FileUtilities2.createFile(filePath));
     _context.setContents(source, contents);
     return source;
   }
 
-  @override
   void setUp() {
     _context = AnalysisContextFactory.contextWithCore();
   }
 
-  @override
   void tearDown() {
     _context = null;
-    super.tearDown();
   }
 
   void test_accessorsAcrossFiles() {
     Source librarySource = addSource(
         "/lib.dart",
         r'''
 library lib;
 part 'first.dart';
 part 'second.dart';''');
     addSource(
@@ skipping 477 matching lines @@
 
   void test_getErrorListener() {
     LibraryElement definingLibrary = createDefaultTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
     LibraryScope scope = new LibraryScope(definingLibrary, errorListener);
     expect(scope.errorListener, errorListener);
   }
 }
 
 @reflectiveTest
-class LibraryTest extends EngineTestCase {
+class LibraryTest {
   /**
    * The error listener to which all errors will be reported.
    */
   GatheringErrorListener _errorListener;
 
   /**
    * The analysis context to pass in to all libraries created by the tests.
    */
   InternalAnalysisContext _analysisContext;
 
   /**
    * The library used by the tests.
    */
   Library _library;
 
-  @override
   void setUp() {
     _analysisContext = AnalysisContextFactory.contextWithCore();
     _errorListener = new GatheringErrorListener();
     _library = _createLibrary("/lib.dart");
   }
 
-  @override
   void tearDown() {
     _errorListener = null;
     _analysisContext = null;
     _library = null;
-    super.tearDown();
   }
 
   void test_getExplicitlyImportsCore() {
     expect(_library.explicitlyImportsCore, isFalse);
     _errorListener.assertNoErrors();
   }
 
   void test_getExports() {
     expect(_library.exports, hasLength(0));
     _errorListener.assertNoErrors();
@@ skipping 1787 matching lines @@
 
   void resolveWithErrors(List<String> strSources, List<ErrorCode> codes) {
     // Analysis and assertions
     Source source = resolveSources(strSources);
     assertErrors(source, codes);
     verify([source]);
   }
 
   @override
   void setUp() {
+    super.setUp();
     reset();
   }
 
   @override
   void tearDown() {
     analysisContext2 = null;
     super.tearDown();
   }
 
   /**
@@ skipping 1916 matching lines @@
     _listener.assertNoErrors();
   }
 
   void fail_visitSimpleIdentifier() {
     fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   @override
   void setUp() {
+    super.setUp();
     _listener = new GatheringErrorListener();
     _typeProvider = new TestTypeProvider();
     _analyzer = _createAnalyzer();
   }
 
   void test_flatten_derived() {
     // class Derived<T> extends Future<T> { ... }
     ClassElementImpl derivedClass =
         ElementFactory.classElement2('Derived', ['T']);
     derivedClass.supertype = _typeProvider.futureType
@@ skipping 2250 matching lines @@
   v; // marker
 }
 int x = 3;
 ''';
     _assertPropagatedAssignedType(code, typeProvider.intType, null);
     _assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 }
 
 @reflectiveTest
-class SubtypeManagerTest extends EngineTestCase {
+class SubtypeManagerTest {
   /**
    * The inheritance manager being tested.
    */
   SubtypeManager _subtypeManager;
 
   /**
    * The compilation unit element containing all of the types setup in each test.
    */
   CompilationUnitElementImpl _definingCompilationUnit;
 
-  @override
   void setUp() {
-    super.setUp();
     AnalysisContext context = AnalysisContextFactory.contextWithCore();
     FileBasedSource source =
         new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     _definingCompilationUnit = new CompilationUnitElementImpl("test.dart");
     _definingCompilationUnit.librarySource =
         _definingCompilationUnit.source = source;
     LibraryElementImpl definingLibrary =
         ElementFactory.library(context, "test");
     definingLibrary.definingCompilationUnit = _definingCompilationUnit;
     _subtypeManager = new SubtypeManager();
@@ skipping 1832 matching lines @@
         }
         element.typeParameters = typeParameters;
         type.typeArguments = typeArguments;
       }
     }
     return element;
   }
 }
 
 @reflectiveTest
-class TypeResolverVisitorTest extends EngineTestCase {
+class TypeResolverVisitorTest {
   /**
    * 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.
    */
   Library _library;
@@ skipping 21 matching lines @@
   void fail_visitVariableDeclaration() {
     fail("Not yet tested");
     ClassElement type = ElementFactory.classElement2("A");
     VariableDeclaration node = AstFactory.variableDeclaration("a");
     AstFactory.variableDeclarationList(null, AstFactory.typeName(type), [node]);
     //resolve(node);
     expect(node.name.staticType, same(type.type));
     _listener.assertNoErrors();
   }
 
-  @override
   void setUp() {
     _listener = new GatheringErrorListener();
     InternalAnalysisContext context = AnalysisContextFactory.contextWithCore();
     Source librarySource =
         new FileBasedSource(FileUtilities2.createFile("/lib.dart"));
     _library = new Library(context, _listener, librarySource);
     LibraryElementImpl element = new LibraryElementImpl.forNode(
         context, AstFactory.libraryIdentifier2(["lib"]));
     element.definingCompilationUnit =
         new CompilationUnitElementImpl("lib.dart");
@@ skipping 644 matching lines @@
 
   void _resolveTestUnit(String code) {
     testCode = code;
     testSource = addSource(testCode);
     LibraryElement library = resolve2(testSource);
     assertNoErrors(testSource);
     verify([testSource]);
     testUnit = resolveCompilationUnit(testSource, library);
   }
 }