Add parsing support for generic methods

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 engine.parser_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
@@ skipping 155 matching lines @@
   void test_assignableExpression_arguments_normal_chain() {
     PropertyAccess propertyAccess1 = parseExpression("a(b)(c).d(e).f");
     expect(propertyAccess1.propertyName.name, "f");
     //
     // a(b)(c).d(e)
     //
     MethodInvocation invocation2 = EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodInvocation, MethodInvocation,
         propertyAccess1.target);
     expect(invocation2.methodName.name, "d");
+    expect(invocation2.typeArguments, isNull);
     ArgumentList argumentList2 = invocation2.argumentList;
     expect(argumentList2, isNotNull);
     expect(argumentList2.arguments, hasLength(1));
     //
     // a(b)(c)
     //
     FunctionExpressionInvocation invocation3 = EngineTestCase.assertInstanceOf(
         (obj) => obj is FunctionExpressionInvocation,
         FunctionExpressionInvocation, invocation2.target);
+    expect(invocation3.typeArguments, isNull);
     ArgumentList argumentList3 = invocation3.argumentList;
     expect(argumentList3, isNotNull);
     expect(argumentList3.arguments, hasLength(1));
     //
     // a(b)
     //
     MethodInvocation invocation4 = EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodInvocation, MethodInvocation,
         invocation3.function);
     expect(invocation4.methodName.name, "a");
+    expect(invocation4.typeArguments, isNull);
     ArgumentList argumentList4 = invocation4.argumentList;
     expect(argumentList4, isNotNull);
     expect(argumentList4.arguments, hasLength(1));
+  }
+
+  void test_assignableExpression_arguments_normal_chain_typeArguments() {
+    enableGenericMethods = true;
+    PropertyAccess propertyAccess1 = parseExpression("a<E>(b)<F>(c).d<G>(e).f");
+    expect(propertyAccess1.propertyName.name, "f");
+    //
+    // a<E>(b)<F>(c).d>G?(e)
+    //
+    MethodInvocation invocation2 = EngineTestCase.assertInstanceOf(
+        (obj) => obj is MethodInvocation, MethodInvocation,
+        propertyAccess1.target);
+    expect(invocation2.methodName.name, "d");
+    expect(invocation2.typeArguments, isNotNull);
+    ArgumentList argumentList2 = invocation2.argumentList;
+    expect(argumentList2, isNotNull);
+    expect(argumentList2.arguments, hasLength(1));
+    //
+    // a<E>(b)<F>(c)
+    //
+    FunctionExpressionInvocation invocation3 = EngineTestCase.assertInstanceOf(
+        (obj) => obj is FunctionExpressionInvocation,
+        FunctionExpressionInvocation, invocation2.target);
+    expect(invocation3.typeArguments, isNotNull);
+    ArgumentList argumentList3 = invocation3.argumentList;
+    expect(argumentList3, isNotNull);
+    expect(argumentList3.arguments, hasLength(1));
+    //
+    // a(b)
+    //
+    MethodInvocation invocation4 = EngineTestCase.assertInstanceOf(
+        (obj) => obj is MethodInvocation, MethodInvocation,
+        invocation3.function);
+    expect(invocation4.methodName.name, "a");
+    expect(invocation4.typeArguments, isNotNull);
+    ArgumentList argumentList4 = invocation4.argumentList;
+    expect(argumentList4, isNotNull);
+    expect(argumentList4.arguments, hasLength(1));
   }
 
   void test_assignmentExpression_compound() {
     AssignmentExpression expression = parseExpression("x = y = 0");
     EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
         SimpleIdentifier, expression.leftHandSide);
     EngineTestCase.assertInstanceOf((obj) => obj is AssignmentExpression,
         AssignmentExpression, expression.rightHandSide);
   }
 
@@ skipping 1535 matching lines @@
   void test_optionalAfterNormalParameters_positional() {
     ParserTestCase.parseCompilationUnit(
         "f([a], b) {}", [ParserErrorCode.NORMAL_BEFORE_OPTIONAL_PARAMETERS]);
   }
 
   void test_parseCascadeSection_missingIdentifier() {
     MethodInvocation methodInvocation = parse4(
         "parseCascadeSection", "..()", [ParserErrorCode.MISSING_IDENTIFIER]);
     expect(methodInvocation.target, isNull);
     expect(methodInvocation.methodName.name, "");
+    expect(methodInvocation.typeArguments, isNull);
     expect(methodInvocation.argumentList.arguments, hasLength(0));
   }
 
+  void test_parseCascadeSection_missingIdentifier_typeArguments() {
+    enableGenericMethods = true;
+    MethodInvocation methodInvocation = parse4(
+        "parseCascadeSection", "..<E>()", [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(methodInvocation.target, isNull);
+    expect(methodInvocation.methodName.name, "");
+    expect(methodInvocation.typeArguments, isNotNull);
+    expect(methodInvocation.argumentList.arguments, hasLength(0));
+  }
+
   void test_positionalAfterNamedArgument() {
     parse4("parseArgumentList", "(x: 1, 2)",
         [ParserErrorCode.POSITIONAL_AFTER_NAMED_ARGUMENT]);
   }
 
   void test_positionalParameterOutsideGroup() {
     parse4("parseFormalParameterList", "(a, b = 0)",
         [ParserErrorCode.POSITIONAL_PARAMETER_OUTSIDE_GROUP]);
   }
 
@@ skipping 755 matching lines @@
    * An empty list of objects used as arguments to zero-argument methods.
    */
   static const List<Object> _EMPTY_ARGUMENTS = const <Object>[];
 
   /**
    * A flag indicating whether parser is to parse function bodies.
    */
   static bool parseFunctionBodies = true;
 
   /**
+   * A flag indicating whether generic method support should be enabled for a
+   * specific test.
+   */
+  bool enableGenericMethods = false;
+
+  /**
    * If non-null, this value is used to override the default value of
    * [Scanner.enableNullAwareOperators] before scanning.
    */
   bool _enableNullAwareOperators;
 
   /**
    * Return a CommentAndMetadata object with the given values that can be used for testing.
    *
    * @param comment the comment to be wrapped in the object
    * @param annotations the annotations to be wrapped in the object
@@ skipping 37 matching lines @@
         new Scanner(null, new CharSequenceReader(source), listener);
     if (_enableNullAwareOperators != null) {
       scanner.enableNullAwareOperators = _enableNullAwareOperators;
     }
     Token tokenStream = scanner.tokenize();
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     //
     // Parse the source.
     //
     Parser parser = createParser(listener);
+    parser.parseGenericMethods = enableGenericMethods;
     parser.parseFunctionBodies = parseFunctionBodies;
     Object result =
         invokeParserMethodImpl(parser, methodName, objects, tokenStream);
     //
     // Partially test the results.
     //
     if (!listener.hasErrors) {
       expect(result, isNotNull);
     }
     return result;
@@ skipping 113 matching lines @@
       [List<ErrorCode> errorCodes = ErrorCode.EMPTY_LIST]) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scanner scanner =
         new Scanner(null, new CharSequenceReader(source), listener);
     if (_enableNullAwareOperators != null) {
       scanner.enableNullAwareOperators = _enableNullAwareOperators;
     }
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
     Parser parser = createParser(listener);
+    parser.parseGenericMethods = enableGenericMethods;
     Expression expression = parser.parseExpression(token);
     expect(expression, isNotNull);
     listener.assertErrorsWithCodes(errorCodes);
     return expression;
   }
 
   @override
   void setUp() {
     super.setUp();
     parseFunctionBodies = true;
@@ skipping 1916 matching lines @@
   }
 
   void test_isFunctionDeclaration_nameButNoReturn_block() {
     expect(_isFunctionDeclaration("f() {}"), isTrue);
   }
 
   void test_isFunctionDeclaration_nameButNoReturn_expression() {
     expect(_isFunctionDeclaration("f() => e"), isTrue);
   }
 
+  void test_isFunctionDeclaration_nameButNoReturn_typeParameters_block() {
+    enableGenericMethods = true;
+    expect(_isFunctionDeclaration("f<E>() {}"), isTrue);
+  }
+
+  void test_isFunctionDeclaration_nameButNoReturn_typeParameters_expression() {
+    enableGenericMethods = true;
+    expect(_isFunctionDeclaration("f<E>() => e"), isTrue);
+  }
+
   void test_isFunctionDeclaration_normalReturn_block() {
     expect(_isFunctionDeclaration("C f() {}"), isTrue);
   }
 
   void test_isFunctionDeclaration_normalReturn_expression() {
     expect(_isFunctionDeclaration("C f() => e"), isTrue);
   }
 
+  void test_isFunctionDeclaration_normalReturn_typeParameters_block() {
+    enableGenericMethods = true;
+    expect(_isFunctionDeclaration("C f<E>() {}"), isTrue);
+  }
+
+  void test_isFunctionDeclaration_normalReturn_typeParameters_expression() {
+    enableGenericMethods = true;
+    expect(_isFunctionDeclaration("C f<E>() => e"), isTrue);
+  }
+
   void test_isFunctionDeclaration_voidReturn_block() {
     expect(_isFunctionDeclaration("void f() {}"), isTrue);
   }
 
   void test_isFunctionDeclaration_voidReturn_expression() {
     expect(_isFunctionDeclaration("void f() => e"), isTrue);
   }
 
+  void test_isFunctionDeclaration_voidReturn_typeParameters_block() {
+    enableGenericMethods = true;
+    expect(_isFunctionDeclaration("void f<E>() {}"), isTrue);
+  }
+
+  void test_isFunctionDeclaration_voidReturn_typeParameters_expression() {
+    enableGenericMethods = true;
+    expect(_isFunctionDeclaration("void f<E>() => e"), isTrue);
+  }
+
   void test_isFunctionExpression_false_noBody() {
     expect(_isFunctionExpression("f();"), isFalse);
   }
 
   void test_isFunctionExpression_false_notParameters() {
     expect(_isFunctionExpression("(a + b) {"), isFalse);
   }
 
-  void test_isFunctionExpression_noName_block() {
+  void test_isFunctionExpression_noParameters_block() {
     expect(_isFunctionExpression("() {}"), isTrue);
   }
 
-  void test_isFunctionExpression_noName_expression() {
+  void test_isFunctionExpression_noParameters_expression() {
     expect(_isFunctionExpression("() => e"), isTrue);
   }
 
+  void test_isFunctionExpression_noParameters_typeParameters_block() {
+    enableGenericMethods = true;
+    expect(_isFunctionExpression("<E>() {}"), isTrue);
+  }
+
+  void test_isFunctionExpression_noParameters_typeParameters_expression() {
+    enableGenericMethods = true;
+    expect(_isFunctionExpression("<E>() => e"), isTrue);
+  }
+
   void test_isFunctionExpression_parameter_final() {
     expect(_isFunctionExpression("(final a) {}"), isTrue);
     expect(_isFunctionExpression("(final a, b) {}"), isTrue);
     expect(_isFunctionExpression("(final a, final b) {}"), isTrue);
   }
 
   void test_isFunctionExpression_parameter_final_typed() {
     expect(_isFunctionExpression("(final int a) {}"), isTrue);
     expect(_isFunctionExpression("(final prefix.List a) {}"), isTrue);
     expect(_isFunctionExpression("(final List<int> a) {}"), isTrue);
@@ skipping 229 matching lines @@
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.semicolon, isNotNull);
   }
 
   void test_parseAssignableExpression_expression_args_dot() {
     PropertyAccess propertyAccess =
         parse("parseAssignableExpression", <Object>[false], "(x)(y).z");
     FunctionExpressionInvocation invocation =
         propertyAccess.target as FunctionExpressionInvocation;
     expect(invocation.function, isNotNull);
+    expect(invocation.typeArguments, isNull);
     ArgumentList argumentList = invocation.argumentList;
     expect(argumentList, isNotNull);
     expect(argumentList.arguments, hasLength(1));
+    expect(propertyAccess.operator, isNotNull);
+    expect(propertyAccess.propertyName, isNotNull);
+  }
+
+  void test_parseAssignableExpression_expression_args_dot_typeParameters() {
+    enableGenericMethods = true;
+    PropertyAccess propertyAccess =
+        parse("parseAssignableExpression", <Object>[false], "(x)<F>(y).z");
+    FunctionExpressionInvocation invocation =
+        propertyAccess.target as FunctionExpressionInvocation;
+    expect(invocation.function, isNotNull);
+    expect(invocation.typeArguments, isNotNull);
+    ArgumentList argumentList = invocation.argumentList;
+    expect(argumentList, isNotNull);
+    expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableExpression_expression_dot() {
     PropertyAccess propertyAccess =
         parse("parseAssignableExpression", <Object>[false], "(x).y");
     expect(propertyAccess.target, isNotNull);
     expect(propertyAccess.operator.type, TokenType.PERIOD);
     expect(propertyAccess.propertyName, isNotNull);
@@ skipping 21 matching lines @@
     SimpleIdentifier identifier =
         parse("parseAssignableExpression", <Object>[false], "x");
     expect(identifier, isNotNull);
   }
 
   void test_parseAssignableExpression_identifier_args_dot() {
     PropertyAccess propertyAccess =
         parse("parseAssignableExpression", <Object>[false], "x(y).z");
     MethodInvocation invocation = propertyAccess.target as MethodInvocation;
     expect(invocation.methodName.name, "x");
+    expect(invocation.typeArguments, isNull);
     ArgumentList argumentList = invocation.argumentList;
     expect(argumentList, isNotNull);
     expect(argumentList.arguments, hasLength(1));
+    expect(propertyAccess.operator, isNotNull);
+    expect(propertyAccess.propertyName, isNotNull);
+  }
+
+  void test_parseAssignableExpression_identifier_args_dot_typeParameters() {
+    enableGenericMethods = true;
+    PropertyAccess propertyAccess =
+        parse("parseAssignableExpression", <Object>[false], "x<E>(y).z");
+    MethodInvocation invocation = propertyAccess.target as MethodInvocation;
+    expect(invocation.methodName.name, "x");
+    expect(invocation.typeArguments, isNotNull);
+    ArgumentList argumentList = invocation.argumentList;
+    expect(argumentList, isNotNull);
+    expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableExpression_identifier_dot() {
     PropertyAccess propertyAccess =
         parse("parseAssignableExpression", <Object>[false], "x.y");
     expect(propertyAccess.target, isNotNull);
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.operator.type, TokenType.PERIOD);
@@ skipping 191 matching lines @@
     expect(section.leftBracket, isNotNull);
     expect(section.index, isNotNull);
     expect(section.rightBracket, isNotNull);
   }
 
   void test_parseCascadeSection_ia() {
     FunctionExpressionInvocation section =
         parse4("parseCascadeSection", "..[i](b)");
     EngineTestCase.assertInstanceOf(
         (obj) => obj is IndexExpression, IndexExpression, section.function);
+    expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
   }
 
+  void test_parseCascadeSection_ia_typeArguments() {
+    enableGenericMethods = true;
+    FunctionExpressionInvocation section =
+        parse4("parseCascadeSection", "..[i]<E>(b)");
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is IndexExpression, IndexExpression, section.function);
+    expect(section.typeArguments, isNotNull);
+    expect(section.argumentList, isNotNull);
+  }
+
   void test_parseCascadeSection_ii() {
     MethodInvocation section = parse4("parseCascadeSection", "..a(b).c(d)");
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodInvocation, MethodInvocation, section.target);
     expect(section.operator, isNotNull);
     expect(section.methodName, isNotNull);
+    expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
+
+  void test_parseCascadeSection_ii_typeArguments() {
+    enableGenericMethods = true;
+    MethodInvocation section =
+        parse4("parseCascadeSection", "..a<E>(b).c<F>(d)");
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is MethodInvocation, MethodInvocation, section.target);
+    expect(section.operator, isNotNull);
+    expect(section.methodName, isNotNull);
+    expect(section.typeArguments, isNotNull);
+    expect(section.argumentList, isNotNull);
+    expect(section.argumentList.arguments, hasLength(1));
+  }
 
   void test_parseCascadeSection_p() {
     PropertyAccess section = parse4("parseCascadeSection", "..a");
     expect(section.target, isNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
   void test_parseCascadeSection_p_assign() {
     AssignmentExpression section = parse4("parseCascadeSection", "..a = 3");
     expect(section.leftHandSide, isNotNull);
     expect(section.operator, isNotNull);
     Expression rhs = section.rightHandSide;
     expect(rhs, isNotNull);
   }
 
   void test_parseCascadeSection_p_assign_withCascade() {
     AssignmentExpression section =
         parse4("parseCascadeSection", "..a = 3..m()");
     expect(section.leftHandSide, isNotNull);
     expect(section.operator, isNotNull);
     Expression rhs = section.rightHandSide;
     EngineTestCase.assertInstanceOf(
         (obj) => obj is IntegerLiteral, IntegerLiteral, rhs);
   }
 
+  void test_parseCascadeSection_p_assign_withCascade_typeArguments() {
+    enableGenericMethods = true;
+    AssignmentExpression section =
+        parse4("parseCascadeSection", "..a = 3..m<E>()");
+    expect(section.leftHandSide, isNotNull);
+    expect(section.operator, isNotNull);
+    Expression rhs = section.rightHandSide;
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is IntegerLiteral, IntegerLiteral, rhs);
+  }
+
   void test_parseCascadeSection_p_builtIn() {
     PropertyAccess section = parse4("parseCascadeSection", "..as");
     expect(section.target, isNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
   void test_parseCascadeSection_pa() {
     MethodInvocation section = parse4("parseCascadeSection", "..a(b)");
     expect(section.target, isNull);
     expect(section.operator, isNotNull);
     expect(section.methodName, isNotNull);
+    expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
+
+  void test_parseCascadeSection_pa_typeArguments() {
+    enableGenericMethods = true;
+    MethodInvocation section = parse4("parseCascadeSection", "..a<E>(b)");
+    expect(section.target, isNull);
+    expect(section.operator, isNotNull);
+    expect(section.methodName, isNotNull);
+    expect(section.typeArguments, isNotNull);
+    expect(section.argumentList, isNotNull);
+    expect(section.argumentList.arguments, hasLength(1));
+  }
 
   void test_parseCascadeSection_paa() {
     FunctionExpressionInvocation section =
         parse4("parseCascadeSection", "..a(b)(c)");
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodInvocation, MethodInvocation, section.function);
+    expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
+
+  void test_parseCascadeSection_paa_typeArguments() {
+    enableGenericMethods = true;
+    FunctionExpressionInvocation section =
+        parse4("parseCascadeSection", "..a<E>(b)<F>(c)");
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is MethodInvocation, MethodInvocation, section.function);
+    expect(section.typeArguments, isNotNull);
+    expect(section.argumentList, isNotNull);
+    expect(section.argumentList.arguments, hasLength(1));
+  }
 
   void test_parseCascadeSection_paapaa() {
     FunctionExpressionInvocation section =
         parse4("parseCascadeSection", "..a(b)(c).d(e)(f)");
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodInvocation, MethodInvocation, section.function);
+    expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
+
+  void test_parseCascadeSection_paapaa_typeArguments() {
+    enableGenericMethods = true;
+    FunctionExpressionInvocation section =
+        parse4("parseCascadeSection", "..a<E>(b)<F>(c).d<G>(e)<H>(f)");
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is MethodInvocation, MethodInvocation, section.function);
+    expect(section.typeArguments, isNotNull);
+    expect(section.argumentList, isNotNull);
+    expect(section.argumentList.arguments, hasLength(1));
+  }
 
   void test_parseCascadeSection_pap() {
     PropertyAccess section = parse4("parseCascadeSection", "..a(b).c");
     expect(section.target, isNotNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
+  void test_parseCascadeSection_pap_typeArguments() {
+    enableGenericMethods = true;
+    PropertyAccess section = parse4("parseCascadeSection", "..a<E>(b).c");
+    expect(section.target, isNotNull);
+    expect(section.operator, isNotNull);
+    expect(section.propertyName, isNotNull);
+  }
+
   void test_parseClassDeclaration_abstract() {
     ClassDeclaration declaration = parse("parseClassDeclaration", <Object>[
       emptyCommentAndMetadata(),
       TokenFactory.tokenFromKeyword(Keyword.ABSTRACT)
     ], "class A {}");
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNotNull);
     expect(declaration.extendsClause, isNull);
     expect(declaration.implementsClause, isNull);
     expect(declaration.classKeyword, isNotNull);
@@ skipping 289 matching lines @@
 
   void test_parseClassMember_method_external() {
     MethodDeclaration method =
         parse("parseClassMember", <Object>["C"], "external m();");
     expect(method.body, isNotNull);
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNotNull);
     expect(method.modifierKeyword, isNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNull);
   }
 
   void test_parseClassMember_method_external_withTypeAndArgs() {
     MethodDeclaration method =
         parse("parseClassMember", <Object>["C"], "external int m(int a);");
     expect(method.body, isNotNull);
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNotNull);
     expect(method.modifierKeyword, isNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNotNull);
   }
 
+  void test_parseClassMember_method_generic_noReturnType() {
+    enableGenericMethods = true;
+    MethodDeclaration method =
+        parse("parseClassMember", <Object>["C"], "m<T>() {}");
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNotNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_generic_returnType() {
+    enableGenericMethods = true;
+    MethodDeclaration method =
+        parse("parseClassMember", <Object>["C"], "T m<T>() {}");
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNotNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_generic_void() {
+    enableGenericMethods = true;
+    MethodDeclaration method =
+        parse("parseClassMember", <Object>["C"], "void m<T>() {}");
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNotNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
   void test_parseClassMember_method_get_noType() {
     MethodDeclaration method =
         parse("parseClassMember", <Object>["C"], "get() {}");
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
 
   void test_parseClassMember_method_get_type() {
     MethodDeclaration method =
         parse("parseClassMember", <Object>["C"], "int get() {}");
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNotNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
 
   void test_parseClassMember_method_get_void() {
     MethodDeclaration method =
         parse("parseClassMember", <Object>["C"], "void get() {}");
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNotNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
 
   void test_parseClassMember_method_operator_noType() {
     MethodDeclaration method =
         parse("parseClassMember", <Object>["C"], "operator() {}");
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
 
   void test_parseClassMember_method_operator_type() {
     MethodDeclaration method =
         parse("parseClassMember", <Object>["C"], "int operator() {}");
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNotNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
 
   void test_parseClassMember_method_operator_void() {
     MethodDeclaration method =
         parse("parseClassMember", <Object>["C"], "void operator() {}");
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNotNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
 
   void test_parseClassMember_method_returnType_parameterized() {
     MethodDeclaration method =
         parse("parseClassMember", <Object>["C"], "p.A m() {}");
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNotNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
 
   void test_parseClassMember_method_set_noType() {
     MethodDeclaration method =
         parse("parseClassMember", <Object>["C"], "set() {}");
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
 
   void test_parseClassMember_method_set_type() {
     MethodDeclaration method =
         parse("parseClassMember", <Object>["C"], "int set() {}");
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNotNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
 
   void test_parseClassMember_method_set_void() {
     MethodDeclaration method =
         parse("parseClassMember", <Object>["C"], "void set() {}");
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNotNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
 
   void test_parseClassMember_operator_index() {
     MethodDeclaration method =
         parse("parseClassMember", <Object>["C"], "int operator [](int i) {}");
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNotNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNotNull);
+    expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
 
   void test_parseClassMember_operator_indexAssign() {
     MethodDeclaration method =
         parse("parseClassMember", <Object>["C"], "int operator []=(int i) {}");
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNotNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNotNull);
+    expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
 
   void test_parseClassMember_redirectingFactory_const() {
     ConstructorDeclaration constructor =
         parse("parseClassMember", <Object>["C"], "const factory C() = B;");
     expect(constructor.externalKeyword, isNull);
     expect(constructor.constKeyword, isNotNull);
     expect(constructor.factoryKeyword, isNotNull);
@@ skipping 1194 matching lines @@
   }
 
   void test_parseExpression_invokeFunctionExpression() {
     FunctionExpressionInvocation invocation =
         parse4("parseExpression", "(a) {return a + a;} (3)");
     EngineTestCase.assertInstanceOf((obj) => obj is FunctionExpression,
         FunctionExpression, invocation.function);
     FunctionExpression expression = invocation.function as FunctionExpression;
     expect(expression.parameters, isNotNull);
     expect(expression.body, isNotNull);
+    expect(invocation.typeArguments, isNull);
     ArgumentList list = invocation.argumentList;
     expect(list, isNotNull);
     expect(list.arguments, hasLength(1));
   }
 
   void test_parseExpression_nonAwait() {
     MethodInvocation expression = parseExpression("await()");
     expect(expression.methodName.name, 'await');
+    expect(expression.typeArguments, isNull);
+    expect(expression.argumentList, isNotNull);
   }
 
   void test_parseExpression_superMethodInvocation() {
     MethodInvocation invocation = parse4("parseExpression", "super.m()");
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
+    expect(invocation.typeArguments, isNull);
     expect(invocation.argumentList, isNotNull);
   }
 
+  void test_parseExpression_superMethodInvocation_typeArguments() {
+    enableGenericMethods = true;
+    MethodInvocation invocation = parse4("parseExpression", "super.m<E>()");
+    expect(invocation.target, isNotNull);
+    expect(invocation.methodName, isNotNull);
+    expect(invocation.typeArguments, isNotNull);
+    expect(invocation.argumentList, isNotNull);
+  }
+
   void test_parseExpressionList_multiple() {
     List<Expression> result = parse4("parseExpressionList", "1, 2, 3");
     expect(result, hasLength(3));
   }
 
   void test_parseExpressionList_single() {
     List<Expression> result = parse4("parseExpressionList", "1");
     expect(result, hasLength(1));
   }
 
@@ skipping 14 matching lines @@
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.EQ_EQ);
     expect(expression.rightOperand, isNotNull);
   }
 
   void test_parseExpressionWithoutCascade_superMethodInvocation() {
     MethodInvocation invocation =
         parse4("parseExpressionWithoutCascade", "super.m()");
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
+    expect(invocation.typeArguments, isNull);
     expect(invocation.argumentList, isNotNull);
   }
 
+  void test_parseExpressionWithoutCascade_superMethodInvocation_typeArguments() {
+    enableGenericMethods = true;
+    MethodInvocation invocation =
+        parse4("parseExpressionWithoutCascade", "super.m<E>()");
+    expect(invocation.target, isNotNull);
+    expect(invocation.methodName, isNotNull);
+    expect(invocation.typeArguments, isNotNull);
+    expect(invocation.argumentList, isNotNull);
+  }
+
   void test_parseExtendsClause() {
     ExtendsClause clause = parse4("parseExtendsClause", "extends B");
     expect(clause.extendsKeyword, isNotNull);
     expect(clause.superclass, isNotNull);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is TypeName, TypeName, clause.superclass);
   }
 
   void test_parseFinalConstVarOrType_const_noType() {
     FinalConstVarOrType result =
@@ skipping 713 matching lines @@
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     TypeName returnType = new TypeName(new SimpleIdentifier(null), null);
     FunctionDeclaration declaration = parse("parseFunctionDeclaration",
         <Object>[commentAndMetadata(comment), null, returnType], "f() {}");
     expect(declaration.documentationComment, comment);
     expect(declaration.returnType, returnType);
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
     expect(expression.body, isNotNull);
+    expect(expression.typeParameters, isNull);
     expect(expression.parameters, isNotNull);
     expect(declaration.propertyKeyword, isNull);
   }
+
+  void test_parseFunctionDeclaration_functionWithTypeParameters() {
+    enableGenericMethods = true;
+    Comment comment = Comment.createDocumentationComment(new List<Token>(0));
+    TypeName returnType = new TypeName(new SimpleIdentifier(null), null);
+    FunctionDeclaration declaration = parse("parseFunctionDeclaration",
+        <Object>[commentAndMetadata(comment), null, returnType], "f<E>() {}");
+    expect(declaration.documentationComment, comment);
+    expect(declaration.returnType, returnType);
+    expect(declaration.name, isNotNull);
+    FunctionExpression expression = declaration.functionExpression;
+    expect(expression, isNotNull);
+    expect(expression.body, isNotNull);
+    expect(expression.typeParameters, isNotNull);
+    expect(expression.parameters, isNotNull);
+    expect(declaration.propertyKeyword, isNull);
+  }
 
   void test_parseFunctionDeclaration_getter() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     TypeName returnType = new TypeName(new SimpleIdentifier(null), null);
     FunctionDeclaration declaration = parse("parseFunctionDeclaration",
         <Object>[commentAndMetadata(comment), null, returnType], "get p => 0;");
     expect(declaration.documentationComment, comment);
     expect(declaration.returnType, returnType);
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
     expect(expression.body, isNotNull);
+    expect(expression.typeParameters, isNull);
     expect(expression.parameters, isNull);
     expect(declaration.propertyKeyword, isNotNull);
   }
 
   void test_parseFunctionDeclaration_setter() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     TypeName returnType = new TypeName(new SimpleIdentifier(null), null);
     FunctionDeclaration declaration = parse("parseFunctionDeclaration",
         <Object>[commentAndMetadata(comment), null, returnType], "set p(v) {}");
     expect(declaration.documentationComment, comment);
     expect(declaration.returnType, returnType);
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
     expect(expression.body, isNotNull);
+    expect(expression.typeParameters, isNull);
     expect(expression.parameters, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
   }
 
   void test_parseFunctionDeclarationStatement() {
     FunctionDeclarationStatement statement =
         parse4("parseFunctionDeclarationStatement", "void f(int p) => p * 2;");
     expect(statement.functionDeclaration, isNotNull);
   }
 
+  void test_parseFunctionDeclarationStatement_typeParameters() {
+    enableGenericMethods = true;
+    FunctionDeclarationStatement statement =
+        parse4("parseFunctionDeclarationStatement", "E f<E>(E p) => p * 2;");
+    expect(statement.functionDeclaration, isNotNull);
+  }
+
   void test_parseFunctionExpression_body_inExpression() {
     FunctionExpression expression =
         parse4("parseFunctionExpression", "(int i) => i++");
     expect(expression.body, isNotNull);
+    expect(expression.typeParameters, isNull);
     expect(expression.parameters, isNotNull);
     expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
   }
+
+  void test_parseFunctionExpression_typeParameters() {
+    enableGenericMethods = true;
+    FunctionExpression expression =
+        parse4("parseFunctionExpression", "<E>(E i) => i++");
+    expect(expression.body, isNotNull);
+    expect(expression.typeParameters, isNotNull);
+    expect(expression.parameters, isNotNull);
+    expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
+  }
 
   void test_parseGetter_nonStatic() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     TypeName returnType = new TypeName(new SimpleIdentifier(null), null);
     MethodDeclaration method = parse("parseGetter", <Object>[
       commentAndMetadata(comment),
       null,
       null,
       returnType
     ], "get a;");
@@ skipping 17 matching lines @@
       null,
       staticKeyword,
       returnType
     ], "get a => 42;");
     expect(method.body, isNotNull);
     expect(method.documentationComment, comment);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, staticKeyword);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
     expect(method.parameters, isNull);
     expect(method.propertyKeyword, isNotNull);
     expect(method.returnType, returnType);
   }
 
   void test_parseIdentifierList_multiple() {
     List<SimpleIdentifier> list = parse4("parseIdentifierList", "a, b, c");
     expect(list, hasLength(3));
   }
 
@@ skipping 564 matching lines @@
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FunctionExpressionInvocation,
         FunctionExpressionInvocation, statement.expression);
     FunctionExpressionInvocation invocation =
         statement.expression as FunctionExpressionInvocation;
     EngineTestCase.assertInstanceOf((obj) => obj is FunctionExpression,
         FunctionExpression, invocation.function);
     FunctionExpression expression = invocation.function as FunctionExpression;
     expect(expression.parameters, isNotNull);
     expect(expression.body, isNotNull);
+    expect(invocation.typeArguments, isNull);
     ArgumentList list = invocation.argumentList;
     expect(list, isNotNull);
     expect(list.arguments, hasLength(1));
   }
 
   void test_parseNonLabeledStatement_null() {
     ExpressionStatement statement = parse4("parseNonLabeledStatement", "null;");
     expect(statement.expression, isNotNull);
   }
 
@@ skipping 97 matching lines @@
     expect(parameter.type, isNull);
     expect(parameter.identifier, isNotNull);
     expect(parameter.parameters, isNull);
   }
 
   void test_parseNormalFormalParameter_function_noType() {
     FunctionTypedFormalParameter parameter =
         parse4("parseNormalFormalParameter", "a())");
     expect(parameter.returnType, isNull);
     expect(parameter.identifier, isNotNull);
+    expect(parameter.typeParameters, isNull);
     expect(parameter.parameters, isNotNull);
   }
 
+  void test_parseNormalFormalParameter_function_noType_typeParameters() {
+    enableGenericMethods = true;
+    FunctionTypedFormalParameter parameter =
+        parse4("parseNormalFormalParameter", "a<E>())");
+    expect(parameter.returnType, isNull);
+    expect(parameter.identifier, isNotNull);
+    expect(parameter.typeParameters, isNotNull);
+    expect(parameter.parameters, isNotNull);
+  }
+
   void test_parseNormalFormalParameter_function_type() {
     FunctionTypedFormalParameter parameter =
         parse4("parseNormalFormalParameter", "A a())");
     expect(parameter.returnType, isNotNull);
     expect(parameter.identifier, isNotNull);
+    expect(parameter.typeParameters, isNull);
     expect(parameter.parameters, isNotNull);
   }
 
+  void test_parseNormalFormalParameter_function_type_typeParameters() {
+    enableGenericMethods = true;
+    FunctionTypedFormalParameter parameter =
+        parse4("parseNormalFormalParameter", "A a<E>())");
+    expect(parameter.returnType, isNotNull);
+    expect(parameter.identifier, isNotNull);
+    expect(parameter.typeParameters, isNotNull);
+    expect(parameter.parameters, isNotNull);
+  }
+
   void test_parseNormalFormalParameter_function_void() {
     FunctionTypedFormalParameter parameter =
         parse4("parseNormalFormalParameter", "void a())");
     expect(parameter.returnType, isNotNull);
     expect(parameter.identifier, isNotNull);
+    expect(parameter.typeParameters, isNull);
     expect(parameter.parameters, isNotNull);
   }
 
+  void test_parseNormalFormalParameter_function_void_typeParameters() {
+    enableGenericMethods = true;
+    FunctionTypedFormalParameter parameter =
+        parse4("parseNormalFormalParameter", "void a<E>())");
+    expect(parameter.returnType, isNotNull);
+    expect(parameter.identifier, isNotNull);
+    expect(parameter.typeParameters, isNotNull);
+    expect(parameter.parameters, isNotNull);
+  }
+
   void test_parseNormalFormalParameter_simple_const_noType() {
     SimpleFormalParameter parameter =
         parse4("parseNormalFormalParameter", "const a)");
     expect(parameter.keyword, isNotNull);
     expect(parameter.type, isNull);
     expect(parameter.identifier, isNotNull);
   }
 
   void test_parseNormalFormalParameter_simple_const_type() {
     SimpleFormalParameter parameter =
@@ skipping 42 matching lines @@
       commentAndMetadata(comment),
       null,
       returnType
     ], "operator +(A a);");
     expect(method.body, isNotNull);
     expect(method.documentationComment, comment);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNotNull);
+    expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, returnType);
   }
 
   void test_parseOptionalReturnType() {
     // TODO(brianwilkerson) Implement tests for this method.
   }
 
   void test_parsePartDirective_part() {
@@ skipping 31 matching lines @@
     IndexExpression expression = parse4("parsePostfixExpression", "a[0]");
     expect(expression.target, isNotNull);
     expect(expression.index, isNotNull);
   }
 
   void test_parsePostfixExpression_none_methodInvocation() {
     MethodInvocation expression = parse4("parsePostfixExpression", "a.m()");
     expect(expression.target, isNotNull);
     expect(expression.operator.type, TokenType.PERIOD);
     expect(expression.methodName, isNotNull);
+    expect(expression.typeArguments, isNull);
     expect(expression.argumentList, isNotNull);
   }
 
   void test_parsePostfixExpression_none_methodInvocation_question_dot() {
     _enableNullAwareOperators = true;
     MethodInvocation expression = parse4('parsePostfixExpression', 'a?.m()');
     expect(expression.target, isNotNull);
     expect(expression.operator.type, TokenType.QUESTION_PERIOD);
     expect(expression.methodName, isNotNull);
+    expect(expression.typeArguments, isNull);
     expect(expression.argumentList, isNotNull);
   }
 
+  void test_parsePostfixExpression_none_methodInvocation_question_dot_typeArguments() {
+    enableGenericMethods = true;
+    _enableNullAwareOperators = true;
+    MethodInvocation expression = parse4('parsePostfixExpression', 'a?.m<E>()');
+    expect(expression.target, isNotNull);
+    expect(expression.operator.type, TokenType.QUESTION_PERIOD);
+    expect(expression.methodName, isNotNull);
+    expect(expression.typeArguments, isNotNull);
+    expect(expression.argumentList, isNotNull);
+  }
+
+  void test_parsePostfixExpression_none_methodInvocation_typeArguments() {
+    enableGenericMethods = true;
+    MethodInvocation expression = parse4("parsePostfixExpression", "a.m<E>()");
+    expect(expression.target, isNotNull);
+    expect(expression.operator.type, TokenType.PERIOD);
+    expect(expression.methodName, isNotNull);
+    expect(expression.typeArguments, isNotNull);
+    expect(expression.argumentList, isNotNull);
+  }
+
   void test_parsePostfixExpression_none_propertyAccess() {
     PrefixedIdentifier expression = parse4("parsePostfixExpression", "a.b");
     expect(expression.prefix, isNotNull);
     expect(expression.identifier, isNotNull);
   }
 
   void test_parsePrefixedIdentifier_noPrefix() {
     String lexeme = "bar";
     SimpleIdentifier identifier = parse4("parsePrefixedIdentifier", lexeme);
     expect(identifier.token, isNotNull);
@@ skipping 247 matching lines @@
       null,
       null,
       returnType
     ], "set a(var x);");
     expect(method.body, isNotNull);
     expect(method.documentationComment, comment);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.propertyKeyword, isNotNull);
     expect(method.returnType, returnType);
   }
 
   void test_parseSetter_static() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     Token staticKeyword = TokenFactory.tokenFromKeyword(Keyword.STATIC);
     TypeName returnType = new TypeName(new SimpleIdentifier(null), null);
     MethodDeclaration method = parse("parseSetter", <Object>[
       commentAndMetadata(comment),
       null,
       staticKeyword,
       returnType
     ], "set a(var x) {}");
     expect(method.body, isNotNull);
     expect(method.documentationComment, comment);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, staticKeyword);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.propertyKeyword, isNotNull);
     expect(method.returnType, returnType);
   }
 
   void test_parseShiftExpression_normal() {
     BinaryExpression expression = parse4("parseShiftExpression", "x << y");
     expect(expression.leftOperand, isNotNull);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.LT_LT);
@@ skipping 31 matching lines @@
         "parseStatement", "C<> c;", [ParserErrorCode.EXPECTED_TYPE_NAME]);
     VariableDeclarationList variables = statement.variables;
     TypeName type = variables.type;
     TypeArgumentList argumentList = type.typeArguments;
     expect(argumentList.leftBracket, isNotNull);
     expect(argumentList.arguments, hasLength(1));
     expect(argumentList.arguments[0].isSynthetic, isTrue);
     expect(argumentList.rightBracket, isNotNull);
   }
 
-  void test_parseStatement_functionDeclaration() {
+  void test_parseStatement_functionDeclaration_noReturnType() {
+    FunctionDeclarationStatement statement =
+        parse4("parseStatement", "f(a, b) {};");
+    expect(statement.functionDeclaration, isNotNull);
+  }
+
+  void test_parseStatement_functionDeclaration_noReturnType_typeParameters() {
+    enableGenericMethods = true;
+    FunctionDeclarationStatement statement =
+        parse4("parseStatement", "f(a, b) {};");
+    expect(statement.functionDeclaration, isNotNull);
+  }
+
+  void test_parseStatement_functionDeclaration_returnType() {
     // TODO(brianwilkerson) Implement more tests for this method.
     FunctionDeclarationStatement statement =
         parse4("parseStatement", "int f(a, b) {};");
     expect(statement.functionDeclaration, isNotNull);
   }
 
+  void test_parseStatement_functionDeclaration_returnType_typeParameters() {
+    enableGenericMethods = true;
+    FunctionDeclarationStatement statement =
+        parse4("parseStatement", "int f<E>(a, b) {};");
+    expect(statement.functionDeclaration, isNotNull);
+  }
+
   void test_parseStatement_mulipleLabels() {
     LabeledStatement statement = parse4("parseStatement", "l: m: return x;");
     expect(statement.labels, hasLength(2));
     expect(statement.statement, isNotNull);
   }
 
   void test_parseStatement_noLabels() {
     parse4("parseStatement", "return x;");
   }
 
@@ skipping 1205 matching lines @@
         new Scanner(null, new CharSequenceReader(source), listener);
     Token tokenStream = scanner.tokenize();
     //
     // Parse the source.
     //
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(
         parser, methodName, <Object>[tokenStream], tokenStream) as Token;
   }
 }