Triage the newly added tests for Fasta

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 9152 matching lines @@
         BinaryExpression, expression.leftOperand);
   }
 
   void test_classTypeAlias_withBody() {
     parseCompilationUnit(r'''
 class A {}
 class B = Object with A {}''', [ParserErrorCode.EXPECTED_TOKEN]);
   }
 
   void test_conditionalExpression_missingElse() {
-    createParser('x ? y :');
-    Expression expression = parser.parseConditionalExpression();
+    Expression expression =
+        parseExpression('x ? y :', [ParserErrorCode.MISSING_IDENTIFIER]);
     expectNotNullIfNoErrors(expression);
-    listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
     expect(expression, new isInstanceOf<ConditionalExpression>());
     ConditionalExpression conditionalExpression = expression;
     expect(conditionalExpression.elseExpression,
         new isInstanceOf<SimpleIdentifier>());
     expect(conditionalExpression.elseExpression.isSynthetic, isTrue);
   }
 
   void test_conditionalExpression_missingThen() {
-    createParser('x ? : z');
-    Expression expression = parser.parseConditionalExpression();
+    Expression expression =
+        parseExpression('x ? : z', [ParserErrorCode.MISSING_IDENTIFIER]);
     expectNotNullIfNoErrors(expression);
-    listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
     expect(expression, new isInstanceOf<ConditionalExpression>());
     ConditionalExpression conditionalExpression = expression;
     expect(conditionalExpression.thenExpression,
         new isInstanceOf<SimpleIdentifier>());
     expect(conditionalExpression.thenExpression.isSynthetic, isTrue);
   }
 
   void test_declarationBeforeDirective() {
     CompilationUnit unit = parseCompilationUnit(
         "class foo { } import 'bar.dart';",
@@ skipping 66 matching lines @@
     BinaryExpression expression = parseExpression("super ==  ==", [
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND
     ]);
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
         BinaryExpression, expression.leftOperand);
   }
 
   void test_expressionList_multiple_end() {
-    createParser(', 2, 3, 4');
-    List<Expression> result = parser.parseExpressionList();
+    List<Expression> result = parseExpressionList(', 2, 3, 4');
     expectNotNullIfNoErrors(result);
     listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
     expect(result, hasLength(4));
     Expression syntheticExpression = result[0];
     EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
         SimpleIdentifier, syntheticExpression);
     expect(syntheticExpression.isSynthetic, isTrue);
   }
 
   void test_expressionList_multiple_middle() {
-    createParser('1, 2, , 4');
-    List<Expression> result = parser.parseExpressionList();
+    List<Expression> result = parseExpressionList('1, 2, , 4');
     expectNotNullIfNoErrors(result);
     listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
     expect(result, hasLength(4));
     Expression syntheticExpression = result[2];
     EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
         SimpleIdentifier, syntheticExpression);
     expect(syntheticExpression.isSynthetic, isTrue);
   }
 
   void test_expressionList_multiple_start() {
-    createParser('1, 2, 3,');
-    List<Expression> result = parser.parseExpressionList();
+    List<Expression> result = parseExpressionList('1, 2, 3,');
     expectNotNullIfNoErrors(result);
     listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
     expect(result, hasLength(4));
     Expression syntheticExpression = result[3];
     EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
         SimpleIdentifier, syntheticExpression);
     expect(syntheticExpression.isSynthetic, isTrue);
   }
 
   void test_functionExpression_in_ConstructorFieldInitializer() {
@@ skipping 2599 matching lines @@
     expectNotNullIfNoErrors(modifiers);
     listener.assertNoErrors();
     expect(modifiers.varKeyword, isNotNull);
   }
 
   void test_parseOptionalReturnType() {
     // TODO(brianwilkerson) Implement tests for this method.
   }
 
   void test_parseReturnStatement_noValue() {
-    createParser('return;');
-    ReturnStatement statement = parser.parseReturnStatement();
+    ReturnStatement statement = parseStatement('return;');
     expectNotNullIfNoErrors(statement);
     listener.assertNoErrors();
     expect(statement.returnKeyword, isNotNull);
     expect(statement.expression, isNull);
     expect(statement.semicolon, isNotNull);
   }
 
   void test_parseReturnStatement_value() {
-    createParser('return x;');
-    ReturnStatement statement = parser.parseReturnStatement();
+    ReturnStatement statement = parseStatement('return x;');
     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)');
@@ skipping 3545 matching lines @@
     expectCommentText(typeVariable.documentationComment, '/// Doc');
   }
 
   /**
    * Assert that the given [name] is in declaration context.
    */
   void _assertIsDeclarationName(SimpleIdentifier name) {
     expect(name.inDeclarationContext(), isTrue);
   }
 }