Enable generic method support by default

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/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/error/error.dart';
@@ skipping 183 matching lines @@
     expect(argumentList4.arguments, hasLength(1));
   }
 
   void test_assignableExpression_arguments_normal_chain_typeArgumentComments() {
     enableGenericMethodComments = true;
     _validate_assignableExpression_arguments_normal_chain_typeArguments(
         "a/*<E>*/(b)/*<F>*/(c).d/*<G>*/(e).f");
   }
 
   void test_assignableExpression_arguments_normal_chain_typeArguments() {
-    enableGenericMethods = true;
     _validate_assignableExpression_arguments_normal_chain_typeArguments(
         "a<E>(b)<F>(c).d<G>(e).f");
   }
 
   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 310 matching lines @@
         BinaryExpression, expression.rightOperand);
   }
 
   void test_shiftExpression_super() {
     BinaryExpression expression = parseExpression("super >> 4 << 3");
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
         BinaryExpression, expression.leftOperand);
   }
 
   void test_topLevelFunction_nestedGenericFunction() {
-    enableGenericMethods = true;
     parseCompilationUnitWithOptions('''
 void f() {
   void g<T>() {
   }
 }
 ''');
   }
 
   void _validate_assignableExpression_arguments_normal_chain_typeArguments(
       String code) {
@@ skipping 1130 matching lines @@
     expect(member, new isInstanceOf<MethodDeclaration>());
     MethodDeclaration method = member;
     expect(method.typeParameters.toString(), '<E, hello>',
         reason: 'parser recovers what it can');
   }
 
   void test_method_invalidTypeParameterExtends() {
     // Regression test for https://github.com/dart-lang/sdk/issues/25739.
 
     // TODO(jmesserly): ideally we'd be better at parser recovery here.
-    enableGenericMethods = true;
     createParser('f<E>(E extends num p);');
     ClassMember member = parser.parseClassMember('C');
     expectNotNullIfNoErrors(member);
     listener.assertErrorsWithCodes([
       ParserErrorCode.MISSING_IDENTIFIER, // `extends` is a keyword
       ParserErrorCode.EXPECTED_TOKEN, // comma
       ParserErrorCode.EXPECTED_TOKEN, // close paren
       ParserErrorCode.MISSING_FUNCTION_BODY
     ]);
     expect(member, new isInstanceOf<MethodDeclaration>());
@@ skipping 25 matching lines @@
     MethodDeclaration method = member;
     expect(method.parameters.toString(), '(E extends, extends)',
         reason: 'parser recovers what it can');
   }
 
   void test_method_invalidTypeParameters() {
     // TODO(jmesserly): ideally we'd be better at parser recovery here.
     // It doesn't try to advance past the invalid token `!` to find the
     // valid `>`. If it did we'd get less cascading errors, at least for this
     // particular example.
-    enableGenericMethods = true;
     createParser('void m<E, hello!>() {}');
     ClassMember member = parser.parseClassMember('C');
     expectNotNullIfNoErrors(member);
     listener.assertErrorsWithCodes([
       ParserErrorCode.EXPECTED_TOKEN /*>*/,
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.EXPECTED_TOKEN /*(*/,
       ParserErrorCode.EXPECTED_TOKEN /*)*/,
       ParserErrorCode.MISSING_FUNCTION_BODY
     ]);
@@ skipping 519 matching lines @@
     MethodInvocation methodInvocation = parser.parseCascadeSection();
     expectNotNullIfNoErrors(methodInvocation);
     listener.assertErrorsWithCodes([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;
     createParser('..<E>()');
     MethodInvocation methodInvocation = parser.parseCascadeSection();
     expectNotNullIfNoErrors(methodInvocation);
     listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
     expect(methodInvocation.target, isNull);
     expect(methodInvocation.methodName.name, "");
     expect(methodInvocation.typeArguments, isNotNull);
     expect(methodInvocation.argumentList.arguments, hasLength(0));
   }
 
@@ skipping 551 matching lines @@
    * list of a constructor.
    */
   bool enableAssertInitializer = false;
 
   /**
    * A flag indicating whether parser is to parse async.
    */
   bool parseAsync = true;
 
   /**
-   * A flag indicating whether generic method support should be enabled for a
-   * specific test.
-   */
-  bool enableGenericMethods = false;
-
-  /**
    * Whether generic method comments should be enabled for the test.
    */
   bool enableGenericMethodComments = false;
 
   /**
    * A flag indicating whether lazy assignment operators should be enabled for
    * the test.
    */
   bool enableLazyAssignmentOperators = false;
 
@@ skipping 43 matching lines @@
     Scanner scanner = new Scanner(source, reader, listener);
     scanner.scanGenericMethodComments = enableGenericMethodComments;
     scanner.scanLazyAssignmentOperators = enableLazyAssignmentOperators;
     Token tokenStream = scanner.tokenize();
     listener.setLineInfo(source, scanner.lineStarts);
     //
     // Create and initialize the parser.
     //
     parser = new Parser(source, listener);
     parser.enableAssertInitializer = enableAssertInitializer;
-    parser.parseGenericMethods = enableGenericMethods;
     parser.parseGenericMethodComments = enableGenericMethodComments;
     parser.parseFunctionBodies = parseFunctionBodies;
     parser.enableNnbd = enableNnbd;
     parser.currentToken = tokenStream;
   }
 
   /**
    * Return an empty CommentAndMetadata object that can be used for testing.
    *
    * @return an empty CommentAndMetadata object that can be used for testing
@@ skipping 65 matching lines @@
     CompilationUnit unit = parser.parseCompilationUnit(token);
     expect(unit, isNotNull);
     listener.assertErrorsWithCodes(errorCodes);
     return unit;
   }
 
   /**
    * Parse the given [code] as a compilation unit.
    */
   static CompilationUnit parseCompilationUnit2(String code,
-      {AnalysisErrorListener listener, bool parseGenericMethods: false}) {
+      {AnalysisErrorListener listener}) {
     listener ??= AnalysisErrorListener.NULL_LISTENER;
     Scanner scanner = new Scanner(null, new CharSequenceReader(code), listener);
     Token token = scanner.tokenize();
     Parser parser = new Parser(null, listener);
-    parser.parseGenericMethods = parseGenericMethods;
     CompilationUnit unit = parser.parseCompilationUnit(token);
     unit.lineInfo = new LineInfo(scanner.lineStarts);
     return unit;
   }
 
   /**
    * Parse the given [source] as a statement. The [errorCodes] are the error
    * codes of the errors that are expected to be found. If
    * [enableLazyAssignmentOperators] is `true`, then lazy assignment operators
    * should be enabled.
@@ skipping 1405 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_noParameters_block() {
     expect(_isFunctionExpression("() {}"), isTrue);
   }
 
   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() {
@@ skipping 358 matching lines @@
     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_args_dot_typeParameters() {
-    enableGenericMethods = true;
     createParser('(x)<F>(y).z');
     Expression expression = parser.parseAssignableExpression(false);
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
     PropertyAccess propertyAccess = expression;
     FunctionExpressionInvocation invocation =
         propertyAccess.target as FunctionExpressionInvocation;
     expect(invocation.function, isNotNull);
     expect(invocation.typeArguments, isNotNull);
@@ skipping 81 matching lines @@
     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_args_dot_typeParameters() {
-    enableGenericMethods = true;
     createParser('x<E>(y).z');
     Expression expression = parser.parseAssignableExpression(false);
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
     PropertyAccess propertyAccess = expression;
     MethodInvocation invocation = propertyAccess.target as MethodInvocation;
     expect(invocation.methodName.name, "x");
     expect(invocation.typeArguments, isNotNull);
     ArgumentList argumentList = invocation.argumentList;
@@ skipping 332 matching lines @@
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
     FunctionExpressionInvocation section = expression;
     expect(section.function, new isInstanceOf<IndexExpression>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
   }
 
   void test_parseCascadeSection_ia_typeArguments() {
-    enableGenericMethods = true;
     createParser('..[i]<E>(b)');
     Expression expression = parser.parseCascadeSection();
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
     FunctionExpressionInvocation section = expression;
     expect(section.function, new isInstanceOf<IndexExpression>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
   }
@@ skipping 23 matching lines @@
     MethodInvocation section = expression;
     expect(section.target, new isInstanceOf<MethodInvocation>());
     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_ii_typeArguments() {
-    enableGenericMethods = true;
     createParser('..a<E>(b).c<F>(d)');
     Expression expression = parser.parseCascadeSection();
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
     MethodInvocation section = expression;
     expect(section.target, new isInstanceOf<MethodInvocation>());
     expect(section.operator, isNotNull);
     expect(section.methodName, isNotNull);
     expect(section.typeArguments, isNotNull);
@@ skipping 49 matching lines @@
     expect(expression, new isInstanceOf<AssignmentExpression>());
     AssignmentExpression section = expression;
     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;
     createParser('..a = 3..m<E>()');
     Expression expression = parser.parseCascadeSection();
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression, new isInstanceOf<AssignmentExpression>());
     AssignmentExpression section = expression;
     expect(section.leftHandSide, isNotNull);
     expect(section.operator, isNotNull);
     Expression rhs = section.rightHandSide;
     EngineTestCase.assertInstanceOf(
@@ skipping 37 matching lines @@
     MethodInvocation section = expression;
     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_pa_typeArguments() {
-    enableGenericMethods = true;
     createParser('..a<E>(b)');
     Expression expression = parser.parseCascadeSection();
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
     MethodInvocation section = expression;
     expect(section.target, isNull);
     expect(section.operator, isNotNull);
     expect(section.methodName, isNotNull);
     expect(section.typeArguments, isNotNull);
@@ skipping 22 matching lines @@
     listener.assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
     FunctionExpressionInvocation section = expression;
     expect(section.function, new isInstanceOf<MethodInvocation>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_paa_typeArguments() {
-    enableGenericMethods = true;
     createParser('..a<E>(b)<F>(c)');
     Expression expression = parser.parseCascadeSection();
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
     FunctionExpressionInvocation section = expression;
     expect(section.function, new isInstanceOf<MethodInvocation>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
@@ skipping 20 matching lines @@
     listener.assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
     FunctionExpressionInvocation section = expression;
     expect(section.function, new isInstanceOf<MethodInvocation>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_paapaa_typeArguments() {
-    enableGenericMethods = true;
     createParser('..a<E>(b)<F>(c).d<G>(e)<H>(f)');
     Expression expression = parser.parseCascadeSection();
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
     FunctionExpressionInvocation section = expression;
     expect(section.function, new isInstanceOf<MethodInvocation>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
@@ skipping 18 matching lines @@
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
     PropertyAccess section = expression;
     expect(section.target, isNotNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
   void test_parseCascadeSection_pap_typeArguments() {
-    enableGenericMethods = true;
     createParser('..a<E>(b).c');
     Expression expression = parser.parseCascadeSection();
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression, new isInstanceOf<PropertyAccess>());
     PropertyAccess section = expression;
     expect(section.target, isNotNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
@@ skipping 480 matching lines @@
     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_noReturnType() {
-    enableGenericMethods = true;
     createParser('m<T>() {}');
     ClassMember member = parser.parseClassMember('C');
     expectNotNullIfNoErrors(member);
     listener.assertNoErrors();
     expect(member, new isInstanceOf<MethodDeclaration>());
     MethodDeclaration method = member;
     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;
     createParser('T m<T>() {}');
     ClassMember member = parser.parseClassMember('C');
     expectNotNullIfNoErrors(member);
     listener.assertNoErrors();
     expect(member, new isInstanceOf<MethodDeclaration>());
     MethodDeclaration method = member;
     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;
     createParser('void m<T>() {}');
     ClassMember member = parser.parseClassMember('C');
     expectNotNullIfNoErrors(member);
     listener.assertNoErrors();
     expect(member, new isInstanceOf<MethodDeclaration>());
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
@@ skipping 1169 matching lines @@
     expectNotNullIfNoErrors(member);
     listener.assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.externalKeyword, isNotNull);
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNull);
   }
 
   void test_parseCompilationUnitMember_function_generic_noReturnType() {
-    enableGenericMethods = true;
     createParser('f<E>() {}');
     CompilationUnitMember member =
         parser.parseCompilationUnitMember(emptyCommentAndMetadata());
     expectNotNullIfNoErrors(member);
     listener.assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.returnType, isNull);
     expect(declaration.functionExpression.typeParameters, isNotNull);
   }
 
   void
       test_parseCompilationUnitMember_function_generic_noReturnType_annotated() {
-    enableGenericMethods = true;
     createParser('f<@a E>() {}');
     CompilationUnitMember member =
         parser.parseCompilationUnitMember(emptyCommentAndMetadata());
     expectNotNullIfNoErrors(member);
     listener.assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.returnType, isNull);
     expect(declaration.functionExpression.typeParameters, isNotNull);
   }
 
   void test_parseCompilationUnitMember_function_generic_returnType() {
-    enableGenericMethods = true;
     createParser('E f<E>() {}');
     CompilationUnitMember member =
         parser.parseCompilationUnitMember(emptyCommentAndMetadata());
     expectNotNullIfNoErrors(member);
     listener.assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.returnType, isNotNull);
     expect(declaration.functionExpression.typeParameters, isNotNull);
   }
 
   void test_parseCompilationUnitMember_function_generic_void() {
-    enableGenericMethods = true;
     createParser('void f<T>(T t) {}');
     CompilationUnitMember member =
         parser.parseCompilationUnitMember(emptyCommentAndMetadata());
     expectNotNullIfNoErrors(member);
     listener.assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNull);
   }
@@ skipping 998 matching lines @@
     Expression expression = parseExpression('super.m/*<E>*/()');
     expect(expression, new isInstanceOf<MethodInvocation>());
     MethodInvocation invocation = expression;
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.typeArguments, isNotNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   void test_parseExpression_superMethodInvocation_typeArguments() {
-    enableGenericMethods = true;
     Expression expression = parseExpression('super.m<E>()');
     expect(expression, new isInstanceOf<MethodInvocation>());
     MethodInvocation invocation = expression;
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.typeArguments, isNotNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   void test_parseExpressionList_multiple() {
@@ skipping 62 matching lines @@
     expect(expression, new isInstanceOf<MethodInvocation>());
     MethodInvocation invocation = expression;
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.typeArguments, isNotNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   void
       test_parseExpressionWithoutCascade_superMethodInvocation_typeArguments() {
-    enableGenericMethods = true;
     createParser('super.m<E>()');
     Expression expression = parser.parseExpressionWithoutCascade();
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
     MethodInvocation invocation = expression;
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.typeArguments, isNotNull);
     expect(invocation.argumentList, isNotNull);
@@ skipping 952 matching lines @@
     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);
     createParser('f<E>() {}');
     FunctionDeclaration declaration = parser.parseFunctionDeclaration(
         commentAndMetadata(comment), null, returnType);
     expectNotNullIfNoErrors(declaration);
     listener.assertNoErrors();
     expect(declaration.documentationComment, comment);
     expect(declaration.returnType, returnType);
     expect(declaration.name, isNotNull);
@@ skipping 81 matching lines @@
     listener.assertNoErrors();
     FunctionDeclaration f = statement.functionDeclaration;
     expect(f, isNotNull);
     expect(f.functionExpression.typeParameters, isNotNull);
     expect(f.returnType, isNotNull);
     SimpleFormalParameter p = f.functionExpression.parameters.parameters[0];
     expect(p.type, isNotNull);
   }
 
   void test_parseFunctionDeclarationStatement_typeParameters() {
-    enableGenericMethods = true;
     createParser('E f<E>(E p) => p * 2;');
     FunctionDeclarationStatement statement =
         parser.parseFunctionDeclarationStatement();
     expectNotNullIfNoErrors(statement);
     listener.assertNoErrors();
     expect(statement.functionDeclaration, isNotNull);
     expect(statement.functionDeclaration.functionExpression.typeParameters,
         isNotNull);
   }
 
@@ skipping 16 matching lines @@
     listener.assertNoErrors();
     expect(expression.body, isNotNull);
     expect(expression.typeParameters, isNotNull);
     expect(expression.parameters, isNotNull);
     expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
     SimpleFormalParameter p = expression.parameters.parameters[0];
     expect(p.type, isNotNull);
   }
 
   void test_parseFunctionExpression_typeParameters() {
-    enableGenericMethods = true;
     createParser('<E>(E i) => i++');
     FunctionExpression expression = parser.parseFunctionExpression();
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression.body, isNotNull);
     expect(expression.typeParameters, isNotNull);
     expect(expression.parameters, isNotNull);
     expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
   }
 
@@ skipping 1223 matching lines @@
     listener.assertNoErrors();
     expect(parameter, new isInstanceOf<FunctionTypedFormalParameter>());
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.returnType, isNull);
     expect(functionParameter.identifier, isNotNull);
     expect(functionParameter.typeParameters, isNotNull);
     expect(functionParameter.parameters, isNotNull);
   }
 
   void test_parseNormalFormalParameter_function_noType_typeParameters() {
-    enableGenericMethods = true;
     createParser('a<E>())');
     NormalFormalParameter parameter = parser.parseNormalFormalParameter();
     expectNotNullIfNoErrors(parameter);
     listener.assertNoErrors();
     expect(parameter, new isInstanceOf<FunctionTypedFormalParameter>());
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.returnType, isNull);
     expect(functionParameter.identifier, isNotNull);
     expect(functionParameter.typeParameters, isNotNull);
     expect(functionParameter.parameters, isNotNull);
     expect(functionParameter.question, isNull);
     expect(functionParameter.question, isNull);
   }
 
   void
       test_parseNormalFormalParameter_function_noType_typeParameters_nullable() {
-    enableGenericMethods = true;
     enableNnbd = true;
     createParser('a<E>()?)');
     NormalFormalParameter parameter = parser.parseNormalFormalParameter();
     expectNotNullIfNoErrors(parameter);
     listener.assertNoErrors();
     expect(parameter, new isInstanceOf<FunctionTypedFormalParameter>());
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.returnType, isNull);
     expect(functionParameter.identifier, isNotNull);
     expect(functionParameter.typeParameters, isNotNull);
@@ skipping 39 matching lines @@
     expect(parameter, new isInstanceOf<FunctionTypedFormalParameter>());
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.returnType, isNotNull);
     expect(functionParameter.identifier, isNotNull);
     expect(functionParameter.typeParameters, isNotNull);
     expect(functionParameter.parameters, isNotNull);
     expect(functionParameter.question, isNull);
   }
 
   void test_parseNormalFormalParameter_function_type_typeParameters() {
-    enableGenericMethods = true;
     createParser('A a<E>())');
     NormalFormalParameter parameter = parser.parseNormalFormalParameter();
     expectNotNullIfNoErrors(parameter);
     listener.assertNoErrors();
     expect(parameter, new isInstanceOf<FunctionTypedFormalParameter>());
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.returnType, isNotNull);
     expect(functionParameter.identifier, isNotNull);
     expect(functionParameter.typeParameters, isNotNull);
     expect(functionParameter.parameters, isNotNull);
     expect(functionParameter.question, isNull);
   }
 
   void test_parseNormalFormalParameter_function_type_typeParameters_nullable() {
-    enableGenericMethods = true;
     enableNnbd = true;
     createParser('A a<E>()?)');
     NormalFormalParameter parameter = parser.parseNormalFormalParameter();
     expectNotNullIfNoErrors(parameter);
     listener.assertNoErrors();
     expect(parameter, new isInstanceOf<FunctionTypedFormalParameter>());
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.returnType, isNotNull);
     expect(functionParameter.identifier, isNotNull);
     expect(functionParameter.typeParameters, isNotNull);
@@ skipping 39 matching lines @@
     expect(parameter, new isInstanceOf<FunctionTypedFormalParameter>());
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.returnType, isNotNull);
     expect(functionParameter.identifier, isNotNull);
     expect(functionParameter.typeParameters, isNotNull);
     expect(functionParameter.parameters, isNotNull);
     expect(functionParameter.question, isNull);
   }
 
   void test_parseNormalFormalParameter_function_void_typeParameters() {
-    enableGenericMethods = true;
     createParser('void a<E>())');
     NormalFormalParameter parameter = parser.parseNormalFormalParameter();
     expectNotNullIfNoErrors(parameter);
     listener.assertNoErrors();
     expect(parameter, new isInstanceOf<FunctionTypedFormalParameter>());
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.returnType, isNotNull);
     expect(functionParameter.identifier, isNotNull);
     expect(functionParameter.typeParameters, isNotNull);
     expect(functionParameter.parameters, isNotNull);
     expect(functionParameter.question, isNull);
   }
 
   void test_parseNormalFormalParameter_function_void_typeParameters_nullable() {
-    enableGenericMethods = true;
     enableNnbd = true;
     createParser('void a<E>()?)');
     NormalFormalParameter parameter = parser.parseNormalFormalParameter();
     expectNotNullIfNoErrors(parameter);
     listener.assertNoErrors();
     expect(parameter, new isInstanceOf<FunctionTypedFormalParameter>());
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.returnType, isNotNull);
     expect(functionParameter.identifier, isNotNull);
     expect(functionParameter.typeParameters, isNotNull);
@@ skipping 194 matching lines @@
     MethodInvocation methodInvocation = expression;
     expect(methodInvocation.target, isNotNull);
     expect(methodInvocation.operator.type, TokenType.QUESTION_PERIOD);
     expect(methodInvocation.methodName, isNotNull);
     expect(methodInvocation.typeArguments, isNotNull);
     expect(methodInvocation.argumentList, isNotNull);
   }
 
   void
       test_parsePostfixExpression_none_methodInvocation_question_dot_typeArguments() {
-    enableGenericMethods = true;
     createParser('a?.m<E>()');
     Expression expression = parser.parsePostfixExpression();
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
     MethodInvocation methodInvocation = expression;
     expect(methodInvocation.target, isNotNull);
     expect(methodInvocation.operator.type, TokenType.QUESTION_PERIOD);
     expect(methodInvocation.methodName, isNotNull);
     expect(methodInvocation.typeArguments, isNotNull);
@@ skipping 10 matching lines @@
     expect(expression, new isInstanceOf<MethodInvocation>());
     MethodInvocation methodInvocation = expression;
     expect(methodInvocation.target, isNotNull);
     expect(methodInvocation.operator.type, TokenType.PERIOD);
     expect(methodInvocation.methodName, isNotNull);
     expect(methodInvocation.typeArguments, isNotNull);
     expect(methodInvocation.argumentList, isNotNull);
   }
 
   void test_parsePostfixExpression_none_methodInvocation_typeArguments() {
-    enableGenericMethods = true;
     createParser('a.m<E>()');
     Expression expression = parser.parsePostfixExpression();
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression, new isInstanceOf<MethodInvocation>());
     MethodInvocation methodInvocation = expression;
     expect(methodInvocation.target, isNotNull);
     expect(methodInvocation.operator.type, TokenType.PERIOD);
     expect(methodInvocation.methodName, isNotNull);
     expect(methodInvocation.typeArguments, isNotNull);
@@ skipping 83 matching lines @@
     Expression expression = parser.parsePrimaryExpression();
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpression>());
     FunctionExpression functionExpression = expression;
     expect(functionExpression.parameters, isNotNull);
     expect(functionExpression.body, isNotNull);
   }
 
   void test_parsePrimaryExpression_genericFunctionExpression() {
-    enableGenericMethods = true;
     createParser('<X, Y>(Map<X, Y> m, X x) => m[x]');
     Expression expression = parser.parsePrimaryExpression();
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression, new isInstanceOf<FunctionExpression>());
     FunctionExpression function = expression;
     expect(function.typeParameters, isNotNull);
   }
 
   void test_parsePrimaryExpression_hex() {
@@ skipping 494 matching lines @@
     listener.assertNoErrors();
     expect(statement, new isInstanceOf<FunctionDeclarationStatement>());
     FunctionDeclarationStatement declaration = statement;
     expect(declaration.functionDeclaration, isNotNull);
     expect(declaration.functionDeclaration.functionExpression.typeParameters,
         isNotNull);
   }
 
   @failingTest
   void test_parseStatement_functionDeclaration_noReturnType_typeParameters() {
-    enableGenericMethods = true;
     createParser('f<E>(a, b) {};');
     Statement statement = parser.parseStatement2();
     expectNotNullIfNoErrors(statement);
     listener.assertNoErrors();
     expect(statement, new isInstanceOf<FunctionDeclarationStatement>());
     FunctionDeclarationStatement declaration = statement;
     expect(declaration.functionDeclaration, isNotNull);
   }
 
   void test_parseStatement_functionDeclaration_returnType() {
     // TODO(brianwilkerson) Implement more tests for this method.
     createParser('int f(a, b) {};');
     Statement statement = parser.parseStatement2();
     expectNotNullIfNoErrors(statement);
     listener.assertNoErrors();
     expect(statement, new isInstanceOf<FunctionDeclarationStatement>());
     FunctionDeclarationStatement declaration = statement;
     expect(declaration.functionDeclaration, isNotNull);
   }
 
   void test_parseStatement_functionDeclaration_returnType_typeParameters() {
-    enableGenericMethods = true;
     createParser('int f<E>(a, b) {};');
     Statement statement = parser.parseStatement2();
     expectNotNullIfNoErrors(statement);
     listener.assertNoErrors();
     expect(statement, new isInstanceOf<FunctionDeclarationStatement>());
     FunctionDeclarationStatement declaration = statement;
     expect(declaration.functionDeclaration, isNotNull);
   }
 
   void test_parseStatement_mulipleLabels() {
@@ skipping 1554 matching lines @@
   CompilationUnit _parseDirectives(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
     createParser(source);
     CompilationUnit unit = parser.parseDirectives2();
     expect(unit, isNotNull);
     expect(unit.declarations, hasLength(0));
     listener.assertErrorsWithCodes(errorCodes);
     return unit;
   }
 }