Split parser tests that exercise class members to their own class.

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:analyzer/src/generated/parser.dart' as analyzer;
 import 'package:analyzer/src/generated/utilities_dart.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' as fasta;
+import 'package:front_end/src/fasta/scanner/precedence.dart' as fasta;
 import 'package:front_end/src/fasta/scanner/string_scanner.dart';
 import 'package:front_end/src/fasta/scanner/token.dart' as fasta;
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'parser_test.dart';
 
 main() {
   defineReflectiveSuite(() {
+    defineReflectiveTests(ClassMemberParserTest_Fasta);
     defineReflectiveTests(ComplexParserTest_Fasta);
     defineReflectiveTests(FormalParameterParserTest_Fasta);
     defineReflectiveTests(TopLevelParserTest_Fasta);
   });
 }
 
 /**
  * Type of the "parse..." methods defined in the Fasta parser.
  */
 typedef fasta.Token ParseFunction(fasta.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);
 }
 
+@reflectiveTest
+class ClassMemberParserTest_Fasta extends FastaParserTestCase
+    with ClassMemberParserTestMixin {
+  @override
+  @failingTest
+  void test_constFactory() {
+    // TODO(paulberry): Unhandled event: ConstructorReference
+    super.test_constFactory();
+  }
+
+  @override
+  @failingTest
+  void test_parseAwaitExpression_asStatement_inAsync() {
+    // TODO(paulberry): Add support for async
+    super.test_parseAwaitExpression_asStatement_inAsync();
+  }
+
+  @override
+  @failingTest
+  void test_parseAwaitExpression_asStatement_inSync() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseAwaitExpression_asStatement_inSync();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_constructor_withInitializers() {
+    // TODO(paulberry): 'this' can't be used here.
+    super.test_parseClassMember_constructor_withInitializers();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_field_covariant() {
+    // TODO(paulberry): Unhandled event: Fields
+    super.test_parseClassMember_field_covariant();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_field_instance_prefixedType() {
+    // TODO(paulberry): Unhandled event: Fields
+    super.test_parseClassMember_field_instance_prefixedType();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_field_namedGet() {
+    // TODO(paulberry): Unhandled event: Fields
+    super.test_parseClassMember_field_namedGet();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_field_namedOperator() {
+    // TODO(paulberry): Unhandled event: Fields
+    super.test_parseClassMember_field_namedOperator();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_field_namedOperator_withAssignment() {
+    // TODO(paulberry): Unhandled event: Fields
+    super.test_parseClassMember_field_namedOperator_withAssignment();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_field_namedSet() {
+    // TODO(paulberry): Unhandled event: Fields
+    super.test_parseClassMember_field_namedSet();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_field_static() {
+    // TODO(paulberry): Unhandled event: Fields
+    super.test_parseClassMember_field_static();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_getter_functionType() {
+    // TODO(paulberry): InputError: ErrorKind.ExpectedFunctionBody {actual: get}
+    super.test_parseClassMember_getter_functionType();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_getter_void() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseClassMember_getter_void();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_external() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseClassMember_method_external();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_external_withTypeAndArgs() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseClassMember_method_external_withTypeAndArgs();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_generic_comment_noReturnType() {
+    // TODO(paulberry): Fasta doesn't support generic comment syntax
+    super.test_parseClassMember_method_generic_comment_noReturnType();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_generic_comment_returnType() {
+    // TODO(paulberry): Fasta doesn't support generic comment syntax
+    super.test_parseClassMember_method_generic_comment_returnType();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_generic_comment_returnType_bound() {
+    // TODO(paulberry): Fasta doesn't support generic comment syntax
+    super.test_parseClassMember_method_generic_comment_returnType_bound();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_generic_comment_void() {
+    // TODO(paulberry): Fasta doesn't support generic comment syntax
+    super.test_parseClassMember_method_generic_comment_void();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_generic_noReturnType() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseClassMember_method_generic_noReturnType();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_generic_returnType() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseClassMember_method_generic_returnType();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_generic_void() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseClassMember_method_generic_void();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_get_noType() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseClassMember_method_get_noType();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_get_type() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseClassMember_method_get_type();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_get_void() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseClassMember_method_get_void();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_operator_noType() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseClassMember_method_operator_noType();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_operator_type() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseClassMember_method_operator_type();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_operator_void() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseClassMember_method_operator_void();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_returnType_functionType() {
+    // TODO(paulberry): InputError: ErrorKind.ExpectedFunctionBody {actual: m}
+    super.test_parseClassMember_method_returnType_functionType();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_returnType_parameterized() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseClassMember_method_returnType_parameterized();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_set_noType() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseClassMember_method_set_noType();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_set_type() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseClassMember_method_set_type();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_set_void() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseClassMember_method_set_void();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_method_trailing_commas() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseClassMember_method_trailing_commas();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_operator_functionType() {
+    // TODO(paulberry): InputError: ErrorKind.ExpectedFunctionBody {actual: operator}
+    super.test_parseClassMember_operator_functionType();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_operator_index() {
+    // TODO(paulberry): Unhandled event: OperatorName
+    super.test_parseClassMember_operator_index();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_operator_indexAssign() {
+    // TODO(paulberry): Unhandled event: OperatorName
+    super.test_parseClassMember_operator_indexAssign();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_redirectingFactory_const() {
+    // TODO(paulberry): Unhandled event: ConstructorReference
+    super.test_parseClassMember_redirectingFactory_const();
+  }
+
+  @override
+  @failingTest
+  void test_parseClassMember_redirectingFactory_nonConst() {
+    // TODO(paulberry): Unhandled event: ConstructorReference
+    super.test_parseClassMember_redirectingFactory_nonConst();
+  }
+
+  @override
+  @failingTest
+  void test_parseConstructor_assert() {
+    // TODO(paulberry): Fasta doesn't support asserts in initializers
+    super.test_parseConstructor_assert();
+  }
+
+  @override
+  @failingTest
+  void test_parseConstructor_with_pseudo_function_literal() {
+    // TODO(paulberry): Expected: an object with length of <1>
+    super.test_parseConstructor_with_pseudo_function_literal();
+  }
+
+  @override
+  @failingTest
+  void test_parseConstructorFieldInitializer_qualified() {
+    // TODO(paulberry): Unhandled event: ThisExpression
+    super.test_parseConstructorFieldInitializer_qualified();
+  }
+
+  @override
+  @failingTest
+  void test_parseConstructorFieldInitializer_unqualified() {
+    // TODO(paulberry): Expected: an object with length of <1>
+    super.test_parseConstructorFieldInitializer_unqualified();
+  }
+
+  @override
+  @failingTest
+  void test_parseGetter_nonStatic() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseGetter_nonStatic();
+  }
+
+  @override
+  @failingTest
+  void test_parseGetter_static() {
+    // TODO(paulberry): Invalid modifier (static). Report an error.
+    super.test_parseGetter_static();
+  }
+
+  @override
+  @failingTest
+  void test_parseInitializedIdentifierList_type() {
+    // TODO(paulberry): Unhandled event: Fields
+    super.test_parseInitializedIdentifierList_type();
+  }
+
+  @override
+  @failingTest
+  void test_parseInitializedIdentifierList_var() {
+    // TODO(paulberry): Unhandled event: Fields
+    super.test_parseInitializedIdentifierList_var();
+  }
+
+  @override
+  @failingTest
+  void test_parseOperator() {
+    // TODO(paulberry): Unhandled event: OperatorName
+    super.test_parseOperator();
+  }
+
+  @override
+  @failingTest
+  void test_parseSetter_nonStatic() {
+    // TODO(paulberry): Add support for method declarations
+    super.test_parseSetter_nonStatic();
+  }
+
+  @override
+  @failingTest
+  void test_parseSetter_static() {
+    // TODO(paulberry): Invalid modifier (static). Report an error.
+    super.test_parseSetter_static();
+  }
+}
+
 /**
  * Tests of the fasta parser based on [ComplexParserTestMixin].
  */
 @reflectiveTest
 class ComplexParserTest_Fasta extends FastaParserTestCase
     with ComplexParserTestMixin {
   @override
   @failingTest
   void test_additiveExpression_precedence_multiplicative_left_withSuper() {
     // TODO(paulberry,ahe): AstBuilder doesn't implement
@@ skipping 194 matching lines @@
 /**
  * Implementation of [AbstractParserTestCase] specialized for testing the
  * Fasta parser.
  */
 class FastaParserTestCase extends Object
     with ParserTestHelpers
     implements AbstractParserTestCase {
   ParserProxy _parserProxy;
 
   @override
+  set enableAssertInitializer(bool value) {
+    if (value == true) {
+      // TODO(paulberry,ahe): it looks like asserts in initializer lists are not
+      // supported by Fasta.
+      throw new UnimplementedError();
+    }
+  }
+
+  @override
   set enableGenericMethodComments(bool value) {
     if (value == true) {
       // TODO(paulberry,ahe): generic method comment syntax is not supported by
       // Fasta.
       throw new UnimplementedError();
     }
   }
 
   @override
   set enableNnbd(bool value) {
@@ skipping 501 matching lines @@
     var astBuilder = new AstBuilder(library, member, elementStore, scope);
     return new ParserProxy._(
         startingToken, new fasta.Parser(astBuilder), astBuilder);
   }
 
   ParserProxy._(this._currentFastaToken, this._fastaParser, this._astBuilder);
 
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
+  ClassMember parseClassMember(String className) {
+    _astBuilder.className = className;
+    var result = _run((parser) => parser.parseMember) as ClassMember;
+    _astBuilder.className = null;
+    return result;
+  }
+
+  @override
   CompilationUnit parseCompilationUnit2() {
     return _run((parser) => parser.parseUnit) as CompilationUnit;
   }
 
+  @override
+  ConstructorFieldInitializer parseConstructorFieldInitializer(bool hasThis) {
+    // Fasta's parser doesn't need the [hasThis] hint, so we ignore it.
+    var colon = new fasta.SymbolToken(fasta.COLON_INFO, 0);
+    colon.next = _currentFastaToken;
+    _currentFastaToken = colon;
+    var initializers = _run((parser) => parser.parseInitializers) as List;
+    return initializers[0] as ConstructorFieldInitializer;
+  }
+
   /**
    * Runs a single parser function, and returns the result as an analyzer AST.
    */
   Object _run(ParseFunction getParseFunction(fasta.Parser parser)) {
     var parseFunction = getParseFunction(_fastaParser);
     _currentFastaToken = parseFunction(_currentFastaToken);
     expect(_currentFastaToken.isEof, isTrue);
     expect(_astBuilder.stack, hasLength(1));
     return _astBuilder.pop();
   }
@@ skipping 284 matching lines @@
   void test_parseTypeAlias_genericFunction_typeParameters_voidReturnType() {
     super.test_parseTypeAlias_genericFunction_typeParameters_voidReturnType();
   }
 
   @override
   @failingTest
   void test_parseTypeAlias_genericFunction_voidReturnType() {
     super.test_parseTypeAlias_genericFunction_voidReturnType();
   }
 }