Make some parser test helper methods non-static.

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 analyzer.test.generated.resolver_test;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 1022 matching lines @@
       d = false;
     } else {
       x = '';
       c = true;
       continue;
     }
     x; // marker
   }
 }''';
     CompilationUnit unit = await resolveSource(code);
-    DartType t =
-        findMarkedIdentifier(code, unit, "; // marker").propagatedType;
+    DartType t = findMarkedIdentifier(code, unit, "; // marker").propagatedType;
     expect(typeProvider.intType.isSubtypeOf(t), isTrue);
     expect(typeProvider.stringType.isSubtypeOf(t), isTrue);
   }
 
   fail_mergePropagatedTypesAtJoinPoint_8() async {
     // https://code.google.com/p/dart/issues/detail?id=19929
     //
     // In nested loops [breaks]s are unsafe for the purposes of
     // [isAbruptTerminationStatement].
     //
@@ skipping 12 matching lines @@
       } else {
         x = '';
         c = true;
         break;
       }
       x; // marker
     }
   }
 }''';
     CompilationUnit unit = await resolveSource(code);
-    DartType t =
-        findMarkedIdentifier(code, unit, "; // marker").propagatedType;
+    DartType t = findMarkedIdentifier(code, unit, "; // marker").propagatedType;
     expect(typeProvider.intType.isSubtypeOf(t), isTrue);
     expect(typeProvider.stringType.isSubtypeOf(t), isTrue);
   }
 
   fail_propagatedReturnType_functionExpression() async {
     // TODO(scheglov) disabled because we don't resolve function expression
     String code = r'''
 main() {
   var v = (() {return 42;})();
 }''';
@@ skipping 987 matching lines @@
     v = '';
   }
   return v;
 }''';
     CompilationUnit unit = await resolveSource(code);
     {
       SimpleIdentifier identifier = findMarkedIdentifier(code, unit, "v;");
       expect(identifier.propagatedType, null);
     }
     {
-      SimpleIdentifier identifier =
-          findMarkedIdentifier(code, unit, "v = '';");
+      SimpleIdentifier identifier = findMarkedIdentifier(code, unit, "v = '';");
       expect(identifier.propagatedType, typeProvider.stringType);
     }
   }
 
   test_mergePropagatedTypes_afterIfThen_same() async {
     var code = r'''
 main() {
   var v = 1;
   if (v != null) {
     v = 2;
@@ skipping 320 matching lines @@
     // 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;
     InterfaceType numType = _classElement("num", objectType).type;
     InterfaceType doubleType = _classElement("double", numType).type;
     InterfaceType functionType = _classElement("Function", objectType).type;
     InterfaceType futureType = _classElement("Future", objectType, ["T"]).type;
-    InterfaceType futureOrType = _classElement("FutureOr", objectType, ["T"]).type;
+    InterfaceType futureOrType =
+        _classElement("FutureOr", objectType, ["T"]).type;
     InterfaceType intType = _classElement("int", numType).type;
     InterfaceType iterableType =
         _classElement("Iterable", objectType, ["T"]).type;
     InterfaceType listType = _classElement("List", objectType, ["E"]).type;
     InterfaceType mapType = _classElement("Map", objectType, ["K", "V"]).type;
     InterfaceType stackTraceType = _classElement("StackTrace", objectType).type;
     InterfaceType streamType = _classElement("Stream", objectType, ["T"]).type;
     InterfaceType stringType = _classElement("String", objectType).type;
     InterfaceType symbolType = _classElement("Symbol", objectType).type;
     InterfaceType typeType = _classElement("Type", objectType).type;
     CompilationUnitElementImpl coreUnit =
         new CompilationUnitElementImpl("core.dart");
     coreUnit.types = <ClassElement>[
       boolType.element,
       doubleType.element,
       functionType.element,
       intType.element,
       iterableType.element,
       listType.element,
       mapType.element,
       objectType.element,
       stackTraceType.element,
       stringType.element,
       symbolType.element,
       typeType.element
     ];
     CompilationUnitElementImpl asyncUnit =
         new CompilationUnitElementImpl("async.dart");
-    asyncUnit.types = <ClassElement>[futureType.element, futureOrType.element, streamType.element];
+    asyncUnit.types = <ClassElement>[
+      futureType.element,
+      futureOrType.element,
+      streamType.element
+    ];
     AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
     LibraryElementImpl coreLibrary = new LibraryElementImpl.forNode(
         context, AstTestFactory.libraryIdentifier2(["dart.core"]));
     coreLibrary.definingCompilationUnit = coreUnit;
     LibraryElementImpl asyncLibrary = new LibraryElementImpl.forNode(
         context, AstTestFactory.libraryIdentifier2(["dart.async"]));
     asyncLibrary.definingCompilationUnit = asyncUnit;
     //
     // Create a type provider and ensure that it can return the expected types.
     //
@@ skipping 37 matching lines @@
           typeParameter.type = typeArguments[i];
         }
         element.typeParameters = typeParameters;
       }
     }
     return element;
   }
 }
 
 @reflectiveTest
-class TypeResolverVisitorTest {
+class TypeResolverVisitorTest extends ParserTestCase {
   /**
    * The error listener to which errors will be reported.
    */
   GatheringErrorListener _listener;
 
   /**
    * The type provider used to access the types.
    */
   TestTypeProvider _typeProvider;
 
@@ skipping 40 matching lines @@
     element.definingCompilationUnit =
         new CompilationUnitElementImpl("lib.dart");
     _typeProvider = new TestTypeProvider();
     libraryScope = new LibraryScope(element);
     _visitor = new TypeResolverVisitor(
         element, librarySource, _typeProvider, _listener,
         nameScope: libraryScope);
   }
 
   test_modeApi() async {
-    CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
+    CompilationUnit unit = parseCompilationUnit(r'''
 class C extends A with A implements A {
   A f = new A();
   A m() {
     A v1;
   }
 }
 A f([A p = const A()]) {
   A v2;
 }
 A V = new A();
@@ skipping 973 matching lines @@
     node.accept(_visitor);
   }
 
   /**
    * Parse the given [code], build elements and resolve in the
    * [TypeResolverMode.local] mode. The [code] is allowed to use only the type
    * named `A`.
    */
   void _resolveTypeModeLocal(
       String code, AstNode getNodeToResolve(CompilationUnit unit)) {
-    CompilationUnit unit = ParserTestCase.parseCompilationUnit2(code);
+    CompilationUnit unit = parseCompilationUnit2(code);
     var unitElement = new CompilationUnitElementImpl('/test.dart');
 
     // Build API elements.
     {
       var holder = new ElementHolder();
       unit.accept(new ElementBuilder(holder, unitElement));
     }
 
     // Prepare for resolution.
     LibraryScope libraryScope;
@@ skipping 35 matching lines @@
  */
 class _StaleElement extends ElementImpl {
   _StaleElement() : super("_StaleElement", -1);
 
   @override
   get kind => throw "_StaleElement's kind shouldn't be accessed";
 
   @override
   /*=T*/ accept/*<T>*/(_) => throw "_StaleElement shouldn't be visited";
 }