Add parser recovery 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser_test;
 
 import 'package:analyzer/src/generated/error.dart';
@@ skipping 2453 matching lines @@
     // Make sure we recovered and parsed "var v" correctly
     ClassDeclaration declaration = unit.declarations[0] as ClassDeclaration;
     NodeList<ClassMember> members = declaration.members;
     ClassMember fieldDecl = members[1];
     EngineTestCase.assertInstanceOf((obj) => obj is FieldDeclaration, FieldDeclaration, fieldDecl);
     NodeList<VariableDeclaration> vars = (fieldDecl as FieldDeclaration).fields.variables;
     expect(vars, hasLength(1));
     expect(vars[0].name.name, "v");
   }
 
+  void test_functionExpression_named() {
+    ParserTestCase.parseExpression("m(f() => 0);", [
+        ParserErrorCode.EXPECTED_TOKEN]);
+  }
+
+  void test_incomplete_conditionalExpression() {
+    ParserTestCase.parseExpression("x ? 0", [
+        ParserErrorCode.EXPECTED_TOKEN,
+        ParserErrorCode.MISSING_IDENTIFIER]);
+  }
+
   void test_incomplete_constructorInitializers_empty() {
     ParserTestCase.parse3(
         "parseClassMember",
         ["C"],
         "C() : {}",
         [ParserErrorCode.MISSING_INITIALIZER]);
   }
 
   void test_incomplete_constructorInitializers_missingEquals() {
     ClassMember member = ParserTestCase.parse3(
@@ skipping 12 matching lines @@
   }
 
   void test_incomplete_constructorInitializers_variable() {
     ParserTestCase.parse3(
         "parseClassMember",
         ["C"],
         "C() : x {}",
         [ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER]);
   }
 
+  void test_incomplete_topLevelFunction() {
+    ParserTestCase.parseCompilationUnit("foo();", [
+        ParserErrorCode.MISSING_FUNCTION_BODY]);
+  }
+
   void test_incomplete_topLevelVariable() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("String", [ParserErrorCode.EXPECTED_EXECUTABLE]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember member = declarations[0];
     EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableDeclaration, TopLevelVariableDeclaration, member);
     NodeList<VariableDeclaration> variables = (member as TopLevelVariableDeclaration).variables.variables;
     expect(variables, hasLength(1));
     SimpleIdentifier name = variables[0].name;
     expect(name.isSynthetic, isTrue);
@@ skipping 103 matching lines @@
     ClassMember classMember = members[0];
     EngineTestCase.assertInstanceOf((obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
     VariableDeclarationList fieldList = (classMember as FieldDeclaration).fields;
     expect((fieldList.keyword as KeywordToken).keyword, Keyword.VAR);
     NodeList<VariableDeclaration> fields = fieldList.variables;
     expect(fields, hasLength(1));
     VariableDeclaration field = fields[0];
     expect(field.name.isSynthetic, isTrue);
   }
 
+  void test_invalidFunctionBodyModifier() {
+    ParserTestCase.parseCompilationUnit("f() sync {}", [
+        ParserErrorCode.MISSING_STAR_AFTER_SYNC]);
+  }
+
   void test_isExpression_noType() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("class Bar<T extends Foo> {m(x){if (x is ) return;if (x is !)}}", [
         ParserErrorCode.EXPECTED_TYPE_NAME,
         ParserErrorCode.EXPECTED_TYPE_NAME,
         ParserErrorCode.MISSING_STATEMENT]);
     ClassDeclaration declaration = unit.declarations[0] as ClassDeclaration;
     MethodDeclaration method = declaration.members[0] as MethodDeclaration;
     BlockFunctionBody body = method.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[1] as IfStatement;
     IsExpression expression = ifStatement.condition as IsExpression;
     expect(expression.expression, isNotNull);
     expect(expression.isOperator, isNotNull);
     expect(expression.notOperator, isNotNull);
     TypeName type = expression.type;
     expect(type, isNotNull);
     expect(type.name.isSynthetic, isTrue);
     EngineTestCase.assertInstanceOf((obj) => obj is EmptyStatement, EmptyStatement, ifStatement.thenStatement);
   }
 
+  void test_keywordInPlaceOfIdentifier() {
+    // TODO(brianwilkerson) We could do better with this.
+    ParserTestCase.parseCompilationUnit("do() {}", [
+        ParserErrorCode.EXPECTED_EXECUTABLE,
+        ParserErrorCode.UNEXPECTED_TOKEN]);
+  }
+
   void test_logicalAndExpression_missing_LHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("&& y", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     expect(expression.leftOperand.isSynthetic, isTrue);
   }
 
   void test_logicalAndExpression_missing_LHS_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("&&", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
@@ skipping 56 matching lines @@
   }
 
   void test_logicalOrExpression_precedence_logicalAnd_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("|| &&", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.rightOperand);
   }
 
+  void test_missing_commaInArgumentList() {
+    ParserTestCase.parseExpression("f(x: 1 y: 2)", [
+        ParserErrorCode.EXPECTED_TOKEN]);
+  }
+
   void test_missingGet() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
 class C {
   int length {}
   void foo() {}
 }''', [ParserErrorCode.MISSING_GET]);
     expect(unit, isNotNull);
     ClassDeclaration classDeclaration = unit.declarations[0] as ClassDeclaration;
     NodeList<ClassMember> members = classDeclaration.members;
     expect(members, hasLength(2));
@@ skipping 152 matching lines @@
 
   void test_typedef_eof() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("typedef n", [
         ParserErrorCode.EXPECTED_TOKEN,
         ParserErrorCode.MISSING_TYPEDEF_PARAMETERS]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember member = declarations[0];
     EngineTestCase.assertInstanceOf((obj) => obj is FunctionTypeAlias, FunctionTypeAlias, member);
   }
+
+  void test_unaryPlus() {
+    ParserTestCase.parseExpression("+2", [
+        ParserErrorCode.MISSING_IDENTIFIER]);
+  }
 }
 
 class ResolutionCopierTest extends EngineTestCase {
   void test_visitAnnotation() {
     String annotationName = "proxy";
     Annotation fromNode = AstFactory.annotation(AstFactory.identifier3(annotationName));
     Element element = ElementFactory.topLevelVariableElement2(annotationName);
     fromNode.element = element;
     Annotation toNode = AstFactory.annotation(AstFactory.identifier3(annotationName));
     ResolutionCopier.copyResolutionData(fromNode, toNode);
@@ skipping 5425 matching lines @@
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(ComplexParserTest);
   runReflectiveTests(ErrorParserTest);
   runReflectiveTests(IncrementalParserTest);
   runReflectiveTests(NonErrorParserTest);
   runReflectiveTests(RecoveryParserTest);
   runReflectiveTests(ResolutionCopierTest);
   runReflectiveTests(SimpleParserTest);
-}
+}