More parser fixes for generic function types

pkg/analyzer/test/generated/parser_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.parser_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/ast/visitor.dart';
@@ skipping 10022 matching lines @@
 
   void test_parseArgumentList_trailing_comma() {
     createParser('(x, y, z,)');
     ArgumentList argumentList = parser.parseArgumentList();
     expectNotNullIfNoErrors(argumentList);
     listener.assertNoErrors();
     NodeList<Expression> arguments = argumentList.arguments;
     expect(arguments, hasLength(3));
   }
 
+  void test_parseClassMember_field_gftType_noReturnType() {
+    createParser('''
+Function(int, String) v;
+''');
+    ClassMember member = parser.parseClassMember('C');
+    listener.assertNoErrors();
+    expect(member, new isInstanceOf<FieldDeclaration>());
+    VariableDeclarationList fields = (member as FieldDeclaration).fields;
+    expect(fields.type, new isInstanceOf<GenericFunctionType>());
+  }
+
   void test_parseClassMember_method_gftReturnType() {
     createParser('''
 void Function<A>(core.List<core.int> x) m() => null;
 ''');
     ClassMember member = parser.parseClassMember('C');
+    listener.assertNoErrors();
     expect(member, new isInstanceOf<MethodDeclaration>());
     expect((member as MethodDeclaration).body,
         new isInstanceOf<ExpressionFunctionBody>());
   }
 
   void test_parseClassMember_method_noReturnType() {
     createParser('''
 Function<A>(core.List<core.int> x) m() => null;
 ''');
     ClassMember member = parser.parseClassMember('C');
+    listener.assertNoErrors();
     expect(member, new isInstanceOf<MethodDeclaration>());
     expect((member as MethodDeclaration).body,
         new isInstanceOf<ExpressionFunctionBody>());
   }
 
   void test_parseCombinator_hide() {
     createParser('hide a;');
     Combinator combinator = parser.parseCombinator();
     expectNotNullIfNoErrors(combinator);
     listener.assertNoErrors();
@@ skipping 590 matching lines @@
     expect(reference, isNotNull);
     expect(reference.identifier, isNotNull);
     expect(reference.offset, 15);
   }
 
   void test_parseCompilationUnitMember_function_gftReturnType() {
     createParser('''
 void Function<A>(core.List<core.int> x) f() => null;
 ''');
     CompilationUnit unit = parser.parseCompilationUnit2();
+    listener.assertNoErrors();
     expect(unit, isNotNull);
     expect(unit.declarations, hasLength(1));
   }
 
   void test_parseCompilationUnitMember_function_noReturnType() {
     createParser('''
 Function<A>(core.List<core.int> x) f() => null;
 ''');
     CompilationUnit unit = parser.parseCompilationUnit2();
+    listener.assertNoErrors();
     expect(unit, isNotNull);
     expect(unit.declarations, hasLength(1));
   }
+
+  void test_parseCompilationUnitMember_variable_gftType_noReturnType() {
+    createParser('''
+Function(int, String) v;
+''');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    listener.assertNoErrors();
+    expect(unit, isNotNull);
+    expect(unit.declarations, hasLength(1));
+  }
 
   void test_parseConfiguration_noOperator_dottedIdentifier() {
     createParser("if (a.b) 'c.dart'");
     Configuration configuration = parser.parseConfiguration();
     expectNotNullIfNoErrors(configuration);
     listener.assertNoErrors();
     expect(configuration.ifKeyword, isNotNull);
     expect(configuration.leftParenthesis, isNotNull);
     expectDottedName(configuration.name, ["a", "b"]);
     expect(configuration.equalToken, isNull);
@@ skipping 581 matching lines @@
   }
 
   void test_parseModifiers_var() {
     createParser('var A');
     Modifiers modifiers = parser.parseModifiers();
     expectNotNullIfNoErrors(modifiers);
     listener.assertNoErrors();
     expect(modifiers.varKeyword, isNotNull);
   }
 
+  void test_parseNonLabeledStatement_localFunction_gftReturnType() {
+    createParser('int Function(int) f(String s) => null;');
+    Statement statement = parser.parseNonLabeledStatement();
+    expectNotNullIfNoErrors(statement);
+    listener.assertNoErrors();
+  }
+
   void test_parseNonLabeledStatement_variableDeclaration_final_namedFunction() {
     createParser('final int Function = 0;');
     Statement statement = parser.parseNonLabeledStatement();
     expectNotNullIfNoErrors(statement);
     listener.assertNoErrors();
   }
 
+  void test_parseNonLabeledStatement_variableDeclaration_gftType() {
+    createParser('int Function(int) v;');
+    Statement statement = parser.parseNonLabeledStatement();
+    expectNotNullIfNoErrors(statement);
+    listener.assertNoErrors();
+  }
+
+  void
+      test_parseNonLabeledStatement_variableDeclaration_gftType_noReturnType() {
+    createParser('Function(int) v;');
+    Statement statement = parser.parseNonLabeledStatement();
+    expectNotNullIfNoErrors(statement);
+    listener.assertNoErrors();
+  }
+
   void test_parseOptionalReturnType() {
     // TODO(brianwilkerson) Implement tests for this method.
   }
 
   void test_Parser() {
     expect(new Parser(null, null), isNotNull);
   }
 
   void test_parseReturnStatement_noValue() {
     createParser('return;');
@@ skipping 3518 matching lines @@
     expectCommentText(typeVariable.documentationComment, '/// Doc');
   }
 
   /**
    * Assert that the given [name] is in declaration context.
    */
   void _assertIsDeclarationName(SimpleIdentifier name) {
     expect(name.inDeclarationContext(), isTrue);
   }
 }