Make some parser test helper methods non-static.

pkg/analyzer/test/generated/parser_fasta_test.dart

 // Copyright (c) 2017, 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.
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:front_end/src/fasta/analyzer/ast_builder.dart';
 import 'package:front_end/src/fasta/analyzer/element_store.dart';
 import 'package:front_end/src/fasta/builder/scope.dart';
 import 'package:front_end/src/fasta/kernel/kernel_builder.dart';
 import 'package:front_end/src/fasta/kernel/kernel_library_builder.dart';
 import 'package:front_end/src/fasta/parser/parser.dart';
 import 'package:front_end/src/fasta/scanner/string_scanner.dart';
+import 'package:front_end/src/fasta/scanner/token.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'parser_test.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(ComplexParserTest_Fasta);
   });
 }
 
 /**
+ * Type of the "parse..." methods defined in the Fasta parser.
+ */
+typedef Token ParseFunction(Token token);
+
+/**
  * Proxy implementation of [Builder] used by Fasta parser tests.
  *
  * All undeclared identifiers are presumed to resolve via an instance of this
  * class.
  */
 class BuilderProxy implements Builder {
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
@@ skipping 99 matching lines @@
 
   @override
   @failingTest
   void test_conditionalExpression_precedence_nullableType_is() {
     // TODO(paulberry,ahe): Fasta doesn't support NNBD syntax yet.
     super.test_conditionalExpression_precedence_nullableType_is();
   }
 
   @override
   @failingTest
+  void test_constructor_initializer_withParenthesizedExpression() {
+    // TODO(paulberry): Implement parseCompilationUnitWithOptions
+    super.test_constructor_initializer_withParenthesizedExpression();
+  }
+
+  @override
+  @failingTest
   void test_equalityExpression_normal() {
     // TODO(paulberry,ahe): bad error recovery
     super.test_equalityExpression_normal();
   }
 
   @override
   @failingTest
   void test_equalityExpression_super() {
     // TODO(paulberry,ahe): AstBuilder doesn't implement
     // handleSuperExpression().
     super.test_equalityExpression_super();
   }
 
   @override
   @failingTest
   void test_logicalAndExpression_precedence_nullableType() {
     // TODO(paulberry,ahe): Fasta doesn't support NNBD syntax yet.
     super.test_logicalAndExpression_precedence_nullableType();
   }
 
   @override
   @failingTest
   void test_logicalOrExpression_precedence_nullableType() {
     // TODO(paulberry,ahe): Fasta doesn't support NNBD syntax yet.
     super.test_logicalOrExpression_precedence_nullableType();
   }
 
   @override
   @failingTest
+  void test_multipleLabels_statement() {
+    // TODO(paulberry,ahe): AstBuilder doesn't implement handleLabel().
+    super.test_multipleLabels_statement();
+  }
+
+  @override
+  @failingTest
   void test_multiplicativeExpression_super() {
     // TODO(paulberry,ahe): AstBuilder doesn't implement
     // handleSuperExpression().
     super.test_multiplicativeExpression_super();
   }
 
   @override
   @failingTest
   void test_shiftExpression_super() {
     // TODO(paulberry,ahe): AstBuilder doesn't implement
@@ skipping 55 matching lines @@
   @override
   set enableNnbd(bool value) {
     if (value == true) {
       // TODO(paulberry,ahe): non-null-by-default syntax is not supported by
       // Fasta.
       throw new UnimplementedError();
     }
   }
 
   @override
+  CompilationUnit parseCompilationUnit(String source,
+      [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
+    // TODO(paulberry): implement parseCompilationUnit
+    throw new UnimplementedError();
+  }
+
+  @override
   CompilationUnit parseCompilationUnitWithOptions(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
     // TODO(paulberry): implement parseCompilationUnitWithOptions
     throw new UnimplementedError();
   }
 
   @override
   Expression parseExpression(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
+    return _runParser(source, (parser) => parser.parseExpression, errorCodes);
+  }
+
+  @override
+  Statement parseStatement(String source,
+      [List<ErrorCode> errorCodes = const <ErrorCode>[],
+      bool enableLazyAssignmentOperators]) {
+    return _runParser(source, (parser) => parser.parseStatement, errorCodes);
+  }
+
+  Object _runParser(String source, ParseFunction getParseFuction(Parser parser),
+      [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
+    if (errorCodes.isNotEmpty) {
+      // TODO(paulberry): Check that the parser generates the proper errors.
+      throw new UnimplementedError();
+    }
     var scanner = new StringScanner(source);
     var token = scanner.tokenize();
     var library = new KernelLibraryBuilderProxy();
     var member = new BuilderProxy();
     var elementStore = new ElementStoreProxy();
     var scope = new ScopeProxy();
     var astBuilder = new AstBuilder(library, member, elementStore, scope);
     var parser = new Parser(astBuilder);
-    var endToken = parser.parseExpression(token);
+    var parseFunction = getParseFuction(parser);
+    var endToken = parseFunction(token);
     expect(endToken.isEof, isTrue);
     expect(astBuilder.stack, hasLength(1));
-    var expression = astBuilder.pop() as Expression;
-    return expression;
+    return astBuilder.pop();
   }
 }
 
 /**
  * Proxy implementation of [KernelClassElement] used by Fasta parser tests.
  *
  * Any element used as a type name is presumed to refer to an instance of this
  * class.
  */
 class InterfaceTypeProxy implements KernelInterfaceType {
@@ skipping 18 matching lines @@
  * [BuilderProxy].
  */
 class ScopeProxy implements Scope {
   final _locals = <String, Builder>{};
 
   Builder lookup(String name) =>
       _locals.putIfAbsent(name, () => new BuilderProxy());
 
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }