Re-land of CL 2990703002, adding fixes to analyzer_test and error_test.

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';
@@ skipping 4297 matching lines @@
   }
 
   void test_varTypedef() {
     parseCompilationUnit("var typedef F();", [ParserErrorCode.VAR_TYPEDEF]);
   }
 
   void test_voidParameter() {
     createParser('void a)');
     NormalFormalParameter parameter = parser.parseNormalFormalParameter();
     expectNotNullIfNoErrors(parameter);
-    listener.assertErrorsWithCodes([ParserErrorCode.VOID_PARAMETER]);
+    listener.assertNoErrors();
   }
 
   void test_voidVariable_parseClassMember_initializer() {
     createParser('void x = 0;');
     ClassMember member = parser.parseClassMember('C');
     expectNotNullIfNoErrors(member);
-    listener.assertErrorsWithCodes([ParserErrorCode.VOID_VARIABLE]);
+    listener.assertNoErrors();
   }
 
   void test_voidVariable_parseClassMember_noInitializer() {
     createParser('void x;');
     ClassMember member = parser.parseClassMember('C');
     expectNotNullIfNoErrors(member);
-    listener.assertErrorsWithCodes([ParserErrorCode.VOID_VARIABLE]);
+    listener.assertNoErrors();
   }
 
   void test_voidVariable_parseCompilationUnit_initializer() {
-    parseCompilationUnit("void x = 0;", [ParserErrorCode.VOID_VARIABLE]);
+    parseCompilationUnit("void x = 0;");
   }
 
   void test_voidVariable_parseCompilationUnit_noInitializer() {
-    parseCompilationUnit("void x;", [ParserErrorCode.VOID_VARIABLE]);
+    parseCompilationUnit("void x;");
   }
 
   void test_voidVariable_parseCompilationUnitMember_initializer() {
     createParser('void a = 0;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expectNotNullIfNoErrors(member);
-    listener.assertErrorsWithCodes([ParserErrorCode.VOID_VARIABLE]);
+    listener.assertNoErrors();
   }
 
   void test_voidVariable_parseCompilationUnitMember_noInitializer() {
     createParser('void a;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expectNotNullIfNoErrors(member);
-    listener.assertErrorsWithCodes([ParserErrorCode.VOID_VARIABLE]);
+    listener.assertNoErrors();
   }
 
   void test_voidVariable_statement_initializer() {
     parseStatement("void x = 0;");
-    assertErrorsWithCodes([ParserErrorCode.VOID_VARIABLE]);
+    listener.assertNoErrors();
   }
 
   void test_voidVariable_statement_noInitializer() {
     parseStatement("void x;");
-    assertErrorsWithCodes([ParserErrorCode.VOID_VARIABLE]);
+    listener.assertNoErrors();
   }
 
   void test_withBeforeExtends() {
     parseCompilationUnit(
         "class A with B extends C {}", [ParserErrorCode.WITH_BEFORE_EXTENDS]);
   }
 
   void test_withWithoutExtends() {
     createParser('class A with B, C {}');
     ClassDeclaration declaration = parseFullCompilationUnitMember();
@@ skipping 6812 matching lines @@
     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_parseFunctionBody_block() {
     createParser('{}');
     FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
     expectNotNullIfNoErrors(functionBody);
     listener.assertNoErrors();
@@ skipping 276 matching lines @@
     createParser('return x;');
     ReturnStatement statement = parser.parseReturnStatement();
     expectNotNullIfNoErrors(statement);
     listener.assertNoErrors();
     expect(statement.returnKeyword, isNotNull);
     expect(statement.expression, isNotNull);
     expect(statement.semicolon, isNotNull);
   }
 
   void test_parseReturnType_function() {
+    // TODO(eernst): `parseReturnType` eliminated, delete this test?
     createParser('A<B> Function<B>(B)');
-    GenericFunctionType type = parser.parseReturnType(false);
+    GenericFunctionType type = parser.parseTypeAnnotation(false);
     expectNotNullIfNoErrors(type);
     listener.assertNoErrors();
     expect(type.returnType, isNotNull);
     expect(type.typeParameters, isNotNull);
     expect(type.parameters, isNotNull);
   }
 
   void test_parseReturnType_named() {
+    // TODO(eernst): `parseReturnType` eliminated, delete this test?
     createParser('A<B>');
-    TypeName typeName = parser.parseReturnType(false);
+    TypeName typeName = parser.parseTypeAnnotation(false);
     expectNotNullIfNoErrors(typeName);
     listener.assertNoErrors();
     expect(typeName.name, isNotNull);
     expect(typeName.typeArguments, isNotNull);
   }
 
   void test_parseReturnType_void() {
+    // TODO(eernst): `parseReturnType` eliminated, delete this test?
     createParser('void');
-    TypeName typeName = parser.parseReturnType(false);
+    TypeName typeName = parser.parseTypeAnnotation(false);
     expectNotNullIfNoErrors(typeName);
     listener.assertNoErrors();
     expect(typeName.name, isNotNull);
     expect(typeName.typeArguments, isNull);
   }
 
   void test_parseStatement_function_noReturnType() {
     createParser('''
 Function<A>(core.List<core.int> x) m() => null;
 ''');
@@ skipping 489 matching lines @@
   }
 
   void test_skipPrefixedIdentifier_prefixed() {
     createParser('a.b +');
     Token following = parser.skipPrefixedIdentifier(parser.currentToken);
     expect(following, isNotNull);
     expect(following.type, TokenType.PLUS);
   }
 
   void test_skipReturnType_invalid() {
+    // TODO(eernst): `skipReturnType` eliminated, delete this test?
     createParser('+');
-    Token following = parser.skipReturnType(parser.currentToken);
+    Token following = parser.skipTypeAnnotation(parser.currentToken);
     expect(following, isNull);
   }
 
   void test_skipReturnType_type() {
+    // TODO(eernst): `skipReturnType` eliminated, delete this test?
     createParser('C +');
-    Token following = parser.skipReturnType(parser.currentToken);
+    Token following = parser.skipTypeAnnotation(parser.currentToken);
     expect(following, isNotNull);
     expect(following.type, TokenType.PLUS);
   }
 
   void test_skipReturnType_void() {
+    // TODO(eernst): `skipReturnType` eliminated, delete this test?
     createParser('void +');
-    Token following = parser.skipReturnType(parser.currentToken);
+    Token following = parser.skipTypeAnnotation(parser.currentToken);
     expect(following, isNotNull);
     expect(following.type, TokenType.PLUS);
   }
 
   void test_skipSimpleIdentifier_identifier() {
     createParser('i +');
     Token following = parser.skipSimpleIdentifier(parser.currentToken);
     expect(following, isNotNull);
     expect(following.type, TokenType.PLUS);
   }
@@ skipping 3126 matching lines @@
     expectCommentText(typeVariable.documentationComment, '/// Doc');
   }
 
   /**
    * Assert that the given [name] is in declaration context.
    */
   void _assertIsDeclarationName(SimpleIdentifier name) {
     expect(name.inDeclarationContext(), isTrue);
   }
 }