Fix several failing tests

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 11119 matching lines @@
   void test_parseArgumentList_trailing_comma() {
     createParser('(x, y, z,)');
     ArgumentList argumentList = parser.parseArgumentList();
     expectNotNullIfNoErrors(argumentList);
     listener.assertNoErrors();
     NodeList<Expression> arguments = argumentList.arguments;
     expect(arguments, hasLength(3));
   }
 
   void test_parseCombinator_hide() {
-    createParser('hide a;');
+    createParser('hide a');
     Combinator combinator = parser.parseCombinator();
     expectNotNullIfNoErrors(combinator);
     listener.assertNoErrors();
     expect(combinator, new isInstanceOf<HideCombinator>());
     HideCombinator hideCombinator = combinator;
     expect(hideCombinator.keyword, isNotNull);
     expect(hideCombinator.hiddenNames, hasLength(1));
   }
 
   void test_parseCombinator_show() {
-    createParser('show a;');
+    createParser('show a');
     Combinator combinator = parser.parseCombinator();
     expectNotNullIfNoErrors(combinator);
     listener.assertNoErrors();
     expect(combinator, new isInstanceOf<ShowCombinator>());
     ShowCombinator showCombinator = combinator;
     expect(showCombinator.keyword, isNotNull);
     expect(showCombinator.shownNames, hasLength(1));
   }
 
   void test_parseCombinators_h() {
-    createParser('hide a;');
+    createParser('hide a');
     List<Combinator> combinators = parser.parseCombinators();
     expectNotNullIfNoErrors(combinators);
     listener.assertNoErrors();
     expect(combinators, hasLength(1));
     HideCombinator combinator = combinators[0] as HideCombinator;
     expect(combinator, isNotNull);
     expect(combinator.keyword, isNotNull);
     expect(combinator.hiddenNames, hasLength(1));
   }
 
   void test_parseCombinators_hs() {
-    createParser('hide a show b;');
+    createParser('hide a show b');
     List<Combinator> combinators = parser.parseCombinators();
     expectNotNullIfNoErrors(combinators);
     listener.assertNoErrors();
     expect(combinators, hasLength(2));
     HideCombinator hideCombinator = combinators[0] as HideCombinator;
     expect(hideCombinator, isNotNull);
     expect(hideCombinator.keyword, isNotNull);
     expect(hideCombinator.hiddenNames, hasLength(1));
     ShowCombinator showCombinator = combinators[1] as ShowCombinator;
     expect(showCombinator, isNotNull);
     expect(showCombinator.keyword, isNotNull);
     expect(showCombinator.shownNames, hasLength(1));
   }
 
   void test_parseCombinators_hshs() {
-    createParser('hide a show b hide c show d;');
+    createParser('hide a show b hide c show d');
     List<Combinator> combinators = parser.parseCombinators();
     expectNotNullIfNoErrors(combinators);
     listener.assertNoErrors();
     expect(combinators, hasLength(4));
   }
 
   void test_parseCombinators_s() {
-    createParser('show a;');
+    createParser('show a');
     List<Combinator> combinators = parser.parseCombinators();
     expectNotNullIfNoErrors(combinators);
     listener.assertNoErrors();
     expect(combinators, hasLength(1));
     ShowCombinator combinator = combinators[0] as ShowCombinator;
     expect(combinator, isNotNull);
     expect(combinator.keyword, isNotNull);
     expect(combinator.shownNames, hasLength(1));
   }
 
   void test_parseCommentAndMetadata_c() {
-    createParser('/** 1 */ void');
+    createParser('/** 1 */');
     CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
     expectNotNullIfNoErrors(commentAndMetadata);
     listener.assertNoErrors();
     expect(commentAndMetadata.comment, isNotNull);
     expect(commentAndMetadata.metadata, isNull);
   }
 
   void test_parseCommentAndMetadata_cmc() {
-    createParser('/** 1 */ @A /** 2 */ void');
+    createParser('/** 1 */ @A /** 2 */');
     CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
     expectNotNullIfNoErrors(commentAndMetadata);
     listener.assertNoErrors();
     expect(commentAndMetadata.comment, isNotNull);
     expect(commentAndMetadata.metadata, hasLength(1));
   }
 
   void test_parseCommentAndMetadata_cmcm() {
-    createParser('/** 1 */ @A /** 2 */ @B void');
+    createParser('/** 1 */ @A /** 2 */ @B');
     CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
     expectNotNullIfNoErrors(commentAndMetadata);
     listener.assertNoErrors();
     expect(commentAndMetadata.comment, isNotNull);
     expect(commentAndMetadata.metadata, hasLength(2));
   }
 
   void test_parseCommentAndMetadata_cmm() {
-    createParser('/** 1 */ @A @B void');
+    createParser('/** 1 */ @A @B');
     CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
     expectNotNullIfNoErrors(commentAndMetadata);
     listener.assertNoErrors();
     expect(commentAndMetadata.comment, isNotNull);
     expect(commentAndMetadata.metadata, hasLength(2));
   }
 
   void test_parseCommentAndMetadata_m() {
-    createParser('@A void');
+    createParser('@A');
     CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
     expectNotNullIfNoErrors(commentAndMetadata);
     listener.assertNoErrors();
     expect(commentAndMetadata.comment, isNull);
     expect(commentAndMetadata.metadata, hasLength(1));
   }
 
   void test_parseCommentAndMetadata_mcm() {
-    createParser('@A /** 1 */ @B void');
+    createParser('@A /** 1 */ @B');
     CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
     expectNotNullIfNoErrors(commentAndMetadata);
     listener.assertNoErrors();
     expect(commentAndMetadata.comment, isNotNull);
     expect(commentAndMetadata.metadata, hasLength(2));
   }
 
   void test_parseCommentAndMetadata_mcmc() {
-    createParser('@A /** 1 */ @B /** 2 */ void');
+    createParser('@A /** 1 */ @B /** 2 */');
     CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
     expectNotNullIfNoErrors(commentAndMetadata);
     listener.assertNoErrors();
     expect(commentAndMetadata.comment, isNotNull);
     expect(commentAndMetadata.metadata, hasLength(2));
   }
 
   void test_parseCommentAndMetadata_mm() {
-    createParser('@A @B(x) void');
+    createParser('@A @B(x)');
     CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
     expectNotNullIfNoErrors(commentAndMetadata);
     listener.assertNoErrors();
     expect(commentAndMetadata.comment, isNull);
     expect(commentAndMetadata.metadata, hasLength(2));
   }
 
   void test_parseCommentAndMetadata_none() {
-    createParser('void');
+    createParser('');
     CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
     expectNotNullIfNoErrors(commentAndMetadata);
     listener.assertNoErrors();
     expect(commentAndMetadata.comment, isNull);
     expect(commentAndMetadata.metadata, isNull);
   }
 
   void test_parseCommentAndMetadata_singleLine() {
     createParser(r'''
 /// 1
 /// 2
-void''');
+''');
     CommentAndMetadata commentAndMetadata = parser.parseCommentAndMetadata();
     expectNotNullIfNoErrors(commentAndMetadata);
     listener.assertNoErrors();
     expect(commentAndMetadata.comment, isNotNull);
     expect(commentAndMetadata.metadata, isNull);
   }
 
   void test_parseConfiguration_noOperator_dottedIdentifier() {
     createParser("if (a.b) 'c.dart'");
     Configuration configuration = parser.parseConfiguration();
@@ skipping 671 matching lines @@
 
   void test_parseStatements_multiple() {
     parseStatementList("return; return;", 2);
   }
 
   void test_parseStatements_single() {
     parseStatementList("return;", 1);
   }
 
   void test_parseTypeAnnotation_function_noReturnType_noParameters() {
-    createParser('Function() v');
+    createParser('Function()');
     GenericFunctionType functionType = parser.parseTypeAnnotation(false);
     expectNotNullIfNoErrors(functionType);
     listener.assertNoErrors();
     expect(functionType.returnType, isNull);
     expect(functionType.functionKeyword, isNotNull);
     expect(functionType.typeParameters, isNull);
     FormalParameterList parameterList = functionType.parameters;
     expect(parameterList, isNotNull);
     expect(parameterList.parameters, hasLength(0));
   }
 
   void test_parseTypeAnnotation_function_noReturnType_parameters() {
-    createParser('Function(int, int) v');
+    createParser('Function(int, int)');
     GenericFunctionType functionType = parser.parseTypeAnnotation(false);
     expectNotNullIfNoErrors(functionType);
     listener.assertNoErrors();
     expect(functionType.returnType, isNull);
     expect(functionType.functionKeyword, isNotNull);
     expect(functionType.typeParameters, isNull);
     FormalParameterList parameterList = functionType.parameters;
     expect(parameterList, isNotNull);
     NodeList<FormalParameter> parameters = parameterList.parameters;
     expect(parameters, hasLength(2));
@@ skipping 36 matching lines @@
     expect(functionType.functionKeyword, isNotNull);
     TypeParameterList typeParameters = functionType.typeParameters;
     expect(typeParameters, isNotNull);
     expect(typeParameters.typeParameters, hasLength(1));
     FormalParameterList parameterList = functionType.parameters;
     expect(parameterList, isNotNull);
     expect(parameterList.parameters, hasLength(2));
   }
 
   void test_parseTypeAnnotation_function_returnType_classFunction() {
-    createParser('Function v');
+    createParser('Function');
     TypeName functionType = parser.parseTypeAnnotation(false);
     expectNotNullIfNoErrors(functionType);
     listener.assertNoErrors();
   }
 
   void test_parseTypeAnnotation_function_returnType_function() {
-    createParser('A Function(B, C) Function(D) v');
+    createParser('A Function(B, C) Function(D)');
     // TODO(scheglov) improve the test to verify also the node properties
     var functionType = parser.parseTypeAnnotation(false) as GenericFunctionType;
     expectNotNullIfNoErrors(functionType);
     listener.assertNoErrors();
   }
 
   void test_parseTypeAnnotation_function_returnType_noParameters() {
     createParser('List<int> Function()');
     GenericFunctionType functionType = parser.parseTypeAnnotation(false);
     expectNotNullIfNoErrors(functionType);
@@ skipping 28 matching lines @@
 
     expect(parameters[1], new isInstanceOf<SimpleFormalParameter>());
     parameter = parameters[1];
     expect(parameter.identifier, isNotNull);
     expect(parameter.identifier.name, 'i');
     expect(parameter.type, new isInstanceOf<TypeName>());
     expect((parameter.type as TypeName).name.name, 'int');
   }
 
   void test_parseTypeAnnotation_function_returnType_simple() {
-    createParser('A Function(B, C) v');
+    createParser('A Function(B, C)');
     // TODO(scheglov) improve the test to verify also the node properties
     var functionType = parser.parseTypeAnnotation(false) as GenericFunctionType;
     expectNotNullIfNoErrors(functionType);
     listener.assertNoErrors();
   }
 
   void test_parseTypeAnnotation_function_returnType_typeParameters() {
     createParser('List<T> Function<T>()');
     GenericFunctionType functionType = parser.parseTypeAnnotation(false);
     expectNotNullIfNoErrors(functionType);
@@ skipping 18 matching lines @@
     expect(functionType.functionKeyword, isNotNull);
     TypeParameterList typeParameters = functionType.typeParameters;
     expect(typeParameters, isNotNull);
     expect(typeParameters.typeParameters, hasLength(1));
     FormalParameterList parameterList = functionType.parameters;
     expect(parameterList, isNotNull);
     expect(parameterList.parameters, hasLength(2));
   }
 
   void test_parseTypeAnnotation_function_returnType_withArguments() {
-    createParser('A<B> Function(C) v');
+    createParser('A<B> Function(C)');
     // TODO(scheglov) improve this test to verify also the node properties
     var functionType = parser.parseTypeAnnotation(false) as GenericFunctionType;
     expectNotNullIfNoErrors(functionType);
     listener.assertNoErrors();
   }
 
   void test_parseTypeAnnotation_named() {
-    createParser('A<B> v');
+    createParser('A<B>');
     TypeName typeName = parser.parseTypeAnnotation(false);
     expectNotNullIfNoErrors(typeName);
     listener.assertNoErrors();
   }
 
   void test_parseTypeArgumentList_empty() {
     createParser('<>');
     TypeArgumentList argumentList = parser.parseTypeArgumentList();
     expectNotNullIfNoErrors(argumentList);
     listener.assertErrorsWithCodes([ParserErrorCode.EXPECTED_TYPE_NAME]);
@@ skipping 3310 matching lines @@
     expectCommentText(typeVariable.documentationComment, '/// Doc');
   }
 
   /**
    * Assert that the given [name] is in declaration context.
    */
   void _assertIsDeclarationName(SimpleIdentifier name) {
     expect(name.inDeclarationContext(), isTrue);
   }
 }