Emit a hint when using generic method comment syntax (issue 30356)

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.
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/dart/ast/token.dart';
+import 'package:analyzer/src/dart/error/hint_codes.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/testing/token_factory.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:front_end/src/scanner/scanner.dart' as fe;
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
@@ skipping 149 matching lines @@
   MapLiteral parseMapLiteral(
       Token token, String typeArgumentsCode, String code);
 
   MapLiteralEntry parseMapLiteralEntry(String code);
 
   Expression parseMultiplicativeExpression(String code);
 
   InstanceCreationExpression parseNewExpression(String code);
 
   NormalFormalParameter parseNormalFormalParameter(String code,
-      {bool inFunctionType: false});
+      {bool inFunctionType: false,
+      List<ErrorCode> errorCodes: const <ErrorCode>[]});
 
   Expression parsePostfixExpression(String code);
 
   Identifier parsePrefixedIdentifier(String code);
 
   Expression parsePrimaryExpression(String code);
 
   Expression parseRelationalExpression(String code);
 
   RethrowExpression parseRethrowExpression(String code);
@@ skipping 423 matching lines @@
     expect(method.parameters, isNotNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNotNull);
   }
 
   void test_parseClassMember_method_generic_comment_noReturnType() {
     enableGenericMethodComments = true;
     createParser('m/*<T>*/() {}');
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     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_comment_parameterType() {
     enableGenericMethodComments = true;
     createParser('m/*<T>*/(dynamic /*=T*/ p) => null;');
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes(
+          [HintCode.GENERIC_METHOD_COMMENT, HintCode.GENERIC_METHOD_COMMENT]);
+    }
     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);
 
     FormalParameterList parameters = method.parameters;
     expect(parameters, isNotNull);
     expect(parameters.parameters, hasLength(1));
     var parameter = parameters.parameters[0] as SimpleFormalParameter;
     var parameterType = parameter.type as TypeName;
     expect(parameterType.name.name, 'T');
 
     expect(method.body, isNotNull);
   }
 
   void test_parseClassMember_method_generic_comment_returnType() {
     enableGenericMethodComments = true;
     createParser('/*=T*/ m/*<T>*/() {}');
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes(
+          [HintCode.GENERIC_METHOD_COMMENT, HintCode.GENERIC_METHOD_COMMENT]);
+    }
     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.returnType as TypeName).name.name, 'T');
     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_comment_returnType_bound() {
     enableGenericMethodComments = true;
     createParser('num/*=T*/ m/*<T extends num>*/() {}');
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes(
+          [HintCode.GENERIC_METHOD_COMMENT, HintCode.GENERIC_METHOD_COMMENT]);
+    }
     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 as TypeName).name.name, 'T');
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
     expect(method.typeParameters, isNotNull);
     TypeParameter tp = method.typeParameters.typeParameters[0];
     expect(tp.name.name, 'T');
     expect(tp.extendsKeyword, isNotNull);
     expect((tp.bound as TypeName).name.name, 'num');
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
 
   void test_parseClassMember_method_generic_comment_returnType_complex() {
     enableGenericMethodComments = true;
     createParser('dynamic /*=Map<int, T>*/ m/*<T>*/() => null;');
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes(
+          [HintCode.GENERIC_METHOD_COMMENT, HintCode.GENERIC_METHOD_COMMENT]);
+    }
     expect(member, new isInstanceOf<MethodDeclaration>());
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
 
     {
       var returnType = method.returnType as TypeName;
       expect(returnType, isNotNull);
@@ skipping 10 matching lines @@
     expect(method.typeParameters, isNotNull);
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
 
   void test_parseClassMember_method_generic_comment_void() {
     enableGenericMethodComments = true;
     createParser('void m/*<T>*/() {}');
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     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);
@@ skipping 299 matching lines @@
     expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
 
   void test_parseClassMember_method_static_generic_comment_returnType() {
     enableGenericMethodComments = true;
     createParser('static /*=T*/ m/*<T>*/() {}');
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes(
+          [HintCode.GENERIC_METHOD_COMMENT, HintCode.GENERIC_METHOD_COMMENT]);
+    }
     expect(member, new isInstanceOf<MethodDeclaration>());
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNotNull);
     expect(method.propertyKeyword, isNull);
     expect(method.returnType, isNotNull);
     expect((method.returnType as TypeName).name.name, 'T');
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
@@ skipping 529 matching lines @@
     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_typeArgumentComments() {
     enableGenericMethodComments = true;
     _validate_assignableExpression_arguments_normal_chain_typeArguments(
-        "a/*<E>*/(b)/*<F>*/(c).d/*<G>*/(e).f");
+        "a/*<E>*/(b)/*<F>*/(c).d/*<G>*/(e).f",
+        usingFastaParser
+            ? []
+            : [
+                HintCode.GENERIC_METHOD_COMMENT,
+                HintCode.GENERIC_METHOD_COMMENT,
+                HintCode.GENERIC_METHOD_COMMENT
+              ]);
   }
 
   void test_assignableExpression_arguments_normal_chain_typeArguments() {
     _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,
@@ skipping 321 matching lines @@
   void test_topLevelFunction_nestedGenericFunction() {
     parseCompilationUnit('''
 void f() {
   void g<T>() {
   }
 }
 ''');
   }
 
   void _validate_assignableExpression_arguments_normal_chain_typeArguments(
-      String code) {
-    PropertyAccess propertyAccess1 = parseExpression(code);
+      String code,
+      [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
+    PropertyAccess propertyAccess1 = parseExpression(code, errorCodes);
     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);
@@ skipping 1232 matching lines @@
     parseStatement("static f() {}");
     assertErrorsWithCodes(
         [ParserErrorCode.LOCAL_FUNCTION_DECLARATION_MODIFIER]);
   }
 
   void test_method_invalidTypeParameterComments() {
     enableGenericMethodComments = 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
-    ]);
+    if (usingFastaParser) {
+      listener.assertErrorsWithCodes([
+        ParserErrorCode.EXPECTED_TOKEN /*>*/,
+        ParserErrorCode.MISSING_IDENTIFIER,
+        ParserErrorCode.EXPECTED_TOKEN /*(*/,
+        ParserErrorCode.EXPECTED_TOKEN /*)*/,
+        ParserErrorCode.MISSING_FUNCTION_BODY
+      ]);
+    } else {
+      listener.assertErrorsWithCodes([
+        ParserErrorCode.EXPECTED_TOKEN /*>*/,
+        ParserErrorCode.MISSING_IDENTIFIER,
+        ParserErrorCode.EXPECTED_TOKEN /*(*/,
+        ParserErrorCode.EXPECTED_TOKEN /*)*/,
+        ParserErrorCode.MISSING_FUNCTION_BODY,
+        HintCode.GENERIC_METHOD_COMMENT
+      ]);
+    }
     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.
@@ skipping 17 matching lines @@
 
     // TODO(jmesserly): ideally we'd be better at parser recovery here.
     // Also, this behavior is slightly different from how we would parse a
     // normal generic method, because we "discover" the comment at a different
     // point in the parser. This has a slight effect on the AST that results
     // from error recovery.
     enableGenericMethodComments = true;
     createParser('f/*<E>*/(dynamic/*=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.MISSING_IDENTIFIER, // `extends` is a keyword
-      ParserErrorCode.EXPECTED_TOKEN, // close paren
-      ParserErrorCode.MISSING_FUNCTION_BODY
-    ]);
+    if (usingFastaParser) {
+      listener.assertErrorsWithCodes([
+        ParserErrorCode.MISSING_IDENTIFIER, // `extends` is a keyword
+        ParserErrorCode.EXPECTED_TOKEN, // comma
+        ParserErrorCode.MISSING_IDENTIFIER, // `extends` is a keyword
+        ParserErrorCode.EXPECTED_TOKEN, // close paren
+        ParserErrorCode.MISSING_FUNCTION_BODY
+      ]);
+    } else {
+      listener.assertErrorsWithCodes([
+        ParserErrorCode.MISSING_IDENTIFIER, // `extends` is a keyword
+        ParserErrorCode.EXPECTED_TOKEN, // comma
+        ParserErrorCode.MISSING_IDENTIFIER, // `extends` is a keyword
+        ParserErrorCode.EXPECTED_TOKEN, // close paren
+        ParserErrorCode.MISSING_FUNCTION_BODY,
+        HintCode.GENERIC_METHOD_COMMENT,
+        HintCode.GENERIC_METHOD_COMMENT
+      ]);
+    }
     expect(member, new isInstanceOf<MethodDeclaration>());
     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
@@ skipping 1190 matching lines @@
     expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void
       test_parseAssignableExpression_expression_args_dot_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parseAssignableExpression('(x)/*<F>*/(y).z', false);
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     var propertyAccess = expression as PropertyAccess;
     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);
@@ skipping 67 matching lines @@
     expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void
       test_parseAssignableExpression_identifier_args_dot_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parseAssignableExpression('x/*<E>*/(y).z', false);
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     var propertyAccess = expression as PropertyAccess;
     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);
   }
@@ skipping 195 matching lines @@
     var section = expression as FunctionExpressionInvocation;
     expect(section.function, new isInstanceOf<IndexExpression>());
     expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
   }
 
   void test_parseCascadeSection_ia_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parseCascadeSection('..[i]/*<E>*/(b)');
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     var section = expression as FunctionExpressionInvocation;
     expect(section.function, new isInstanceOf<IndexExpression>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
   }
 
   void test_parseCascadeSection_ia_typeArguments() {
     Expression expression = parseCascadeSection('..[i]<E>(b)');
     expect(expression, isNotNull);
     assertNoErrors();
@@ skipping 13 matching lines @@
     expect(section.methodName, isNotNull);
     expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_ii_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parseCascadeSection('..a/*<E>*/(b).c/*<F>*/(d)');
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes(
+          [HintCode.GENERIC_METHOD_COMMENT, HintCode.GENERIC_METHOD_COMMENT]);
+    }
     var section = expression as MethodInvocation;
     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() {
@@ skipping 87 matching lines @@
     expect(section.methodName, isNotNull);
     expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_pa_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parseCascadeSection('..a/*<E>*/(b)');
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     var section = expression as MethodInvocation;
     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() {
@@ skipping 17 matching lines @@
     expect(section.function, new isInstanceOf<MethodInvocation>());
     expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_paa_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parseCascadeSection('..a/*<E>*/(b)/*<F>*/(c)');
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes(
+          [HintCode.GENERIC_METHOD_COMMENT, HintCode.GENERIC_METHOD_COMMENT]);
+    }
     var section = expression as FunctionExpressionInvocation;
     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() {
     Expression expression = parseCascadeSection('..a<E>(b)<F>(c)');
     expect(expression, isNotNull);
@@ skipping 14 matching lines @@
     expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_paapaa_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression =
         parseCascadeSection('..a/*<E>*/(b)/*<F>*/(c).d/*<G>*/(e)/*<H>*/(f)');
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([
+        HintCode.GENERIC_METHOD_COMMENT,
+        HintCode.GENERIC_METHOD_COMMENT,
+        HintCode.GENERIC_METHOD_COMMENT,
+        HintCode.GENERIC_METHOD_COMMENT
+      ]);
+    }
     var section = expression as FunctionExpressionInvocation;
     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() {
     Expression expression =
         parseCascadeSection('..a<E>(b)<F>(c).d<G>(e)<H>(f)');
@@ skipping 13 matching lines @@
     var section = expression as PropertyAccess;
     expect(section.target, isNotNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
   void test_parseCascadeSection_pap_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parseCascadeSection('..a/*<E>*/(b).c');
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     var section = expression as PropertyAccess;
     expect(section.target, isNotNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
   void test_parseCascadeSection_pap_typeArguments() {
     Expression expression = parseCascadeSection('..a<E>(b).c');
     expect(expression, isNotNull);
     assertNoErrors();
@@ skipping 38 matching lines @@
     expect(literal.typeArguments, isNotNull);
     expect(literal.leftBracket, isNotNull);
     expect(literal.elements, hasLength(0));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseConstExpression_listLiteral_typed_genericComment() {
     enableGenericMethodComments = true;
     Expression expression = parseConstExpression('const /*<A>*/ []');
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     var literal = expression as ListLiteral;
     expect(literal.constKeyword, isNotNull);
     expect(literal.typeArguments, isNotNull);
     expect(literal.leftBracket, isNotNull);
     expect(literal.elements, hasLength(0));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseConstExpression_listLiteral_untyped() {
     Expression expression = parseConstExpression('const []');
@@ skipping 15 matching lines @@
     expect(literal.leftBracket, isNotNull);
     expect(literal.entries, hasLength(0));
     expect(literal.rightBracket, isNotNull);
     expect(literal.typeArguments, isNotNull);
   }
 
   void test_parseConstExpression_mapLiteral_typed_genericComment() {
     enableGenericMethodComments = true;
     Expression expression = parseConstExpression('const /*<A, B>*/ {}');
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     var literal = expression as MapLiteral;
     expect(literal.leftBracket, isNotNull);
     expect(literal.entries, hasLength(0));
     expect(literal.rightBracket, isNotNull);
     expect(literal.typeArguments, isNotNull);
   }
 
   void test_parseConstExpression_mapLiteral_untyped() {
     Expression expression = parseConstExpression('const {}');
     expect(expression, isNotNull);
@@ skipping 116 matching lines @@
     Expression expression = parseExpression('super.m()');
     var invocation = expression as MethodInvocation;
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.typeArguments, isNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   void test_parseExpression_superMethodInvocation_typeArgumentComments() {
     enableGenericMethodComments = true;
-    Expression expression = parseExpression('super.m/*<E>*/()');
+    Expression expression;
+    expression = parseExpression('super.m/*<E>*/()',
+        usingFastaParser ? [] : [HintCode.GENERIC_METHOD_COMMENT]);
     var invocation = expression as MethodInvocation;
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.typeArguments, isNotNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   void test_parseExpression_superMethodInvocation_typeArguments() {
     Expression expression = parseExpression('super.m<E>()');
     var invocation = expression as MethodInvocation;
@@ skipping 49 matching lines @@
     expect(invocation.methodName, isNotNull);
     expect(invocation.typeArguments, isNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   void
       test_parseExpressionWithoutCascade_superMethodInvocation_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parseExpressionWithoutCascade('super.m/*<E>*/()');
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     var invocation = expression as MethodInvocation;
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.typeArguments, isNotNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   void
       test_parseExpressionWithoutCascade_superMethodInvocation_typeArguments() {
     Expression expression = parseExpressionWithoutCascade('super.m<E>()');
@@ skipping 14 matching lines @@
     expect(expression.typeParameters, isNull);
     expect(expression.parameters, isNotNull);
     expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
   }
 
   void test_parseFunctionExpression_typeParameterComments() {
     enableGenericMethodComments = true;
     FunctionExpression expression =
         parseFunctionExpression('/*<E>*/(/*=E*/ i) => i++');
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes(
+          [HintCode.GENERIC_METHOD_COMMENT, HintCode.GENERIC_METHOD_COMMENT]);
+    }
     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() {
     FunctionExpression expression = parseFunctionExpression('<E>(E i) => i++');
@@ skipping 39 matching lines @@
     expect(expression.argumentList, isNotNull);
   }
 
   void
       test_parseInstanceCreationExpression_qualifiedType_named_typeArgumentComments() {
     enableGenericMethodComments = true;
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
     InstanceCreationExpression expression =
         parseInstanceCreationExpression('A.B/*<E>*/.c()', token);
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     expect(expression.keyword.keyword, Keyword.NEW);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     TypeName type = name.type;
     expect(type, isNotNull);
     expect(type.typeArguments.arguments, hasLength(1));
     expect(name.period, isNotNull);
     expect(name.name, isNotNull);
     expect(expression.argumentList, isNotNull);
   }
@@ skipping 16 matching lines @@
     expect(expression.argumentList, isNotNull);
   }
 
   void
       test_parseInstanceCreationExpression_qualifiedType_typeArgumentComments() {
     enableGenericMethodComments = true;
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
     InstanceCreationExpression expression =
         parseInstanceCreationExpression('A.B/*<E>*/()', token);
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     expect(expression.keyword.keyword, Keyword.NEW);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     TypeName type = name.type;
     expect(type, isNotNull);
     expect(type.typeArguments.arguments, hasLength(1));
     expect(name.period, isNull);
     expect(name.name, isNull);
     expect(expression.argumentList, isNotNull);
   }
@@ skipping 48 matching lines @@
     expect(name.name, isNull);
     expect(expression.argumentList, isNotNull);
   }
 
   void test_parseInstanceCreationExpression_type_named_typeArgumentComments() {
     enableGenericMethodComments = true;
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
     InstanceCreationExpression expression =
         parseInstanceCreationExpression('A/*<B>*/.c()', token);
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     expect(expression.keyword.keyword, Keyword.NEW);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     TypeName type = name.type;
     expect(type, isNotNull);
     expect(type.typeArguments.arguments, hasLength(1));
     expect(name.period, isNotNull);
     expect(name.name, isNotNull);
     expect(expression.argumentList, isNotNull);
   }
@@ skipping 14 matching lines @@
     expect(name.name, isNotNull);
     expect(expression.argumentList, isNotNull);
   }
 
   void test_parseInstanceCreationExpression_type_typeArgumentComments() {
     enableGenericMethodComments = true;
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
     InstanceCreationExpression expression =
         parseInstanceCreationExpression('A/*<B>*/()', token);
     expect(expression, isNotNull);
-    assertNoErrors();
+
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     expect(expression.keyword.keyword, Keyword.NEW);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     TypeName type = name.type;
     expect(type, isNotNull);
     expect(type.typeArguments.arguments, hasLength(1));
     expect(name.period, isNull);
     expect(name.name, isNull);
     expect(expression.argumentList, isNotNull);
   }
@@ skipping 319 matching lines @@
     expect(methodInvocation.methodName, isNotNull);
     expect(methodInvocation.typeArguments, isNull);
     expect(methodInvocation.argumentList, isNotNull);
   }
 
   void
       test_parsePostfixExpression_none_methodInvocation_question_dot_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parsePostfixExpression('a?.m/*<E>*/()');
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     var methodInvocation = expression as MethodInvocation;
     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() {
     Expression expression = parsePostfixExpression('a?.m<E>()');
     expect(expression, isNotNull);
     assertNoErrors();
     var methodInvocation = expression as MethodInvocation;
     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_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parsePostfixExpression('a.m/*<E>*/()');
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     var methodInvocation = expression as MethodInvocation;
     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() {
     Expression expression = parsePostfixExpression('a.m<E>()');
@@ skipping 140 matching lines @@
     assertNoErrors();
     var literal = expression as ListLiteral;
     expect(literal.typeArguments, isNotNull);
     expect(literal.typeArguments.arguments, hasLength(1));
   }
 
   void test_parsePrimaryExpression_listLiteral_typed_genericComment() {
     enableGenericMethodComments = true;
     Expression expression = parsePrimaryExpression('/*<A>*/[ ]');
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     var literal = expression as ListLiteral;
     expect(literal.typeArguments, isNotNull);
     expect(literal.typeArguments.arguments, hasLength(1));
   }
 
   void test_parsePrimaryExpression_mapLiteral() {
     Expression expression = parsePrimaryExpression('{}');
     expect(expression, isNotNull);
     assertNoErrors();
     var literal = expression as MapLiteral;
     expect(literal.typeArguments, isNull);
     expect(literal, isNotNull);
   }
 
   void test_parsePrimaryExpression_mapLiteral_typed() {
     Expression expression = parsePrimaryExpression('<A, B>{}');
     expect(expression, isNotNull);
     assertNoErrors();
     var literal = expression as MapLiteral;
     expect(literal.typeArguments, isNotNull);
     expect(literal.typeArguments.arguments, hasLength(2));
   }
 
   void test_parsePrimaryExpression_mapLiteral_typed_genericComment() {
     enableGenericMethodComments = true;
     Expression expression = parsePrimaryExpression('/*<A, B>*/{}');
     expect(expression, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     var literal = expression as MapLiteral;
     expect(literal.typeArguments, isNotNull);
     expect(literal.typeArguments.arguments, hasLength(2));
   }
 
   void test_parsePrimaryExpression_new() {
     Expression expression = parsePrimaryExpression('new A()');
     expect(expression, isNotNull);
     assertNoErrors();
     var creation = expression as InstanceCreationExpression;
@@ skipping 1656 matching lines @@
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.returnType, isNull);
     expect(functionParameter.identifier, isNotNull);
     expect(functionParameter.typeParameters, isNull);
     expect(functionParameter.parameters, isNotNull);
     expect(functionParameter.question, isNotNull);
   }
 
   void test_parseNormalFormalParameter_function_noType_typeParameterComments() {
     enableGenericMethodComments = true;
-    NormalFormalParameter parameter = parseNormalFormalParameter('a/*<E>*/()');
+    NormalFormalParameter parameter = parseNormalFormalParameter('a/*<E>*/()',
+        errorCodes: usingFastaParser ? [] : [HintCode.GENERIC_METHOD_COMMENT]);
     expect(parameter, isNotNull);
-    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() {
     NormalFormalParameter parameter = parseNormalFormalParameter('a<E>()');
@@ skipping 46 matching lines @@
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.returnType, isNotNull);
     expect(functionParameter.identifier, isNotNull);
     expect(functionParameter.typeParameters, isNull);
     expect(functionParameter.parameters, isNotNull);
     expect(functionParameter.question, isNotNull);
   }
 
   void test_parseNormalFormalParameter_function_type_typeParameterComments() {
     enableGenericMethodComments = true;
-    NormalFormalParameter parameter =
-        parseNormalFormalParameter('A a/*<E>*/()');
+    NormalFormalParameter parameter = parseNormalFormalParameter('A a/*<E>*/()',
+        errorCodes: usingFastaParser ? [] : [HintCode.GENERIC_METHOD_COMMENT]);
     expect(parameter, isNotNull);
-    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() {
@@ skipping 45 matching lines @@
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.returnType, isNotNull);
     expect(functionParameter.identifier, isNotNull);
     expect(functionParameter.typeParameters, isNull);
     expect(functionParameter.parameters, isNotNull);
     expect(functionParameter.question, isNotNull);
   }
 
   void test_parseNormalFormalParameter_function_void_typeParameterComments() {
     enableGenericMethodComments = true;
-    NormalFormalParameter parameter =
-        parseNormalFormalParameter('void a/*<E>*/()');
+    NormalFormalParameter parameter = parseNormalFormalParameter(
+        'void a/*<E>*/()',
+        errorCodes: usingFastaParser ? [] : [HintCode.GENERIC_METHOD_COMMENT]);
     expect(parameter, isNotNull);
-    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() {
@@ skipping 3252 matching lines @@
 
   void test_parseFinalConstVarOrType_void() {
     createParser('void f()');
     FinalConstVarOrType result = parser.parseFinalConstVarOrType(false);
     expectNotNullIfNoErrors(result);
     listener.assertNoErrors();
     expect(result.keyword, isNull);
     expect(result.type, isNotNull);
   }
 
-  void test_parseFinalConstVarOrType_void_noIdentifier() {
-    createParser('void,');
-    FinalConstVarOrType result = parser.parseFinalConstVarOrType(false);
-    expectNotNullIfNoErrors(result);
-    listener.assertErrorsWithCodes(
-        [ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE]);
-  }
-
   void test_parseFinalConstVarOrType_void_identifier() {
     createParser('void x');
     FinalConstVarOrType result = parser.parseFinalConstVarOrType(false);
     expectNotNullIfNoErrors(result);
     listener.assertNoErrors();
     expect(result.keyword, isNull);
     expect(result.type, isNotNull);
   }
 
+  void test_parseFinalConstVarOrType_void_noIdentifier() {
+    createParser('void,');
+    FinalConstVarOrType result = parser.parseFinalConstVarOrType(false);
+    expectNotNullIfNoErrors(result);
+    listener.assertErrorsWithCodes(
+        [ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE]);
+  }
+
   void test_parseFunctionBody_block() {
     createParser('{}');
     FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
     expectNotNullIfNoErrors(functionBody);
     listener.assertNoErrors();
     expect(functionBody, new isInstanceOf<BlockFunctionBody>());
     BlockFunctionBody body = functionBody;
     expect(body.keyword, isNull);
     expect(body.star, isNull);
     expect(body.block, isNotNull);
@@ skipping 1387 matching lines @@
     var statement = parseStatement('void f(int p) => p * 2;')
         as FunctionDeclarationStatement;
     assertNoErrors();
     expect(statement.functionDeclaration, isNotNull);
   }
 
   void test_parseFunctionDeclarationStatement_typeParameterComments() {
     enableGenericMethodComments = true;
     var statement = parseStatement('/*=E*/ f/*<E>*/(/*=E*/ p) => p * 2;')
         as FunctionDeclarationStatement;
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([
+        HintCode.GENERIC_METHOD_COMMENT,
+        HintCode.GENERIC_METHOD_COMMENT,
+        HintCode.GENERIC_METHOD_COMMENT
+      ]);
+    }
     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() {
     var statement =
@@ skipping 300 matching lines @@
     var statement = parseStatement('true;') as ExpressionStatement;
     assertNoErrors();
     expect(statement.expression, isNotNull);
   }
 
   void
       test_parseStatement_functionDeclaration_noReturnType_typeParameterComments() {
     enableGenericMethodComments = true;
     var statement =
         parseStatement('f/*<E>*/(a, b) {}') as FunctionDeclarationStatement;
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     expect(statement.functionDeclaration, isNotNull);
     expect(statement.functionDeclaration.functionExpression.typeParameters,
         isNotNull);
   }
 
   void test_parseStatement_functionDeclaration_noReturnType_typeParameters() {
     var statement =
         parseStatement('f<E>(a, b) {}') as FunctionDeclarationStatement;
     assertNoErrors();
     expect(statement.functionDeclaration, isNotNull);
@@ skipping 245 matching lines @@
     var declarationList = parseVariableDeclarationList('const A a');
     assertNoErrors();
     expect(declarationList.keyword.lexeme, 'const');
     expect(declarationList.type, isNotNull);
     expect(declarationList.variables, hasLength(1));
   }
 
   void test_parseVariableDeclarationListAfterMetadata_const_typeComment() {
     enableGenericMethodComments = true;
     var declarationList = parseVariableDeclarationList('const/*=T*/ a');
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     expect((declarationList.type as TypeName).name.name, 'T');
     expect(declarationList.isConst, true);
   }
 
   void test_parseVariableDeclarationListAfterMetadata_dynamic_typeComment() {
     enableGenericMethodComments = true;
     var declarationList = parseVariableDeclarationList('dynamic/*=T*/ a');
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     expect((declarationList.type as TypeName).name.name, 'T');
     expect(declarationList.keyword, isNull);
   }
 
   void test_parseVariableDeclarationListAfterMetadata_final_noType() {
     var declarationList = parseVariableDeclarationList('final a');
     assertNoErrors();
     expect(declarationList.keyword, isNotNull);
     expect(declarationList.type, isNull);
     expect(declarationList.variables, hasLength(1));
   }
 
   void test_parseVariableDeclarationListAfterMetadata_final_type() {
     var declarationList = parseVariableDeclarationList('final A a');
     assertNoErrors();
     expect(declarationList.keyword.lexeme, 'final');
     expect(declarationList.type, isNotNull);
     expect(declarationList.variables, hasLength(1));
   }
 
   void test_parseVariableDeclarationListAfterMetadata_final_typeComment() {
     enableGenericMethodComments = true;
     var declarationList = parseVariableDeclarationList('final/*=T*/ a');
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     expect((declarationList.type as TypeName).name.name, 'T');
     expect(declarationList.isFinal, true);
   }
 
   void test_parseVariableDeclarationListAfterMetadata_type_multiple() {
     var declarationList = parseVariableDeclarationList('A a, b, c');
     assertNoErrors();
     expect(declarationList.keyword, isNull);
     expect(declarationList.type, isNotNull);
     expect(declarationList.variables, hasLength(3));
   }
 
   void test_parseVariableDeclarationListAfterMetadata_type_single() {
     var declarationList = parseVariableDeclarationList('A a');
     assertNoErrors();
     expect(declarationList.keyword, isNull);
     expect(declarationList.type, isNotNull);
     expect(declarationList.variables, hasLength(1));
   }
 
   void test_parseVariableDeclarationListAfterMetadata_type_typeComment() {
     enableGenericMethodComments = true;
     var declarationList = parseVariableDeclarationList('int/*=T*/ a');
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     expect((declarationList.type as TypeName).name.name, 'T');
     expect(declarationList.keyword, isNull);
   }
 
   void test_parseVariableDeclarationListAfterMetadata_var_multiple() {
     var declarationList = parseVariableDeclarationList('var a, b, c');
     assertNoErrors();
     expect(declarationList.keyword.lexeme, 'var');
     expect(declarationList.type, isNull);
     expect(declarationList.variables, hasLength(3));
   }
 
   void test_parseVariableDeclarationListAfterMetadata_var_single() {
     var declarationList = parseVariableDeclarationList('var a');
     assertNoErrors();
     expect(declarationList.keyword.lexeme, 'var');
     expect(declarationList.type, isNull);
     expect(declarationList.variables, hasLength(1));
   }
 
   void test_parseVariableDeclarationListAfterMetadata_var_typeComment() {
     enableGenericMethodComments = true;
     var declarationList = parseVariableDeclarationList('var/*=T*/ a');
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     expect((declarationList.type as TypeName).name.name, 'T');
     expect(declarationList.keyword, isNull);
   }
 
   void test_parseVariableDeclarationStatementAfterMetadata_multiple() {
     var statement =
         parseStatement('var x, y, z;') as VariableDeclarationStatement;
     assertNoErrors();
     expect(statement.semicolon, isNotNull);
     VariableDeclarationList variableList = statement.variables;
@@ skipping 1350 matching lines @@
     expect(expression.typeParameters, isNotNull);
     expect(expression.parameters, isNotNull);
     expect(declaration.propertyKeyword, isNull);
   }
 
   void test_parseFunctionDeclaration_functionWithTypeParameters_comment() {
     enableGenericMethodComments = true;
     createParser('/// Doc\nT f/*<E>*/() {}');
     FunctionDeclaration declaration = parseFullCompilationUnitMember();
     expect(declaration, isNotNull);
-    assertNoErrors();
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([HintCode.GENERIC_METHOD_COMMENT]);
+    }
     expectCommentText(declaration.documentationComment, '/// Doc');
     expect((declaration.returnType as TypeName).name.name, 'T');
     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);
   }
@@ skipping 12 matching lines @@
     expect(expression.typeParameters, isNull);
     expect(expression.parameters, isNull);
     expect(declaration.propertyKeyword, isNotNull);
   }
 
   void test_parseFunctionDeclaration_getter_generic_comment_returnType() {
     enableGenericMethodComments = true;
     createParser('/*=T*/ f/*<S, T>*/(/*=S*/ s) => null;');
     var member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
-    assertNoErrors();
+
+    if (usingFastaParser) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([
+        HintCode.GENERIC_METHOD_COMMENT,
+        HintCode.GENERIC_METHOD_COMMENT,
+        HintCode.GENERIC_METHOD_COMMENT
+      ]);
+    }
     var functionDeclaration = member as FunctionDeclaration;
     var functionExpression = functionDeclaration.functionExpression;
     expect(functionDeclaration.documentationComment, isNull);
     expect(functionDeclaration.externalKeyword, isNull);
     expect(functionDeclaration.propertyKeyword, isNull);
     expect((functionDeclaration.returnType as TypeName).name.name, 'T');
     expect(functionDeclaration.name, isNotNull);
     expect(functionExpression.typeParameters, isNotNull);
     expect(functionExpression.parameters, isNotNull);
     expect(functionExpression.body, isNotNull);
@@ skipping 504 matching lines @@
     expectCommentText(typeVariable.documentationComment, '/// Doc');
   }
 
   /**
    * Assert that the given [name] is in declaration context.
    */
   void _assertIsDeclarationName(SimpleIdentifier name) {
     expect(name.inDeclarationContext(), isTrue);
   }
 }