Make some parser test helper methods non-static.

pkg/analyzer/test/dart/element/builder_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.dart.element.builder_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 1012 matching lines @@
 }
 
 @reflectiveTest
 class LocalElementBuilderTest extends _BaseTest {
   @override
   AstVisitor createElementBuilder(ElementHolder holder) {
     return new LocalElementBuilder(holder, compilationUnitElement);
   }
 
   void test_buildLocalElements() {
-    CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
+    CompilationUnit unit = parseCompilationUnit(r'''
 main() {
   int v1;
   f1() {
     int v2;
     f2() {
       int v3;
     }
   }
 }
 ''');
@@ skipping 23 matching lines @@
       {
         FunctionElement f2 = f1.functions[0];
         expect(f2.name, 'f2');
         expect(f2.localVariables.map((v) => v.name), ['v3']);
         expect(f2.functions, isEmpty);
       }
     }
   }
 
   void test_buildParameterInitializer() {
-    CompilationUnit unit = ParserTestCase.parseCompilationUnit('f({p: 42}) {}');
+    CompilationUnit unit = parseCompilationUnit('f({p: 42}) {}');
     var function = unit.declarations.single as FunctionDeclaration;
     var parameter = function.functionExpression.parameters.parameters.single
         as DefaultFormalParameter;
     // Build API elements.
     {
       ElementHolder holder = new ElementHolder();
       unit.accept(new ApiElementBuilder(holder, compilationUnitElement));
     }
     // Validate the parameter element.
     var parameterElement = parameter.element as ParameterElementImpl;
     expect(parameterElement, isNotNull);
     expect(parameterElement.initializer, isNull);
     // Build the initializer element.
     new LocalElementBuilder(new ElementHolder(), compilationUnitElement)
         .buildParameterInitializer(parameterElement, parameter.defaultValue);
     expect(parameterElement.initializer, isNotNull);
   }
 
   void test_buildVariableInitializer() {
-    CompilationUnit unit = ParserTestCase.parseCompilationUnit('var V = 42;');
+    CompilationUnit unit = parseCompilationUnit('var V = 42;');
     TopLevelVariableDeclaration topLevelDecl =
         unit.declarations[0] as TopLevelVariableDeclaration;
     VariableDeclaration variable = topLevelDecl.variables.variables.single;
     // Build the variable element.
     {
       ElementHolder holder = new ElementHolder();
       unit.accept(new ApiElementBuilder(holder, compilationUnitElement));
     }
     // Validate the variable element.
     var variableElement = variable.element as VariableElementImpl;
     expect(variableElement, isNotNull);
     expect(variableElement.initializer, isNull);
     // Build the initializer element.
     new LocalElementBuilder(new ElementHolder(), compilationUnitElement)
         .buildVariableInitializer(variableElement, variable.initializer);
     expect(variableElement.initializer, isNotNull);
   }
 
   void test_visitDefaultFormalParameter_local() {
-    CompilationUnit unit = ParserTestCase.parseCompilationUnit('''
+    CompilationUnit unit = parseCompilationUnit('''
 main() {
   f({bool b: false}) {}
 }
 ''');
     var mainAst = unit.declarations.single as FunctionDeclaration;
     // Build API elements.
     FunctionElementImpl main;
     {
       ElementHolder holder = new ElementHolder();
       unit.accept(new ApiElementBuilder(holder, compilationUnitElement));
@@ skipping 1403 matching lines @@
     expect(typeParameters, hasLength(1));
     TypeParameterElement typeParameterElement = typeParameters[0];
     expect(typeParameterElement, isNotNull);
     assertHasCodeRange(typeParameterElement, 50, 1);
     expect(typeParameterElement.name, parameterName);
     expect(typeParameterElement.bound, isNull);
     expect(typeParameterElement.isSynthetic, isFalse);
   }
 }
 
-abstract class _BaseTest {
+abstract class _BaseTest extends ParserTestCase {
   CompilationUnitElement compilationUnitElement;
   CompilationUnit _compilationUnit;
 
   CompilationUnit get compilationUnit => _compilationUnit;
 
   void assertHasCodeRange(Element element, int offset, int length) {
     ElementImpl elementImpl = element;
     expect(elementImpl.codeOffset, offset);
     expect(elementImpl.codeLength, length);
   }
@@ skipping 60 matching lines @@
   }
 
   /**
    * Parse the given [code], and visit it with the given [visitor].
    * Fail if any error is logged.
    */
   void _visitAstOfCode(String code, AstVisitor visitor) {
     TestLogger logger = new TestLogger();
     AnalysisEngine.instance.logger = logger;
     try {
-      _compilationUnit = ParserTestCase.parseCompilationUnit(code);
+      _compilationUnit = parseCompilationUnit(code);
       compilationUnit.accept(visitor);
     } finally {
       expect(logger.log, hasLength(0));
       AnalysisEngine.instance.logger = Logger.NULL;
     }
   }
 }